Get Subtitle Result for Language

GET

sub-result

{run_id}

{language}

Get Subtitle Result For Language

curl --request GET \
  --url https://client.camb.ai/apis/sub-result/{run_id}/{language} \
  --header 'x-api-key: <api-key>'

import requests

url = "https://client.camb.ai/apis/sub-result/{run_id}/{language}"

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

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

print(response.text)

const options = {method: 'GET', headers: {'x-api-key': '<api-key>'}};

fetch('https://client.camb.ai/apis/sub-result/{run_id}/{language}', options)
  .then(res => res.json())
  .then(res => console.log(res))
  .catch(err => console.error(err));

<?php

$curl = curl_init();

curl_setopt_array($curl, [
  CURLOPT_URL => "https://client.camb.ai/apis/sub-result/{run_id}/{language}",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "x-api-key: <api-key>"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

{
  "transcript": [
    {
      "start": 123,
      "end": 123,
      "text": "<string>",
      "speaker": "<string>"
    }
  ]
}

{
  "detail": [
    {
      "loc": [
        "<string>"
      ],
      "msg": "<string>",
      "type": "<string>"
    }
  ]
}

Fetches subtitles for one language of a completed subtitle run.

By default (no query params) you get the structured JSON transcript for that language: { "transcript": [ {start, end, text, speaker}, ... ] }.
When you pass format_type and/or data_type, the transcript is exported and returned as { "transcript": <presigned url | raw text> }, the same parameter values and response shape as Get Transcription Result.

The {language} path parameter must be the run’s source language or one of the target languages from Create Subtitle. Pass a locale tag (es-es, fr-fr); numeric IDs still work but are deprecated.

If the run was created with formatting_options on Create Subtitle, the segments already follow subtitle timing and length rules.

Choosing your output

Parameter	Values	Behaviour
(none)	n/a	Structured JSON transcript: `{ "transcript": [ {start, end, text, speaker}, ... ] }`
`data_type=file`	`srt` / `vtt` / `txt` via `format_type` (default `txt`)	`{ "transcript": "<presigned url>" }`: a downloadable file
`data_type=raw_data`	`srt` / `vtt` / `txt` via `format_type` (default `txt`)	`{ "transcript": "<raw text>" }`: the rendered text inline

format_type (srt/vtt/txt) and data_type (raw_data/file) use the exact same values as Get Transcription Result. Need every language at once? Use Get Subtitle Result — it supports the same export params for all languages in one call.

Implementation Example

import requests

API_KEY = "your_api_key_here"
RUN_ID = 12345
LANGUAGE = "es-es"  # Locale tag; numeric IDs (e.g. 23) still work but are deprecated

url = f"https://client.camb.ai/apis/sub-result/{RUN_ID}/{LANGUAGE}"
headers = {"x-api-key": API_KEY}

# 1) Default: structured JSON transcript for this language
result = requests.get(url, headers=headers).json()
for segment in result["transcript"]:
    print(f"[{segment['start']} - {segment['end']}] {segment['speaker']}: {segment['text']}")

# 2) Export: presigned URL to an SRT file
srt = requests.get(
    url, headers=headers, params={"format_type": "srt", "data_type": "file"}
).json()
print(f"SRT file: {srt['transcript']}")

# 3) Export: raw VTT text inline
vtt = requests.get(
    url, headers=headers, params={"format_type": "vtt", "data_type": "raw_data"}
).json()
print(vtt["transcript"][:150])

Understanding the Response Structure

The response is always a JSON object with a single transcript field. Its value depends on the parameters.

Default: structured transcript (no params)

{
  "transcript": [
    { "start": 5.0,  "end": 12.0, "text": "Bienvenidos a nuestra discusión sobre IA.", "speaker": "SPEAKER_0" },
    { "start": 13.0, "end": 18.0, "text": "Gracias por invitarme.",                    "speaker": "SPEAKER_1" }
  ]
}

Field	Description
`start`	Start time of the segment (seconds)
`end`	End time of the segment (seconds)
`text`	Text for the segment, in that language
`speaker`	Speaker identifier

Export: file (`data_type=file`)

{ "transcript": "https://storage.example.com/.../output_transcript.srt?..." }

transcript is a presigned URL to the rendered file. The file content matches your format_type:

TXT (`format_type=txt`)

[00:00:05 - 00:00:12] SPEAKER_0: Bienvenidos a nuestra discusión sobre IA.
[00:00:13 - 00:00:18] SPEAKER_1: Gracias por invitarme.

SRT (`format_type=srt`)

1
00:00:05,000 --> 00:00:12,000
SPEAKER_0: Bienvenidos a nuestra discusión sobre IA.

2
00:00:13,000 --> 00:00:18,000
SPEAKER_1: Gracias por invitarme.

VTT (`format_type=vtt`)

WEBVTT

00:00:05.000 --> 00:00:12.000
SPEAKER_0: Bienvenidos a nuestra discusión sobre IA.

00:00:13.000 --> 00:00:18.000
SPEAKER_1: Gracias por invitarme.

Export: raw data (`data_type=raw_data`)

The same rendered content is returned inline as a string:

{ "transcript": "1\n00:00:05,000 --> 00:00:12,000\nSPEAKER_0: Bienvenidos a nuestra discusión sobre IA.\n\n..." }

The presigned file URL expires after 24 hours, so download your file soon.

Building a Complete Workflow

Create Subtitle: submit your media for subtitle generation
Get Subtitle Task Status: determine when your subtitles are ready
Get Subtitle Result: every language at once (same export params)

Authorizations

x-api-key

string

header

required

The x-api-key is a custom header required for authenticating requests to our API. Include this header in your request with the appropriate API key value to securely access our endpoints. You can find your API key(s) in the 'API' section of our studio website.

Path Parameters

run_id

integer

required

The unique identifier for the run, which was generated during the subtitle creation process and returned upon task completion. The unique identifier for the run, which was generated during the creation process and returned upon task completion.

language

string

required

The language to fetch, either the run's source language or one of its target languages. Pass a locale tag (en-us, fr-fr, es-es). Numeric language IDs still work but are deprecated. See all source languages.

Example:

""

Query Parameters

format_type

enum<string> | null

default:txt

Subtitle format for the transcript export: srt, vtt or txt. When omitted (and data_type is also omitted) the structured JSON transcript is returned instead of an exported file.

Available options:

srt,

vtt,

txt

data_type

enum<string> | null

default:file

How the exported transcript is returned once format_type/data_type is set: file returns a presigned URL, raw_data returns the raw text. Same values and response shape as the dubbing /transcript endpoint. In export mode the effective defaults are format_type=txt, data_type=file.

Available options:

raw_data,

file

Response

Successful Response

transcript

Structured dialogue array by default; a string (presigned URL for data_type=file, or raw text for data_type=raw_data) in export mode.

Hide child attributes

transcript.start

number<float>

required

The start time (in seconds) of the dialogue.

transcript.end

number<float>

required

The end time (in seconds) of the dialogue.

transcript.text

string

required

The actual text content of the dialogue spoken by the speaker.

transcript.speaker

string

required

The name or identifier of the speaker delivering the dialogue.

Last modified on July 26, 2026

Fetch Subtitle ResultsRetrieves the results of multiple subtitle runs using the provided run IDs in the request body.

Get Subtitle Result For Language

curl --request GET \
  --url https://client.camb.ai/apis/sub-result/{run_id}/{language} \
  --header 'x-api-key: <api-key>'

import requests

url = "https://client.camb.ai/apis/sub-result/{run_id}/{language}"

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

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

print(response.text)

const options = {method: 'GET', headers: {'x-api-key': '<api-key>'}};

fetch('https://client.camb.ai/apis/sub-result/{run_id}/{language}', options)
  .then(res => res.json())
  .then(res => console.log(res))
  .catch(err => console.error(err));

<?php

$curl = curl_init();

curl_setopt_array($curl, [
  CURLOPT_URL => "https://client.camb.ai/apis/sub-result/{run_id}/{language}",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "x-api-key: <api-key>"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

{
  "transcript": [
    {
      "start": 123,
      "end": 123,
      "text": "<string>",
      "speaker": "<string>"
    }
  ]
}

{
  "detail": [
    {
      "loc": [
        "<string>"
      ],
      "msg": "<string>",
      "type": "<string>"
    }
  ]
}

Getting Started

Models

Tutorials

SDK Guides

Hosting Platforms

Integrations

API Reference

Other Products

Release Logs

Get Subtitle Result for Language

Choosing your output

Implementation Example

Understanding the Response Structure

Default: structured transcript (no params)

Export: file (`data_type=file`)

TXT (`format_type=txt`)

SRT (`format_type=srt`)

VTT (`format_type=vtt`)

Export: raw data (`data_type=raw_data`)

Building a Complete Workflow

Authorizations

Path Parameters

Query Parameters

Response

​Choosing your output

​Implementation Example

​Understanding the Response Structure

​Default: structured transcript (no params)

​Export: file (data_type=file)

​TXT (format_type=txt)

​SRT (format_type=srt)

​VTT (format_type=vtt)

​Export: raw data (data_type=raw_data)

​Building a Complete Workflow

Authorizations

Path Parameters

Query Parameters

Response

Choosing your output

Implementation Example

Understanding the Response Structure

Default: structured transcript (no params)

Export: file (`data_type=file`)

TXT (`format_type=txt`)

SRT (`format_type=srt`)

VTT (`format_type=vtt`)

Export: raw data (`data_type=raw_data`)

Building a Complete Workflow