End to End Dubbing

POST

dub

End To End Dubbing

curl --request POST \
  --url https://client.camb.ai/apis/dub \
  --header 'Content-Type: application/json' \
  --header 'x-api-key: <api-key>' \
  --data '
{
  "source_language": "en-us",
  "source_transcript": {
    "content": "1\n00:00:00,500 --> 00:00:02,800\nWelcome back.\n",
    "format": "srt"
  },
  "target_transcripts": null,
  "video_url": null,
  "target_languages": [
    "es-es",
    "fr-fr"
  ],
  "project_name": null,
  "project_description": null,
  "selected_audio_tracks": null,
  "add_output_as_an_audio_track": null,
  "chosen_dictionaries": null,
  "target_language": "fr-fr",
  "transcription_mode": "fast",
  "include_music_in_fg": true
}
'

import requests

url = "https://client.camb.ai/apis/dub"

payload = {
    "source_language": "en-us",
    "source_transcript": {
        "content": "1
00:00:00,500 --> 00:00:02,800
Welcome back.
",
        "format": "srt"
    },
    "target_transcripts": None,
    "video_url": None,
    "target_languages": ["es-es", "fr-fr"],
    "project_name": None,
    "project_description": None,
    "selected_audio_tracks": None,
    "add_output_as_an_audio_track": None,
    "chosen_dictionaries": None,
    "target_language": "fr-fr",
    "transcription_mode": "fast",
    "include_music_in_fg": True
}
headers = {
    "x-api-key": "<api-key>",
    "Content-Type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.text)

const options = {
  method: 'POST',
  headers: {'x-api-key': '<api-key>', 'Content-Type': 'application/json'},
  body: JSON.stringify({
    source_language: 'en-us',
    source_transcript: {content: '1\n00:00:00,500 --> 00:00:02,800\nWelcome back.\n', format: 'srt'},
    target_transcripts: null,
    video_url: null,
    target_languages: ['es-es', 'fr-fr'],
    project_name: null,
    project_description: null,
    selected_audio_tracks: null,
    add_output_as_an_audio_track: null,
    chosen_dictionaries: null,
    target_language: 'fr-fr',
    transcription_mode: 'fast',
    include_music_in_fg: true
  })
};

fetch('https://client.camb.ai/apis/dub', 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/dub",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'source_language' => 'en-us',
    'source_transcript' => [
        'content' => '1
00:00:00,500 --> 00:00:02,800
Welcome back.
',
        'format' => 'srt'
    ],
    'target_transcripts' => null,
    'video_url' => null,
    'target_languages' => [
        'es-es',
        'fr-fr'
    ],
    'project_name' => null,
    'project_description' => null,
    'selected_audio_tracks' => null,
    'add_output_as_an_audio_track' => null,
    'chosen_dictionaries' => null,
    'target_language' => 'fr-fr',
    'transcription_mode' => 'fast',
    'include_music_in_fg' => true
  ]),
  CURLOPT_HTTPHEADER => [
    "Content-Type: application/json",
    "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;
}

{
  "task_id": "<string>"
}

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

Transform your media content for global audiences with our comprehensive dubbing solution. This powerful endpoint automates the entire dubbing process, taking your original media and producing a version that speaks naturally in your target language. The system handles everything from transcription to voice synthesis, delivering professional-quality results without requiring specialized audio engineering knowledge.

The Dubbing Process

When you submit a dubbing request, our system begins a multi-stage workflow:

Project Setup

Our intelligent system works its magic behind the scenes to prepare your content for flawless localization.

Translation

The transcribed text is expertly translated to your target language using our proprietary translation engine BOLI.

Voiceover Generation

Voiceovers are created using natural-sounding synthetic voices using our in-house novel speech model MARS.

Final Assembly

Everything is combined into a seamless final product.

Throughout this process, you can check on your task’s progress using the /dub/{task_id} endpoint with the task_id provided in your initial response.

Compatible Media Sources

