Get Subtitle Result

GET

sub-result

{run_id}

Get Subtitle Result

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

import requests

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

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}', 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}",
  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 the result of a completed subtitle run: the source language plus each target language from Create Subtitle.

By default (no query params) you get the structured JSON transcript: one language returns { "transcript": [ {start, end, text, speaker}, ... ] }; multiple languages return an object keyed by language ID with that same shape per language.
When you pass format_type and/or data_type, every language on the run is exported. One language returns { "transcript": <presigned url | raw text> }; multiple languages return an object keyed by language ID, each value { "transcript": <presigned url | raw text> }. Same parameter values as Get Transcription Result.

Use the run_id returned when you created the subtitle run. The run must have finished processing and must be a subtitle project.

If the run was created with formatting_options on Create Subtitle, every language’s segments already follow subtitle timing and length rules. The response shape stays the same; only where each segment starts and ends differs.

Choosing your output

Parameter	Values	Behaviour
(none)	n/a	Structured JSON: one language → `{ "transcript": [ ... ] }`; many → `{ "<lang_id>": { "transcript": [ ... ] }, ... }`
`data_type=file`	`srt` / `vtt` / `txt` via `format_type` (default `txt`)	One language → `{ "transcript": "<presigned url>" }`; many → `{ "<lang_id>": { "transcript": "<presigned url>" }, ... }`
`data_type=raw_data`	`srt` / `vtt` / `txt` via `format_type` (default `txt`)	Same shapes as `file`, but each `transcript` value is the rendered text inline

format_type (srt/vtt/txt) and data_type (raw_data/file) use the exact same values as Get Transcription Result. For a single language only, use Get Subtitle Result for Language.

Implementation Example

import requests

API_KEY = "your_api_key_here"
RUN_ID = 12345

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

# 1) Default: structured JSON for every language
result = requests.get(url, headers=headers).json()
if "transcript" in result:
    for segment in result["transcript"]:
        print(f"[{segment['start']} - {segment['end']}] {segment['speaker']}: {segment['text']}")
else:
    for language_id, language_result in result.items():
        print(f"\nLanguage {language_id}:")
        for segment in language_result["transcript"]:
            print(f"  [{segment['start']} - {segment['end']}] {segment['speaker']}: {segment['text']}")

# 2) Export: SRT file URL for every language
srt = requests.get(
    url, headers=headers, params={"format_type": "srt", "data_type": "file"}
).json()
if "transcript" in srt:
    print(f"SRT file: {srt['transcript']}")
else:
    for language_id, payload in srt.items():
        print(f"Language {language_id}: {payload['transcript']}")

# 3) Export: raw VTT text inline for every language
vtt = requests.get(
    url, headers=headers, params={"format_type": "vtt", "data_type": "raw_data"}
).json()
if "transcript" in vtt:
    print(vtt["transcript"][:150])
else:
    for language_id, payload in vtt.items():
        print(f"Language {language_id}:\n{payload['transcript'][:150]}")

Understanding the Response Structure

Default: structured transcript (no params)

Single language on the run

{
  "transcript": [
    { "start": 5.0,  "end": 12.0, "text": "Welcome to our discussion on AI.", "speaker": "SPEAKER_0" },
    { "start": 13.0, "end": 18.0, "text": "Thank you for having me.",         "speaker": "SPEAKER_1" }
  ]
}

Multiple languages on the run

{
  "1": {
    "transcript": [
      { "start": 5.0, "end": 12.0, "text": "Welcome to our discussion on AI.", "speaker": "SPEAKER_0" }
    ]
  },
  "23": {
    "transcript": [
      { "start": 5.0, "end": 12.5, "text": "Bienvenidos a nuestra discusión sobre IA.", "speaker": "SPEAKER_0" }
    ]
  }
}

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`)

Single language

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

Multiple languages

{
  "1":  { "transcript": "https://storage.example.com/.../en_us/output_transcript.srt?..." },
  "23": { "transcript": "https://storage.example.com/.../es_es/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: Welcome to our discussion on AI.
[00:00:13 - 00:00:18] SPEAKER_1: Thank you for having me.

SRT (`format_type=srt`)

1
00:00:05,000 --> 00:00:12,000
SPEAKER_0: Welcome to our discussion on AI.

2
00:00:13,000 --> 00:00:18,000
SPEAKER_1: Thank you for having me.

VTT (`format_type=vtt`)

WEBVTT

00:00:05.000 --> 00:00:12.000
SPEAKER_0: Welcome to our discussion on AI.

00:00:13.000 --> 00:00:18.000
SPEAKER_1: Thank you for having me.

Export: raw data (`data_type=raw_data`)

The same rendered content is returned inline as a string (flat for one language, keyed by language ID for many):

{ "transcript": "1\n00:00:05,000 --> 00:00:12,000\nSPEAKER_0: Welcome to our discussion on AI.\n\n..." }

{
  "1":  { "transcript": "1\n00:00:05,000 --> 00:00:12,000\nSPEAKER_0: Welcome...\n\n..." },
  "23": { "transcript": "1\n00:00:05,000 --> 00:00:12,500\nSPEAKER_0: Bienvenidos...\n\n..." }
}

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

Fetching Multiple Runs at Once

Need subtitles for several runs? Use Fetch Subtitle Run Results (POST /apis/sub-results). It accepts the same optional format_type / data_type query params.

Building a Complete Workflow

Create Subtitle: submit your media for subtitle generation
Get Subtitle Task Status: determine when your subtitles are ready

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.

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. Applies to every language on the run.

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 as the dubbing /transcript and transcription-result endpoints. In export mode the effective defaults are format_type=txt, data_type=file. Applies to every language on the run.

Available options:

raw_data,

file

Response

Successful Response

Single Language
Multiple Languages

One language of a subtitle run: structured dialogue segments by default, or an exported transcript string when format_type/data_type are set.

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

Get Subtitle Result for LanguageRetrieves the transcript in a specific language of a completed subtitle run using the provided `run_id`, with optional export to `srt`/`vtt`/`txt`.

Get Subtitle Result

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

import requests

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

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}', 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}",
  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

Choosing your output

Implementation Example

Understanding the Response Structure

Default: structured transcript (no params)

Single language on the run

Multiple languages on the run

Export: file (`data_type=file`)

Single language

Multiple languages

TXT (`format_type=txt`)

SRT (`format_type=srt`)

VTT (`format_type=vtt`)

Export: raw data (`data_type=raw_data`)

Fetching Multiple Runs at Once

Building a Complete Workflow

Authorizations

Path Parameters

Query Parameters

Response

​Choosing your output

​Implementation Example

​Understanding the Response Structure

​Default: structured transcript (no params)

​Single language on the run

​Multiple languages on the run

​Export: file (data_type=file)

​Single language

​Multiple languages

​TXT (format_type=txt)

​SRT (format_type=srt)

​VTT (format_type=vtt)

​Export: raw data (data_type=raw_data)

​Fetching Multiple Runs at Once

​Building a Complete Workflow

Authorizations

Path Parameters

Query Parameters

Response

Choosing your output

Implementation Example

Understanding the Response Structure

Default: structured transcript (no params)

Single language on the run

Multiple languages on the run

Export: file (`data_type=file`)

Single language

Multiple languages

TXT (`format_type=txt`)

SRT (`format_type=srt`)

VTT (`format_type=vtt`)

Export: raw data (`data_type=raw_data`)

Fetching Multiple Runs at Once

Building a Complete Workflow