> This page is for version v1.3 (default).
> For other versions, use one of these documentation indexes:
> - v1.3 (default): https://docs.twelvelabs.io/v1.3/llms.txt

> For clean Markdown of any page, append .md to the page URL.
> For a complete documentation index, see https://docs.twelvelabs.io/llms.txt.
> For AI client integration (Claude Code, Cursor, etc.), connect to the MCP server at https://docs.twelvelabs.io/_mcp/server.

# Retrieve task status and results

GET https://api.twelvelabs.io/v1.3/embed-v2/tasks/{task_id}

This method retrieves the status and the results of an async embedding task.

Invoke this method repeatedly until the `status` field is `ready` or `failed`. When the status is `ready`, use the embeddings from the response. When the status is `failed`, the `error.message` field contains the reason.

Embeddings are stored for seven days.

Reference: https://docs.twelvelabs.io/api-reference/create-embeddings-v2/retrieve-embeddings

## Authentication

- `x-api-key` header (required) — Your API key. You can find your API key on the API Keys page.

## Request

### Path parameters

- `task_id` (string, required) — The unique identifier of the embedding task.

## Response

### 200

Task status and results retrieved successfully

- `_id` (string, required) — The unique identifier of the embedding task.
- `status` (enum, required) — The current status of the task. **Values**: - `processing`: The platform is creating the embeddings - `ready`: Processing is complete. Embeddings are available in the `data` field - `failed`: The task failed. The `data` field is `null`, and the [`error.message`](/v1.3/api-reference/create-embeddings-v2/retrieve-embeddings#response.body.error.message) field contains the reason
  - Allowed values: `processing`, `ready`, `failed`
- `data` (list of EmbeddingData, required, nullable) — An object containing the embedding results, or `null` otherwise.
- `created_at` (string, optional) — A string representing the date and time, in RFC 3339 format (“YYYY-MM-DDTHH:mm:ssZ”), when the resource was created.
- `updated_at` (string, optional) — A string representing the date and time, in RFC 3339 format (“YYYY-MM-DDTHH:mm:ssZ”), when the resource was last updated.
- `usage` (EmbeddingUsage, optional) — Token counts for the request. Only Marengo 3.5 returns this field.
- `metadata` (EmbeddingTaskMediaMetadata, optional) — Metadata for the media input.
- `error` (EmbeddingTaskResponseError, optional) — An object describing why the embedding task failed. Present only when `status` is `failed`. Omitted otherwise.

## Errors

### 404 Not Found Error

Task not found

- `error` (ErrorResponseError, required)

## Types

### EmbeddingData

An embedding with its metadata.

- `embedding` (list of double, required) — The embedding vector for the content.
- `embedding_uncertainty` (list of double, optional) — A per-dimension uncertainty vector with the same length as the `embedding` array. A higher value indicates lower confidence in that dimension. Present when the request sets [`embedding_uncertainty: true`](/v1.3/api-reference/create-embeddings-v2/create-embeddings#request.body.embedding-uncertainty). Only Marengo 3.5 returns this field.
- `embedding_option` (enum, optional, nullable) — The type of the embedding. **Values**: - `visual`: Embedding based on visual content (a video, a page of a PDF file, or an image embedded asynchronously). - `audio`: Embedding based on audio content. - `text`: Embedding based on the text content of a PDF, plain text, or Markdown file embedded asynchronously. - `transcription`: Embedding based on transcribed speech. Returned only for content embedded with Marengo 3.0. - `fused`: Embedding based on a combination of the modalities specified in the request. The platform returns this embedding only for video and audio input, and only when the `embedding_type` parameter includes the `fused_embedding` value. - `null`: For text embeddings and images embedded synchronously.
  - Allowed values: `visual`, `audio`, `transcription`, `text`, `fused`
- `embedding_scope` (enum, optional, nullable) — The scope for which the embedding was generated. **Values**: - `clip`: Embedding for a segment. For video and audio input, one embedding per detected segment. - `page`: Embedding for one page of a PDF file embedded asynchronously, or for one quadrant of a page when the request sets [`document.segmentation.spatial.strategy`](/v1.3/api-reference/create-embeddings-v2/create-async-embedding-task#request.body.document.segmentation.spatial.strategy) to `quadrants`. With that strategy, five entries share the same scope and page numbers, so read the `quadrant` field to tell them apart: the whole-page entry has no `quadrant` value. - `chunk`: Embedding for one chunk of whole sentences from a plain text or Markdown file embedded asynchronously. Read the `chunk_index` field for the position of the chunk in the file. - `asset`: Embedding for the entire file. For video and audio input, use this scope for content up to 10-30 seconds to maintain optimal performance. - `null`: For text embeddings and images embedded synchronously. When you request the `local` scope, the platform returns `clip` for audio and video, `page` for PDF files, and `chunk` for plain text and Markdown files. For audio, video, and document input, the `metadata.embedding_scopes` field contains the scopes you requested.
  - Allowed values: `clip`, `page`, `chunk`, `asset`
- `start_sec` (double, optional, nullable) — The start time in seconds for this segment. This field is `null` for text and image embeddings.
- `end_sec` (double, optional, nullable) — The end time in seconds for this segment. This field is `null` for text and image embeddings.
- `start_page_number` (integer, optional, nullable) — The first page this embedding covers, counting from 1. The platform returns this field only for page-level embeddings of a PDF file, and `null` in every other case.
- `end_page_number` (integer, optional, nullable) — The last page this embedding covers, counting from 1 and including that page. This field matches the `start_page_number` field when the embedding covers a single page. The platform returns this field only for page-level embeddings of a PDF file, and `null` in every other case.
- `quadrant` (enum, optional, nullable) — The quarter of the page this embedding covers. The platform returns this field only when the request sets [`document.segmentation.spatial.strategy`](/v1.3/api-reference/create-embeddings-v2/create-async-embedding-task#request.body.document.segmentation.spatial.strategy) to `quadrants`, and only on the four quadrant embeddings of a page. This field is `null` on the whole-page embedding and in every other case.
  - Allowed values: `top_left`, `top_right`, `bottom_left`, `bottom_right`
- `chunk_index` (integer, optional, nullable) — The position of this chunk in the file, counting from 0. The platform returns this field only on `chunk`-scope embeddings of a plain text or Markdown file, and `null` in every other case. Read this field rather than the position of the entry in the `data` array, which provides no ordering guarantee.

### EmbeddingUsage

Token counts for the request. Only Marengo 3.5 returns this object.

- `input_tokens` (map from string to integer, required) — The number of tokens the request used. Each key names a type of content the request processed, and each value is the token count for that content. The platform reports the content types your request actually used. Each key is one of the following: `video`, `audio`, `image`, `document`, or `text`. Read the keys the response returns rather than assuming a fixed set.
- `truncated` (boolean, required) — Whether the input was truncated to fit within the token limit.
- `truncation_reason` (enum, optional) — The reason the input was truncated. Present only when the `truncated` field is `true`. **Values**: - `model_context_window`: The input exceeded the context window of the model.
  - Allowed values: `model_context_window`

### EmbeddingTaskMediaMetadata

Metadata for the media input.

- `input_type`: `audio` (audio)
  - `duration` (double, required) — The duration of the audio in seconds.
  - `embedding_options` (list of string, required) — The `embedding_option` values used to generate the embedding.
  - `embedding_scopes` (list of enum, required) — The `embedding_scope` values used to generate the embedding.
    - Allowed values: `clip`, `local`, `asset`
  - `embedding_dimension` (integer, optional) — The number of dimensions for each embedding in this response. Only Marengo 3.5 returns this field.
  - `end_offset_sec` (double, optional) — The end offset in seconds.
  - `input_filename` (string, optional) — The name of the audio file.
  - `input_url` (string, optional) — The publicly accessible URL for the audio file.
  - `start_offset_sec` (double, optional) — The start offset in seconds.
- `input_type`: `video` (video)
  - `duration` (double, required) — The duration of the video in seconds.
  - `embedding_options` (list of string, required) — The `embedding_option` values used to generate the embedding.
  - `embedding_scopes` (list of enum, required) — The `embedding_scope` values used to generate the embedding.
    - Allowed values: `clip`, `local`, `asset`
  - `clip_length` (integer, optional) — Length of each video clip in seconds. Only available for fixed segmentation.
  - `embedding_dimension` (integer, optional) — The number of dimensions for each embedding in this response. Only Marengo 3.5 returns this field.
  - `end_offset_sec` (double, optional) — The end offset in seconds.
  - `input_filename` (string, optional) — The name of the video file.
  - `input_url` (string, optional) — The publicly accessible URL for the video file.
  - `start_offset_sec` (double, optional) — The start offset in seconds.
- `input_type`: `document` (document)
  - `embedding_dimension` (integer, optional) — The number of dimensions for each embedding in this response. Only Marengo 3.5 returns this field.
  - `embedding_options` (list of string, optional) — The `embedding_option` values used to generate the embedding.
  - `embedding_scopes` (list of enum, optional) — The `embedding_scope` values used to generate the embedding.
    - Allowed values: `local`, `asset`
  - `input_filename` (string, optional) — The name of the document file.
  - `input_url` (string, optional) — The publicly accessible URL for the document file.
- `input_type`: `image` (image)
  - `embedding_dimension` (integer, optional) — The number of dimensions for each embedding in this response. Only Marengo 3.5 returns this field.
  - `embedding_options` (list of string, optional) — The `embedding_option` values used to generate the embedding. Always `["visual"]`.
  - `embedding_scopes` (list of enum, optional) — The `embedding_scope` values used to generate the embedding. Always `["asset"]`.
    - Allowed values: `asset`
  - `input_filename` (string, optional) — The name of the image file.
  - `input_url` (string, optional) — The publicly accessible URL for the image file.

### EmbeddingTaskResponseError

An object describing why the embedding task failed. Present only when `status` is `failed`. Omitted otherwise.

- `message` (string, required) — A human-readable message that describes why the task failed. Possible values: - "The embedding service is temporarily unstable. Please try again later." - "The embedding task failed. Please try again later." - "The embedding task could not complete processing." - "The embedding request was invalid." - "The media exceeds the maximum allowed size for embedding." - "Content exceeds the model's context window." - "The embedding result is no longer available and cannot be retrieved." - "failed to fetch or materialize source media" - "We could not process your media for embedding. Please verify the input file and try again." For the steps to fix the file, see the [How do I fix a file that could not be processed for embedding?](/v1.3/docs/resources/frequently-asked-questions#how-do-i-fix-a-file-that-could-not-be-processed-for-embedding) section on the **Frequently asked questions** page. When the platform can measure the overage in pages, bytes, or seconds, the message includes those numbers in place of the fixed sentence for that limit. For example: "Document (17 pages) exceeds maximum limit of 6 pages", "File size (33.6 MB) exceeds maximum limit of 32 MB", or "Duration (35.0 seconds) exceeds maximum limit of 30 seconds (0 minutes)".

### ErrorResponseError

- `code` (string, required) — A string representing the code associated with the error. See the [Error codes](/v1.3/api-reference/error-codes) page for details.
- `message` (string, required) — A human-readable string describing the error, intended to be suitable for display in a user interface.
- `details` (map from string to any, optional) — Additional error details (optional)

## Examples

### Task still processing

**Response**

```json
{
  "_id": "64f8d2c7e4a1b37f8a9c5d12",
  "status": "processing",
  "data": null
}
```

**SDK Code**

```python Task still processing
import requests

url = "https://api.twelvelabs.io/v1.3/embed-v2/tasks/64f8d2c7e4a1b37f8a9c5d12"

headers = {"x-api-key": "<apiKey>"}

response = requests.get(url, headers=headers)

print(response.json())
```

```javascript Task still processing
const url = 'https://api.twelvelabs.io/v1.3/embed-v2/tasks/64f8d2c7e4a1b37f8a9c5d12';
const options = {method: 'GET', headers: {'x-api-key': '<apiKey>'}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
```

```go Task still processing
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "https://api.twelvelabs.io/v1.3/embed-v2/tasks/64f8d2c7e4a1b37f8a9c5d12"

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("x-api-key", "<apiKey>")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
```

```ruby Task still processing
require 'uri'
require 'net/http'

url = URI("https://api.twelvelabs.io/v1.3/embed-v2/tasks/64f8d2c7e4a1b37f8a9c5d12")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["x-api-key"] = '<apiKey>'

response = http.request(request)
puts response.read_body
```

```java Task still processing
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.get("https://api.twelvelabs.io/v1.3/embed-v2/tasks/64f8d2c7e4a1b37f8a9c5d12")
  .header("x-api-key", "<apiKey>")
  .asString();
```

```php Task still processing
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('GET', 'https://api.twelvelabs.io/v1.3/embed-v2/tasks/64f8d2c7e4a1b37f8a9c5d12', [
  'headers' => [
    'x-api-key' => '<apiKey>',
  ],
]);

echo $response->getBody();
```

```csharp Task still processing
using RestSharp;

var client = new RestClient("https://api.twelvelabs.io/v1.3/embed-v2/tasks/64f8d2c7e4a1b37f8a9c5d12");
var request = new RestRequest(Method.GET);
request.AddHeader("x-api-key", "<apiKey>");
IRestResponse response = client.Execute(request);
```

```swift Task still processing
import Foundation

let headers = ["x-api-key": "<apiKey>"]

let request = NSMutableURLRequest(url: NSURL(string: "https://api.twelvelabs.io/v1.3/embed-v2/tasks/64f8d2c7e4a1b37f8a9c5d12")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
```

### Task completed with results

**Response**

```json
{
  "_id": "64f8d2c7e4a1b37f8a9c5d12",
  "status": "ready",
  "data": [
    {
      "embedding": [
        0.123,
        -0.456,
        0.789,
        0.012
      ],
      "embedding_option": "visual",
      "embedding_scope": "clip",
      "start_sec": 0,
      "end_sec": 4.2
    },
    {
      "embedding": [
        0.234,
        0.567,
        -0.89,
        0.123
      ],
      "embedding_option": "audio",
      "embedding_scope": "clip",
      "start_sec": 0,
      "end_sec": 4.2
    }
  ],
  "created_at": "2024-09-26T10:29:19.968Z",
  "updated_at": "2024-09-26T10:29:19.968Z"
}
```

**SDK Code**

```python Task completed with results
import requests

url = "https://api.twelvelabs.io/v1.3/embed-v2/tasks/64f8d2c7e4a1b37f8a9c5d12"

headers = {"x-api-key": "<apiKey>"}

response = requests.get(url, headers=headers)

print(response.json())
```

```javascript Task completed with results
const url = 'https://api.twelvelabs.io/v1.3/embed-v2/tasks/64f8d2c7e4a1b37f8a9c5d12';
const options = {method: 'GET', headers: {'x-api-key': '<apiKey>'}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
```

```go Task completed with results
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "https://api.twelvelabs.io/v1.3/embed-v2/tasks/64f8d2c7e4a1b37f8a9c5d12"

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("x-api-key", "<apiKey>")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
```

```ruby Task completed with results
require 'uri'
require 'net/http'

url = URI("https://api.twelvelabs.io/v1.3/embed-v2/tasks/64f8d2c7e4a1b37f8a9c5d12")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["x-api-key"] = '<apiKey>'

response = http.request(request)
puts response.read_body
```

```java Task completed with results
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.get("https://api.twelvelabs.io/v1.3/embed-v2/tasks/64f8d2c7e4a1b37f8a9c5d12")
  .header("x-api-key", "<apiKey>")
  .asString();
```

```php Task completed with results
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('GET', 'https://api.twelvelabs.io/v1.3/embed-v2/tasks/64f8d2c7e4a1b37f8a9c5d12', [
  'headers' => [
    'x-api-key' => '<apiKey>',
  ],
]);

echo $response->getBody();
```

```csharp Task completed with results
using RestSharp;

var client = new RestClient("https://api.twelvelabs.io/v1.3/embed-v2/tasks/64f8d2c7e4a1b37f8a9c5d12");
var request = new RestRequest(Method.GET);
request.AddHeader("x-api-key", "<apiKey>");
IRestResponse response = client.Execute(request);
```

```swift Task completed with results
import Foundation

let headers = ["x-api-key": "<apiKey>"]

let request = NSMutableURLRequest(url: NSURL(string: "https://api.twelvelabs.io/v1.3/embed-v2/tasks/64f8d2c7e4a1b37f8a9c5d12")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
```

### Task failed

**Response**

```json
{
  "_id": "64f8d2c7e4a1b37f8a9c5d12",
  "status": "failed",
  "data": null,
  "error": {
    "message": "The embedding service is temporarily unstable. Please try again later."
  }
}
```

**SDK Code**

```python Task failed
import requests

url = "https://api.twelvelabs.io/v1.3/embed-v2/tasks/64f8d2c7e4a1b37f8a9c5d12"

headers = {"x-api-key": "<apiKey>"}

response = requests.get(url, headers=headers)

print(response.json())
```

```javascript Task failed
const url = 'https://api.twelvelabs.io/v1.3/embed-v2/tasks/64f8d2c7e4a1b37f8a9c5d12';
const options = {method: 'GET', headers: {'x-api-key': '<apiKey>'}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
```

```go Task failed
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "https://api.twelvelabs.io/v1.3/embed-v2/tasks/64f8d2c7e4a1b37f8a9c5d12"

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("x-api-key", "<apiKey>")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
```

```ruby Task failed
require 'uri'
require 'net/http'

url = URI("https://api.twelvelabs.io/v1.3/embed-v2/tasks/64f8d2c7e4a1b37f8a9c5d12")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["x-api-key"] = '<apiKey>'

response = http.request(request)
puts response.read_body
```

```java Task failed
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.get("https://api.twelvelabs.io/v1.3/embed-v2/tasks/64f8d2c7e4a1b37f8a9c5d12")
  .header("x-api-key", "<apiKey>")
  .asString();
```

```php Task failed
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('GET', 'https://api.twelvelabs.io/v1.3/embed-v2/tasks/64f8d2c7e4a1b37f8a9c5d12', [
  'headers' => [
    'x-api-key' => '<apiKey>',
  ],
]);

echo $response->getBody();
```

```csharp Task failed
using RestSharp;

var client = new RestClient("https://api.twelvelabs.io/v1.3/embed-v2/tasks/64f8d2c7e4a1b37f8a9c5d12");
var request = new RestRequest(Method.GET);
request.AddHeader("x-api-key", "<apiKey>");
IRestResponse response = client.Execute(request);
```

```swift Task failed
import Foundation

let headers = ["x-api-key": "<apiKey>"]

let request = NSMutableURLRequest(url: NSURL(string: "https://api.twelvelabs.io/v1.3/embed-v2/tasks/64f8d2c7e4a1b37f8a9c5d12")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
```

### Task completed with fused embedding

**Response**

```json
{
  "_id": "64f8d2c7e4a1b37f8a9c5d12",
  "status": "ready",
  "data": [
    {
      "embedding": [
        0.123,
        -0.456,
        0.789,
        0.012
      ],
      "embedding_option": "visual",
      "embedding_scope": "clip",
      "start_sec": 0,
      "end_sec": 4.2
    },
    {
      "embedding": [
        0.234,
        0.567,
        -0.89,
        0.123
      ],
      "embedding_option": "audio",
      "embedding_scope": "clip",
      "start_sec": 0,
      "end_sec": 4.2
    },
    {
      "embedding": [
        0.456,
        0.789,
        -0.123,
        0.567
      ],
      "embedding_option": "fused",
      "embedding_scope": "clip",
      "start_sec": 0,
      "end_sec": 4.2
    }
  ],
  "created_at": "2024-09-26T10:29:19.968Z",
  "updated_at": "2024-09-26T10:29:19.968Z"
}
```

**SDK Code**

```python Task completed with fused embedding
import requests

url = "https://api.twelvelabs.io/v1.3/embed-v2/tasks/64f8d2c7e4a1b37f8a9c5d12"

headers = {"x-api-key": "<apiKey>"}

response = requests.get(url, headers=headers)

print(response.json())
```

```javascript Task completed with fused embedding
const url = 'https://api.twelvelabs.io/v1.3/embed-v2/tasks/64f8d2c7e4a1b37f8a9c5d12';
const options = {method: 'GET', headers: {'x-api-key': '<apiKey>'}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
```

```go Task completed with fused embedding
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "https://api.twelvelabs.io/v1.3/embed-v2/tasks/64f8d2c7e4a1b37f8a9c5d12"

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("x-api-key", "<apiKey>")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
```

```ruby Task completed with fused embedding
require 'uri'
require 'net/http'

url = URI("https://api.twelvelabs.io/v1.3/embed-v2/tasks/64f8d2c7e4a1b37f8a9c5d12")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["x-api-key"] = '<apiKey>'

response = http.request(request)
puts response.read_body
```

```java Task completed with fused embedding
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.get("https://api.twelvelabs.io/v1.3/embed-v2/tasks/64f8d2c7e4a1b37f8a9c5d12")
  .header("x-api-key", "<apiKey>")
  .asString();
```

```php Task completed with fused embedding
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('GET', 'https://api.twelvelabs.io/v1.3/embed-v2/tasks/64f8d2c7e4a1b37f8a9c5d12', [
  'headers' => [
    'x-api-key' => '<apiKey>',
  ],
]);

echo $response->getBody();
```

```csharp Task completed with fused embedding
using RestSharp;

var client = new RestClient("https://api.twelvelabs.io/v1.3/embed-v2/tasks/64f8d2c7e4a1b37f8a9c5d12");
var request = new RestRequest(Method.GET);
request.AddHeader("x-api-key", "<apiKey>");
IRestResponse response = client.Execute(request);
```

```swift Task completed with fused embedding
import Foundation

let headers = ["x-api-key": "<apiKey>"]

let request = NSMutableURLRequest(url: NSURL(string: "https://api.twelvelabs.io/v1.3/embed-v2/tasks/64f8d2c7e4a1b37f8a9c5d12")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
```

### Marengo 3.5: PDF file, page embeddings with uncertainty

**Response**

```json
{
  "_id": "6831add901f7b3d28476a1e5",
  "status": "ready",
  "data": [
    {
      "embedding": [
        0.31,
        -0.14,
        0.58,
        0.09
      ],
      "embedding_uncertainty": [
        0.007,
        0.012,
        0.004,
        0.006
      ],
      "embedding_option": "visual",
      "embedding_scope": "page",
      "start_page_number": 1,
      "end_page_number": 1
    },
    {
      "embedding": [
        0.27,
        0.09,
        0.41,
        -0.02
      ],
      "embedding_uncertainty": [
        0.008,
        0.011,
        0.006,
        0.005
      ],
      "embedding_option": "visual",
      "embedding_scope": "page",
      "start_page_number": 2,
      "end_page_number": 2
    }
  ],
  "created_at": "2026-04-15T10:29:19.968Z",
  "updated_at": "2026-04-15T10:31:02.113Z",
  "usage": {
    "input_tokens": {
      "document": 46320
    },
    "truncated": false
  }
}
```

**SDK Code**

```python Marengo 3.5: PDF file, page embeddings with uncertainty
import requests

url = "https://api.twelvelabs.io/v1.3/embed-v2/tasks/64f8d2c7e4a1b37f8a9c5d12"

headers = {"x-api-key": "<apiKey>"}

response = requests.get(url, headers=headers)

print(response.json())
```

```javascript Marengo 3.5: PDF file, page embeddings with uncertainty
const url = 'https://api.twelvelabs.io/v1.3/embed-v2/tasks/64f8d2c7e4a1b37f8a9c5d12';
const options = {method: 'GET', headers: {'x-api-key': '<apiKey>'}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
```

```go Marengo 3.5: PDF file, page embeddings with uncertainty
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "https://api.twelvelabs.io/v1.3/embed-v2/tasks/64f8d2c7e4a1b37f8a9c5d12"

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("x-api-key", "<apiKey>")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
```

```ruby Marengo 3.5: PDF file, page embeddings with uncertainty
require 'uri'
require 'net/http'

url = URI("https://api.twelvelabs.io/v1.3/embed-v2/tasks/64f8d2c7e4a1b37f8a9c5d12")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["x-api-key"] = '<apiKey>'

response = http.request(request)
puts response.read_body
```

```java Marengo 3.5: PDF file, page embeddings with uncertainty
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.get("https://api.twelvelabs.io/v1.3/embed-v2/tasks/64f8d2c7e4a1b37f8a9c5d12")
  .header("x-api-key", "<apiKey>")
  .asString();
```

```php Marengo 3.5: PDF file, page embeddings with uncertainty
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('GET', 'https://api.twelvelabs.io/v1.3/embed-v2/tasks/64f8d2c7e4a1b37f8a9c5d12', [
  'headers' => [
    'x-api-key' => '<apiKey>',
  ],
]);

echo $response->getBody();
```

```csharp Marengo 3.5: PDF file, page embeddings with uncertainty
using RestSharp;

var client = new RestClient("https://api.twelvelabs.io/v1.3/embed-v2/tasks/64f8d2c7e4a1b37f8a9c5d12");
var request = new RestRequest(Method.GET);
request.AddHeader("x-api-key", "<apiKey>");
IRestResponse response = client.Execute(request);
```

```swift Marengo 3.5: PDF file, page embeddings with uncertainty
import Foundation

let headers = ["x-api-key": "<apiKey>"]

let request = NSMutableURLRequest(url: NSURL(string: "https://api.twelvelabs.io/v1.3/embed-v2/tasks/64f8d2c7e4a1b37f8a9c5d12")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
```

### Marengo 3.5: PDF file, whole-page and quadrant embeddings at 256 dimensions

**Response**

```json
{
  "_id": "6831add901f7b3d28476a1e6",
  "status": "ready",
  "data": [
    {
      "embedding": [
        0.31,
        -0.14,
        0.58,
        0.09
      ],
      "embedding_option": "visual",
      "embedding_scope": "page",
      "start_page_number": 1,
      "end_page_number": 1
    },
    {
      "embedding": [
        0.22,
        -0.31,
        0.44,
        0.17
      ],
      "embedding_option": "visual",
      "embedding_scope": "page",
      "start_page_number": 1,
      "end_page_number": 1,
      "quadrant": "top_left"
    },
    {
      "embedding": [
        0.19,
        -0.08,
        0.51,
        0.23
      ],
      "embedding_option": "visual",
      "embedding_scope": "page",
      "start_page_number": 1,
      "end_page_number": 1,
      "quadrant": "top_right"
    },
    {
      "embedding": [
        0.28,
        -0.22,
        0.36,
        0.11
      ],
      "embedding_option": "visual",
      "embedding_scope": "page",
      "start_page_number": 1,
      "end_page_number": 1,
      "quadrant": "bottom_left"
    },
    {
      "embedding": [
        0.34,
        -0.17,
        0.49,
        0.05
      ],
      "embedding_option": "visual",
      "embedding_scope": "page",
      "start_page_number": 1,
      "end_page_number": 1,
      "quadrant": "bottom_right"
    }
  ],
  "created_at": "2026-04-15T10:29:19.968Z",
  "updated_at": "2026-04-15T10:31:02.113Z",
  "usage": {
    "input_tokens": {
      "document": 115800
    },
    "truncated": false
  },
  "metadata": {
    "input_type": "document",
    "embedding_dimension": 256,
    "embedding_options": [
      "visual"
    ],
    "embedding_scopes": [
      "local"
    ],
    "input_filename": "annual-report-2025.pdf"
  }
}
```

**SDK Code**

```python Marengo 3.5: PDF file, whole-page and quadrant embeddings at 256 dimensions
import requests

url = "https://api.twelvelabs.io/v1.3/embed-v2/tasks/64f8d2c7e4a1b37f8a9c5d12"

headers = {"x-api-key": "<apiKey>"}

response = requests.get(url, headers=headers)

print(response.json())
```

```javascript Marengo 3.5: PDF file, whole-page and quadrant embeddings at 256 dimensions
const url = 'https://api.twelvelabs.io/v1.3/embed-v2/tasks/64f8d2c7e4a1b37f8a9c5d12';
const options = {method: 'GET', headers: {'x-api-key': '<apiKey>'}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
```

```go Marengo 3.5: PDF file, whole-page and quadrant embeddings at 256 dimensions
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "https://api.twelvelabs.io/v1.3/embed-v2/tasks/64f8d2c7e4a1b37f8a9c5d12"

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("x-api-key", "<apiKey>")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
```

```ruby Marengo 3.5: PDF file, whole-page and quadrant embeddings at 256 dimensions
require 'uri'
require 'net/http'

url = URI("https://api.twelvelabs.io/v1.3/embed-v2/tasks/64f8d2c7e4a1b37f8a9c5d12")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["x-api-key"] = '<apiKey>'

response = http.request(request)
puts response.read_body
```

```java Marengo 3.5: PDF file, whole-page and quadrant embeddings at 256 dimensions
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.get("https://api.twelvelabs.io/v1.3/embed-v2/tasks/64f8d2c7e4a1b37f8a9c5d12")
  .header("x-api-key", "<apiKey>")
  .asString();
```

```php Marengo 3.5: PDF file, whole-page and quadrant embeddings at 256 dimensions
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('GET', 'https://api.twelvelabs.io/v1.3/embed-v2/tasks/64f8d2c7e4a1b37f8a9c5d12', [
  'headers' => [
    'x-api-key' => '<apiKey>',
  ],
]);

echo $response->getBody();
```

```csharp Marengo 3.5: PDF file, whole-page and quadrant embeddings at 256 dimensions
using RestSharp;

var client = new RestClient("https://api.twelvelabs.io/v1.3/embed-v2/tasks/64f8d2c7e4a1b37f8a9c5d12");
var request = new RestRequest(Method.GET);
request.AddHeader("x-api-key", "<apiKey>");
IRestResponse response = client.Execute(request);
```

```swift Marengo 3.5: PDF file, whole-page and quadrant embeddings at 256 dimensions
import Foundation

let headers = ["x-api-key": "<apiKey>"]

let request = NSMutableURLRequest(url: NSURL(string: "https://api.twelvelabs.io/v1.3/embed-v2/tasks/64f8d2c7e4a1b37f8a9c5d12")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
```

### Marengo 3.5: plain text file, one embedding for the entire file

**Response**

```json
{
  "_id": "6831add901f7b3d28476a1e7",
  "status": "ready",
  "data": [
    {
      "embedding": [
        0.18,
        0.42,
        -0.09,
        0.33
      ],
      "embedding_option": "text",
      "embedding_scope": "asset",
      "start_sec": null,
      "end_sec": null,
      "start_page_number": null,
      "end_page_number": null,
      "quadrant": null
    }
  ],
  "created_at": "2026-04-15T10:29:19.968Z",
  "updated_at": "2026-04-15T10:29:41.204Z",
  "usage": {
    "input_tokens": {
      "text": 4820
    },
    "truncated": false
  },
  "metadata": {
    "input_type": "document",
    "embedding_dimension": 512,
    "embedding_options": [
      "text"
    ],
    "embedding_scopes": [
      "asset"
    ],
    "input_url": "https://user-bucket.com/folder/release-notes.txt"
  }
}
```

**SDK Code**

```python Marengo 3.5: plain text file, one embedding for the entire file
import requests

url = "https://api.twelvelabs.io/v1.3/embed-v2/tasks/64f8d2c7e4a1b37f8a9c5d12"

headers = {"x-api-key": "<apiKey>"}

response = requests.get(url, headers=headers)

print(response.json())
```

```javascript Marengo 3.5: plain text file, one embedding for the entire file
const url = 'https://api.twelvelabs.io/v1.3/embed-v2/tasks/64f8d2c7e4a1b37f8a9c5d12';
const options = {method: 'GET', headers: {'x-api-key': '<apiKey>'}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
```

```go Marengo 3.5: plain text file, one embedding for the entire file
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "https://api.twelvelabs.io/v1.3/embed-v2/tasks/64f8d2c7e4a1b37f8a9c5d12"

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("x-api-key", "<apiKey>")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
```

```ruby Marengo 3.5: plain text file, one embedding for the entire file
require 'uri'
require 'net/http'

url = URI("https://api.twelvelabs.io/v1.3/embed-v2/tasks/64f8d2c7e4a1b37f8a9c5d12")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["x-api-key"] = '<apiKey>'

response = http.request(request)
puts response.read_body
```

```java Marengo 3.5: plain text file, one embedding for the entire file
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.get("https://api.twelvelabs.io/v1.3/embed-v2/tasks/64f8d2c7e4a1b37f8a9c5d12")
  .header("x-api-key", "<apiKey>")
  .asString();
```

```php Marengo 3.5: plain text file, one embedding for the entire file
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('GET', 'https://api.twelvelabs.io/v1.3/embed-v2/tasks/64f8d2c7e4a1b37f8a9c5d12', [
  'headers' => [
    'x-api-key' => '<apiKey>',
  ],
]);

echo $response->getBody();
```

```csharp Marengo 3.5: plain text file, one embedding for the entire file
using RestSharp;

var client = new RestClient("https://api.twelvelabs.io/v1.3/embed-v2/tasks/64f8d2c7e4a1b37f8a9c5d12");
var request = new RestRequest(Method.GET);
request.AddHeader("x-api-key", "<apiKey>");
IRestResponse response = client.Execute(request);
```

```swift Marengo 3.5: plain text file, one embedding for the entire file
import Foundation

let headers = ["x-api-key": "<apiKey>"]

let request = NSMutableURLRequest(url: NSURL(string: "https://api.twelvelabs.io/v1.3/embed-v2/tasks/64f8d2c7e4a1b37f8a9c5d12")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
```

### Marengo 3.5: plain text file, one embedding for each chunk of whole sentences

**Response**

```json
{
  "_id": "6831add901f7b3d28476a1e9",
  "status": "ready",
  "data": [
    {
      "embedding": [
        0.18,
        0.42,
        -0.09,
        0.33
      ],
      "embedding_option": "text",
      "embedding_scope": "chunk",
      "chunk_index": 0
    },
    {
      "embedding": [
        0.26,
        0.31,
        -0.14,
        0.29
      ],
      "embedding_option": "text",
      "embedding_scope": "chunk",
      "chunk_index": 1
    }
  ],
  "created_at": "2026-04-15T10:29:19.968Z",
  "updated_at": "2026-04-15T10:29:52.640Z",
  "usage": {
    "input_tokens": {
      "text": 4820
    },
    "truncated": false
  },
  "metadata": {
    "input_type": "document",
    "embedding_dimension": 512,
    "embedding_options": [
      "text"
    ],
    "embedding_scopes": [
      "local"
    ],
    "input_url": "https://user-bucket.com/folder/release-notes.txt"
  }
}
```

**SDK Code**

```python Marengo 3.5: plain text file, one embedding for each chunk of whole sentences
import requests

url = "https://api.twelvelabs.io/v1.3/embed-v2/tasks/64f8d2c7e4a1b37f8a9c5d12"

headers = {"x-api-key": "<apiKey>"}

response = requests.get(url, headers=headers)

print(response.json())
```

```javascript Marengo 3.5: plain text file, one embedding for each chunk of whole sentences
const url = 'https://api.twelvelabs.io/v1.3/embed-v2/tasks/64f8d2c7e4a1b37f8a9c5d12';
const options = {method: 'GET', headers: {'x-api-key': '<apiKey>'}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
```

```go Marengo 3.5: plain text file, one embedding for each chunk of whole sentences
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "https://api.twelvelabs.io/v1.3/embed-v2/tasks/64f8d2c7e4a1b37f8a9c5d12"

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("x-api-key", "<apiKey>")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
```

```ruby Marengo 3.5: plain text file, one embedding for each chunk of whole sentences
require 'uri'
require 'net/http'

url = URI("https://api.twelvelabs.io/v1.3/embed-v2/tasks/64f8d2c7e4a1b37f8a9c5d12")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["x-api-key"] = '<apiKey>'

response = http.request(request)
puts response.read_body
```

```java Marengo 3.5: plain text file, one embedding for each chunk of whole sentences
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.get("https://api.twelvelabs.io/v1.3/embed-v2/tasks/64f8d2c7e4a1b37f8a9c5d12")
  .header("x-api-key", "<apiKey>")
  .asString();
```

```php Marengo 3.5: plain text file, one embedding for each chunk of whole sentences
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('GET', 'https://api.twelvelabs.io/v1.3/embed-v2/tasks/64f8d2c7e4a1b37f8a9c5d12', [
  'headers' => [
    'x-api-key' => '<apiKey>',
  ],
]);

echo $response->getBody();
```

```csharp Marengo 3.5: plain text file, one embedding for each chunk of whole sentences
using RestSharp;

var client = new RestClient("https://api.twelvelabs.io/v1.3/embed-v2/tasks/64f8d2c7e4a1b37f8a9c5d12");
var request = new RestRequest(Method.GET);
request.AddHeader("x-api-key", "<apiKey>");
IRestResponse response = client.Execute(request);
```

```swift Marengo 3.5: plain text file, one embedding for each chunk of whole sentences
import Foundation

let headers = ["x-api-key": "<apiKey>"]

let request = NSMutableURLRequest(url: NSURL(string: "https://api.twelvelabs.io/v1.3/embed-v2/tasks/64f8d2c7e4a1b37f8a9c5d12")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
```

### Marengo 3.5: PDF file, one visual and one text embedding for the entire file

**Response**

```json
{
  "_id": "6831add901f7b3d28476a1e8",
  "status": "ready",
  "data": [
    {
      "embedding": [
        0.29,
        -0.16,
        0.55,
        0.11
      ],
      "embedding_option": "visual",
      "embedding_scope": "asset"
    },
    {
      "embedding": [
        0.21,
        0.38,
        -0.05,
        0.27
      ],
      "embedding_option": "text",
      "embedding_scope": "asset"
    }
  ],
  "created_at": "2026-04-15T10:29:19.968Z",
  "updated_at": "2026-04-15T10:30:55.402Z",
  "usage": {
    "input_tokens": {
      "document": 23160,
      "text": 12440
    },
    "truncated": false
  },
  "metadata": {
    "input_type": "document",
    "embedding_dimension": 512,
    "embedding_options": [
      "visual",
      "text"
    ],
    "embedding_scopes": [
      "asset"
    ],
    "input_filename": "annual-report-2025.pdf"
  }
}
```

**SDK Code**

```python Marengo 3.5: PDF file, one visual and one text embedding for the entire file
import requests

url = "https://api.twelvelabs.io/v1.3/embed-v2/tasks/64f8d2c7e4a1b37f8a9c5d12"

headers = {"x-api-key": "<apiKey>"}

response = requests.get(url, headers=headers)

print(response.json())
```

```javascript Marengo 3.5: PDF file, one visual and one text embedding for the entire file
const url = 'https://api.twelvelabs.io/v1.3/embed-v2/tasks/64f8d2c7e4a1b37f8a9c5d12';
const options = {method: 'GET', headers: {'x-api-key': '<apiKey>'}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
```

```go Marengo 3.5: PDF file, one visual and one text embedding for the entire file
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "https://api.twelvelabs.io/v1.3/embed-v2/tasks/64f8d2c7e4a1b37f8a9c5d12"

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("x-api-key", "<apiKey>")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
```

```ruby Marengo 3.5: PDF file, one visual and one text embedding for the entire file
require 'uri'
require 'net/http'

url = URI("https://api.twelvelabs.io/v1.3/embed-v2/tasks/64f8d2c7e4a1b37f8a9c5d12")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["x-api-key"] = '<apiKey>'

response = http.request(request)
puts response.read_body
```

```java Marengo 3.5: PDF file, one visual and one text embedding for the entire file
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.get("https://api.twelvelabs.io/v1.3/embed-v2/tasks/64f8d2c7e4a1b37f8a9c5d12")
  .header("x-api-key", "<apiKey>")
  .asString();
```

```php Marengo 3.5: PDF file, one visual and one text embedding for the entire file
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('GET', 'https://api.twelvelabs.io/v1.3/embed-v2/tasks/64f8d2c7e4a1b37f8a9c5d12', [
  'headers' => [
    'x-api-key' => '<apiKey>',
  ],
]);

echo $response->getBody();
```

```csharp Marengo 3.5: PDF file, one visual and one text embedding for the entire file
using RestSharp;

var client = new RestClient("https://api.twelvelabs.io/v1.3/embed-v2/tasks/64f8d2c7e4a1b37f8a9c5d12");
var request = new RestRequest(Method.GET);
request.AddHeader("x-api-key", "<apiKey>");
IRestResponse response = client.Execute(request);
```

```swift Marengo 3.5: PDF file, one visual and one text embedding for the entire file
import Foundation

let headers = ["x-api-key": "<apiKey>"]

let request = NSMutableURLRequest(url: NSURL(string: "https://api.twelvelabs.io/v1.3/embed-v2/tasks/64f8d2c7e4a1b37f8a9c5d12")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
```

### Marengo 3.5: image, single asset-scope visual embedding with uncertainty

**Response**

```json
{
  "_id": "6831af3a8c1b2e4d5f6a7b8c",
  "status": "ready",
  "data": [
    {
      "embedding": [
        0.67,
        0.03,
        -0.22,
        0.14
      ],
      "embedding_uncertainty": [
        0.004,
        0.009,
        0.003,
        0.006
      ],
      "embedding_option": "visual",
      "embedding_scope": "asset"
    }
  ],
  "created_at": "2026-04-15T10:29:19.968Z",
  "updated_at": "2026-04-15T10:29:47.221Z",
  "usage": {
    "input_tokens": {
      "image": 1024
    },
    "truncated": false
  }
}
```

**SDK Code**

```python Marengo 3.5: image, single asset-scope visual embedding with uncertainty
import requests

url = "https://api.twelvelabs.io/v1.3/embed-v2/tasks/64f8d2c7e4a1b37f8a9c5d12"

headers = {"x-api-key": "<apiKey>"}

response = requests.get(url, headers=headers)

print(response.json())
```

```javascript Marengo 3.5: image, single asset-scope visual embedding with uncertainty
const url = 'https://api.twelvelabs.io/v1.3/embed-v2/tasks/64f8d2c7e4a1b37f8a9c5d12';
const options = {method: 'GET', headers: {'x-api-key': '<apiKey>'}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
```

```go Marengo 3.5: image, single asset-scope visual embedding with uncertainty
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "https://api.twelvelabs.io/v1.3/embed-v2/tasks/64f8d2c7e4a1b37f8a9c5d12"

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("x-api-key", "<apiKey>")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
```

```ruby Marengo 3.5: image, single asset-scope visual embedding with uncertainty
require 'uri'
require 'net/http'

url = URI("https://api.twelvelabs.io/v1.3/embed-v2/tasks/64f8d2c7e4a1b37f8a9c5d12")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["x-api-key"] = '<apiKey>'

response = http.request(request)
puts response.read_body
```

```java Marengo 3.5: image, single asset-scope visual embedding with uncertainty
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.get("https://api.twelvelabs.io/v1.3/embed-v2/tasks/64f8d2c7e4a1b37f8a9c5d12")
  .header("x-api-key", "<apiKey>")
  .asString();
```

```php Marengo 3.5: image, single asset-scope visual embedding with uncertainty
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('GET', 'https://api.twelvelabs.io/v1.3/embed-v2/tasks/64f8d2c7e4a1b37f8a9c5d12', [
  'headers' => [
    'x-api-key' => '<apiKey>',
  ],
]);

echo $response->getBody();
```

```csharp Marengo 3.5: image, single asset-scope visual embedding with uncertainty
using RestSharp;

var client = new RestClient("https://api.twelvelabs.io/v1.3/embed-v2/tasks/64f8d2c7e4a1b37f8a9c5d12");
var request = new RestRequest(Method.GET);
request.AddHeader("x-api-key", "<apiKey>");
IRestResponse response = client.Execute(request);
```

```swift Marengo 3.5: image, single asset-scope visual embedding with uncertainty
import Foundation

let headers = ["x-api-key": "<apiKey>"]

let request = NSMutableURLRequest(url: NSURL(string: "https://api.twelvelabs.io/v1.3/embed-v2/tasks/64f8d2c7e4a1b37f8a9c5d12")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
```

### Marengo 3.5: video fused with time-based metadata, segment scope with uncertainty

**Response**

```json
{
  "_id": "6831ae81c4a8d3697e15b2f0",
  "status": "ready",
  "data": [
    {
      "embedding": [
        0.38,
        -0.11,
        0.22,
        0.05
      ],
      "embedding_uncertainty": [
        0.006,
        0.013,
        0.004,
        0.007
      ],
      "embedding_option": "visual",
      "embedding_scope": "clip",
      "start_sec": 40.5,
      "end_sec": 46.2
    },
    {
      "embedding": [
        -0.07,
        0.44,
        0.19,
        0.02
      ],
      "embedding_uncertainty": [
        0.019,
        0.008,
        0.027,
        0.011
      ],
      "embedding_option": "audio",
      "embedding_scope": "clip",
      "start_sec": 40.5,
      "end_sec": 46.2
    },
    {
      "embedding": [
        0.24,
        0.31,
        0.4,
        0.08
      ],
      "embedding_uncertainty": [
        0.01,
        0.008,
        0.012,
        0.009
      ],
      "embedding_option": "fused",
      "embedding_scope": "clip",
      "start_sec": 40.5,
      "end_sec": 46.2
    }
  ],
  "created_at": "2026-04-15T10:29:19.968Z",
  "updated_at": "2026-04-15T10:34:47.501Z",
  "usage": {
    "input_tokens": {
      "video": 40500,
      "audio": 40500
    },
    "truncated": false
  }
}
```

**SDK Code**

```python Marengo 3.5: video fused with time-based metadata, segment scope with uncertainty
import requests

url = "https://api.twelvelabs.io/v1.3/embed-v2/tasks/64f8d2c7e4a1b37f8a9c5d12"

headers = {"x-api-key": "<apiKey>"}

response = requests.get(url, headers=headers)

print(response.json())
```

```javascript Marengo 3.5: video fused with time-based metadata, segment scope with uncertainty
const url = 'https://api.twelvelabs.io/v1.3/embed-v2/tasks/64f8d2c7e4a1b37f8a9c5d12';
const options = {method: 'GET', headers: {'x-api-key': '<apiKey>'}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
```

```go Marengo 3.5: video fused with time-based metadata, segment scope with uncertainty
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "https://api.twelvelabs.io/v1.3/embed-v2/tasks/64f8d2c7e4a1b37f8a9c5d12"

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("x-api-key", "<apiKey>")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
```

```ruby Marengo 3.5: video fused with time-based metadata, segment scope with uncertainty
require 'uri'
require 'net/http'

url = URI("https://api.twelvelabs.io/v1.3/embed-v2/tasks/64f8d2c7e4a1b37f8a9c5d12")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["x-api-key"] = '<apiKey>'

response = http.request(request)
puts response.read_body
```

```java Marengo 3.5: video fused with time-based metadata, segment scope with uncertainty
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.get("https://api.twelvelabs.io/v1.3/embed-v2/tasks/64f8d2c7e4a1b37f8a9c5d12")
  .header("x-api-key", "<apiKey>")
  .asString();
```

```php Marengo 3.5: video fused with time-based metadata, segment scope with uncertainty
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('GET', 'https://api.twelvelabs.io/v1.3/embed-v2/tasks/64f8d2c7e4a1b37f8a9c5d12', [
  'headers' => [
    'x-api-key' => '<apiKey>',
  ],
]);

echo $response->getBody();
```

```csharp Marengo 3.5: video fused with time-based metadata, segment scope with uncertainty
using RestSharp;

var client = new RestClient("https://api.twelvelabs.io/v1.3/embed-v2/tasks/64f8d2c7e4a1b37f8a9c5d12");
var request = new RestRequest(Method.GET);
request.AddHeader("x-api-key", "<apiKey>");
IRestResponse response = client.Execute(request);
```

```swift Marengo 3.5: video fused with time-based metadata, segment scope with uncertainty
import Foundation

let headers = ["x-api-key": "<apiKey>"]

let request = NSMutableURLRequest(url: NSURL(string: "https://api.twelvelabs.io/v1.3/embed-v2/tasks/64f8d2c7e4a1b37f8a9c5d12")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
```