Our dubbing service accommodates various media sources to fit your workflow needs. The video_url parameter in your request can point to any of the following:

Online Platforms

Use content directly from popular content platforms:

YouTube videos: Simply provide the standard YouTube video URL.
Google Drive: Link to media files stored in Google Drive (ensure they’re publicly accessible).
Direct URLs: Any direct link to a media file that doesn’t require authentication.

Supported File Formats

Our system processes a wide range of professional and consumer media formats:

Media Type	Supported Formats
Video Files	MP4, MOV, MXF
Audio Files	MP3, FLAC, WAV, AAC

This flexibility allows you to work with both broadcast-quality content and consumer-grade media without conversion hassles.

Please note that MXF format support is exclusively available to customers on our Enterprise plan, offering professional broadcast-quality media handling for organizations with advanced needs.

Language Configuration

Specifying the right languages is crucial for successful dubbing. Your request needs to include:

Source Language: The original language spoken in your media.
Target Language(s): The language(s) you want your content to be dubbed into.

Both parameters require specific language identifiers from our system. To find the correct IDs:

Query the /source-languages endpoint for available source language options.
Check the /target-languages endpoint for supported target languages.

Using these official IDs ensures our system correctly processes your content.

Transcription Mode

The optional transcription_mode request field controls the transcription pass used before dubbing:

fast (default): returns a transcript more quickly while maintaining quality.
slow: takes longer and may produce a more accurate transcript through a more thorough pass.

Omit the field to use fast.

Keeping Music in the Foreground

The optional include_music_in_fg parameter controls how background music is handled during source separation:

true (default): music is preserved in the foreground audio alongside speech.
false: music is stripped out of the foreground, isolating speech.

Omit the parameter to keep the default behaviour of retaining music.

Creating Your First Dubbing request

Let’s look at how to initiate a dubbing task with Python:

import requests
import json
import time

# Your API authentication
headers = {
    "x-api-key": "your-api-key",  # Replace with your actual API key
    "Content-Type": "application/json"
}

# Define your dubbing request parameters
dubbing_request = {
    "video_url": "https://www.youtube.com/watch?v=exampleVideo",  # Your media URL
    "source_language": "en-us",      # Locale tag. Numeric IDs (e.g. 1) still work but are deprecated.
    "target_languages": ["es-es"],
    "transcription_mode": "fast",
    "include_music_in_fg": True,     # keep music in the foreground audio (default); set False to strip it
}

# Submit the dubbing request
def submit_dubbing_task(payload):
    """
    Submits a new dubbing task and returns the task ID for tracking.
    """
    try:
        response = requests.post(
            "https://client.camb.ai/apis/dub",
            headers=headers,
            data=json.dumps(payload)
        )

        # Verify the request was successful
        response.raise_for_status()

        # Extract the task ID from the response
        result = response.json()
        task_id = result.get("task_id")

        print(f"Dubbing task submitted successfully! Task ID: {task_id}")
        return task_id

    except requests.exceptions.RequestException as e:
        print(f"Error submitting dubbing task: {e}")
        if hasattr(e, 'response') and e.response is not None:
            print(f"Response content: {e.response.text}")
        return None

# Call the function to submit your dubbing task
task_id = submit_dubbing_task(dubbing_request)

Monitoring Your Dubbing Progress

After submission, your content enters our processing pipeline. The time required depends on the length and complexity of your media. You can check progress by polling the status endpoint:

def check_dubbing_status(task_id):
    """
    Checks the status of a dubbing task.
    Returns the current status and any available result information.
    """
    if not task_id:
        print("No task ID provided.")
        return None

    try:
        response = requests.get(
            f"https://client.camb.ai/apis/dub/{task_id}",
            headers=headers
        )

        # Verify the request was successful
        response.raise_for_status()

        # Parse the status information
        status_data = response.json()
        print(f"Current status: {status_data['status']}")

        return status_data

    except requests.exceptions.RequestException as e:
        print(f"Error checking dubbing status: {e}")
        return None

# Check the status of your task
status_info = check_dubbing_status(task_id)

Use Your Own Transcript or Translation

You can include SRT file contents directly in the JSON body of POST /dub:

source_transcript: an optional transcript in source_language.
target_transcripts: optional translations, each with a language matching one of your requested target languages. Supply at most one SRT per language.

Each script takes content containing the SRT text and an optional format, whose only supported value is srt. Read the file as UTF-8; do not send a filename, URL, base64 string, multipart upload, or an array of segments.

from pathlib import Path
import requests

payload = {
    "video_url": "https://example.com/video.mp4",
    "source_language": "en-us",
    "target_languages": ["es-es", "fr-fr"],
    "source_transcript": {
        "format": "srt",
        "content": Path("original.srt").read_text(encoding="utf-8"),
    },
    "target_transcripts": [
        {
            "language": "es-es",
            "format": "srt",
            "content": Path("spanish.srt").read_text(encoding="utf-8"),
        }
    ],
}
response = requests.post(
    "https://client.camb.ai/apis/dub",
    headers={"x-api-key": "your-api-key"},
    json=payload,
    timeout=60,
)
response.raise_for_status()
task_id = response.json()["task_id"]

This example supplies the original transcript and Spanish translation; French is translated automatically. You can also send only source_transcript, only target_transcripts, or neither. If you have the original transcript, include it alongside your translations to provide source-language context. Requests without these fields retain the existing automatic workflow. The task ID, polling, and result endpoints are unchanged. The API stores supplied scripts as temporary .srt objects under temp/ in your workspace’s configured storage before passing them to the dubbing pipeline. An SRT content string looks like this in JSON:

{
  "format": "srt",
  "content": "1\n00:00:00,500 --> 00:00:02,800\nWelcome back.\n"
}

Validation and limits

Maximum 2 MiB of UTF-8 text per script; 10 MiB combined across the original and translations, with at most 100 target scripts.
Scripts must contain at least one cue parseable by the srt library. Standard SRT uses HH:MM:SS,mmm --> HH:MM:SS,mmm and blank lines between cues. Parsing uses the srt library with parse errors enabled; its supported variations, including dot-separated milliseconds, are also accepted.
Overlapping and out-of-order cues are accepted. No additional cue-count, numbering, timing, control-character, or dialogue-content checks are imposed beyond the parser. UTF-8 BOM and Windows/Mac line endings are normalized.
Target scripts must use supported languages selected in target_languages (or the legacy target_language). Language aliases are normalized before checking for duplicates. Unknown properties inside a script are rejected.

Invalid scripts return HTTP 422 before script storage or dubbing submission. Errors identify the input field. Unparseable SRT returns SRT content could not be parsed; check cue numbers and timestamps. Use timestamps relative to the original media and scripts that match that media. Request validation checks SRT structure; it does not download the media to check its duration or verify the language of your text. Supplied scripts use the existing dubbing pipeline’s timing and speech processing; this option does not introduce an exact-wording or exact-timing output mode.

Best Practices for Optimal Results

To get the most from our dubbing service, consider these professional tips:

Source Quality Matters: Higher quality original media yields better dubbing results.
Language Selection: Choose the right language for your audience to ensure clarity and authenticity.

Practical Applications

Our end-to-end dubbing functionality opens exciting possibilities across industries:

E-Learning: Make educational content accessible to global learners.
Marketing: Localize promotional videos for international markets.
Entertainment: Bring films and shows to new language audiences.
Corporate Communications: Ensure company messages reach multilingual teams.
Social Media: Expand your content’s reach across language barriers.

By integrating this API into your workflow, you can dramatically reduce the time and expense traditionally associated with professional dubbing while maintaining impressive quality.

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.

Body

application/json

source_language

string

required

The language of the input text. Pass a locale tag (en-us, fr-fr, es-es). Numeric language IDs (1 or "1") still work but are deprecated. See all source languages.

Example:

"en-us"

source_transcript

object | null

Optional original-language SRT contents. Send the file text in JSON, not a file path or URL.

Hide child attributes

source_transcript.content

string

required

SRT file contents, limited to 2 MiB encoded as UTF-8. Must contain at least one cue parsed by the srt library with parse errors enabled. No additional cue-count, numbering, timing, ordering, control-character, or dialogue-content checks are imposed beyond the parser. Overlapping and out-of-order cues are accepted. BOM and CRLF/CR line endings are normalized. Scripts are stored under temp/ in the workspace's configured storage.

Required string length: 1 - 2097152

Example:

"1\n00:00:00,500 --> 00:00:02,800\nWelcome back.\n"

source_transcript.format

enum<string>

default:srt

Available options:

srt

target_transcripts

object[] | null

Optional translated SRTs, one per requested target language. Languages must be unique after normalization. Source and target SRT contents must not exceed 10 MiB UTF-8 combined.

Maximum array length: 100

Hide child attributes

target_transcripts.language

string

required

target_transcripts.content

string

required

Translated SRT file contents. The same parser validation and 2 MiB UTF-8 limit as source_transcript apply.

Required string length: 1 - 2097152

Example:

"1\n00:00:00,500 --> 00:00:02,800\nBienvenidos de nuevo.\n"

target_transcripts.format

enum<string>

default:srt

Available options:

srt

video_url

string | null

The URL of the media file to be used to create the end-to-end dubbing task.

Example:

null

target_languages

string[]

Languages to generate output in. Pass locale tags (es-es, fr-fr, de-de). Numeric language IDs still work but are deprecated. See all target languages.

Example:

["es-es", "fr-fr"]

project_name

string | null

Enter a distinctive name for your project that reflects its purpose or content. This name will be displayed in your CAMB.AI workspace dashboard and used to organize related assets, transcriptions, etc.. . Choose something memorable that helps you quickly identify this specific project among your other voice, audio and localization tasks.

Required string length: 3 - 255

Example:

null

project_description

string | null

Provide details about your project's goals and specifications. Include information such as the target languages for translation or dubbing, desired voice characteristics, emotional tones to capture, or specific audio processing requirements, outlining the workflow here can serve as valuable documentation for organizational purposes.

Required string length: 3 - 5000

Example:

null

selected_audio_tracks

integer[] | null

Optional array of one or two zero‑based audio track indices to dub. Only supported for MXF files. If omitted, the first audio track (index 0) is used by default.

Required array length: 1 - 2 elements

add_output_as_an_audio_track

boolean | null

Optional flag to append the dubbed audio as a new audio track in the output file. Only supported for MXF files. If true, the dubbed audio is added as an additional track; if false or omitted, the source would be returned with only dubbed audio.

chosen_dictionaries

integer[] | null

An optional list of dictionary IDs selected by the user. Each entry must be an integer corresponding to a valid dictionary ID. If provided, at least one ID is required.

Minimum array length: 1

target_language

string

The target output language. Pass a locale tag (fr-fr, es-es, de-de). Numeric language IDs still work but are deprecated. See all target languages.

Example:

"fr-fr"

transcription_mode

enum<string>

default:fast

Transcription mode. fast (default) is quicker; slow takes longer and may produce a more accurate transcript.

Available options:

fast,

slow

include_music_in_fg

boolean

default:true

Keep music in the foreground audio during source separation. When true (default), background music is preserved alongside speech; set to false to strip music out of the foreground.

Example:

true

Response

Successful Response

A JSON that contains the unique identifier for the task. This is used to query the status of the end to end dubbing task that is running. It is returned when a create request is made for a dub

task_id

string

Last modified on September 11, 2026

End To End Dubbing

curl --request POST \
  --url https://client.camb.ai/apis/dub \
  --header 'Content-Type: application/json' \
  --header 'x-api-key: <api-key>' \
  --data '
{
  "source_language": "en-us",
  "source_transcript": {
    "content": "1\n00:00:00,500 --> 00:00:02,800\nWelcome back.\n",
    "format": "srt"
  },
  "target_transcripts": null,
  "video_url": null,
  "target_languages": [
    "es-es",
    "fr-fr"
  ],
  "project_name": null,
  "project_description": null,
  "selected_audio_tracks": null,
  "add_output_as_an_audio_track": null,
  "chosen_dictionaries": null,
  "target_language": "fr-fr",
  "transcription_mode": "fast",
  "include_music_in_fg": true
}
'

import requests

url = "https://client.camb.ai/apis/dub"

payload = {
    "source_language": "en-us",
    "source_transcript": {
        "content": "1
00:00:00,500 --> 00:00:02,800
Welcome back.
",
        "format": "srt"
    },
    "target_transcripts": None,
    "video_url": None,
    "target_languages": ["es-es", "fr-fr"],
    "project_name": None,
    "project_description": None,
    "selected_audio_tracks": None,
    "add_output_as_an_audio_track": None,
    "chosen_dictionaries": None,
    "target_language": "fr-fr",
    "transcription_mode": "fast",
    "include_music_in_fg": True
}
headers = {
    "x-api-key": "<api-key>",
    "Content-Type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.text)

const options = {
  method: 'POST',
  headers: {'x-api-key': '<api-key>', 'Content-Type': 'application/json'},
  body: JSON.stringify({
    source_language: 'en-us',
    source_transcript: {content: '1\n00:00:00,500 --> 00:00:02,800\nWelcome back.\n', format: 'srt'},
    target_transcripts: null,
    video_url: null,
    target_languages: ['es-es', 'fr-fr'],
    project_name: null,
    project_description: null,
    selected_audio_tracks: null,
    add_output_as_an_audio_track: null,
    chosen_dictionaries: null,
    target_language: 'fr-fr',
    transcription_mode: 'fast',
    include_music_in_fg: true
  })
};

fetch('https://client.camb.ai/apis/dub', 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/dub",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'source_language' => 'en-us',
    'source_transcript' => [
        'content' => '1
00:00:00,500 --> 00:00:02,800
Welcome back.
',
        'format' => 'srt'
    ],
    'target_transcripts' => null,
    'video_url' => null,
    'target_languages' => [
        'es-es',
        'fr-fr'
    ],
    'project_name' => null,
    'project_description' => null,
    'selected_audio_tracks' => null,
    'add_output_as_an_audio_track' => null,
    'chosen_dictionaries' => null,
    'target_language' => 'fr-fr',
    'transcription_mode' => 'fast',
    'include_music_in_fg' => true
  ]),
  CURLOPT_HTTPHEADER => [
    "Content-Type: application/json",
    "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;
}

{
  "task_id": "<string>"
}

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

Getting Started

Models

Tutorials

SDK Guides

Hosting Platforms

Integrations

API Reference

Other Products

Release Logs

End to End Dubbing

The Dubbing Process

Compatible Media Sources

Online Platforms

Supported File Formats

Language Configuration

Transcription Mode

Keeping Music in the Foreground

Creating Your First Dubbing request

Monitoring Your Dubbing Progress

Use Your Own Transcript or Translation

Validation and limits

Best Practices for Optimal Results

Practical Applications

Authorizations

Body

Response

​The Dubbing Process

​Compatible Media Sources

​Online Platforms

​Supported File Formats

​Language Configuration

​Transcription Mode

​Keeping Music in the Foreground

​Creating Your First Dubbing request

​Monitoring Your Dubbing Progress

​Use Your Own Transcript or Translation

​Validation and limits

​Best Practices for Optimal Results

​Practical Applications

Authorizations

Body

Response

The Dubbing Process

Compatible Media Sources

Online Platforms

Supported File Formats

Language Configuration

Transcription Mode

Keeping Music in the Foreground

Creating Your First Dubbing request

Monitoring Your Dubbing Progress

Use Your Own Transcript or Translation

Validation and limits

Best Practices for Optimal Results

Practical Applications