# Video Dubbing & Translation (`zhanji/video-dubbing-translation`) Actor

Dub any video or audio into 32+ languages using AI-powered voice cloning. Supports YouTube URLs, direct video links, and SRT transcript export.

- **URL**: https://apify.com/zhanji/video-dubbing-translation.md
- **Developed by:** [Zhanji](https://apify.com/zhanji) (community)
- **Categories:** Videos, AI, Agents
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $2,500.00 / 1,000 dubbed minutes

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## Video Dubbing & Translation

Automatically dub any video or audio into **32+ languages** using AI-powered voice cloning from ElevenLabs. Just paste a YouTube URL, pick your target languages, and get back professionally dubbed videos with optional SRT transcripts.

### What it does

This actor takes a video (via YouTube URL or direct link) and creates dubbed versions in your chosen languages. The AI clones the original speaker's voice and translates the speech naturally — preserving tone, emotion, and timing.

**Each dubbed language produces:**
- A full dubbed video file (MP4)
- An optional SRT subtitle transcript

### Supported Languages (32)

English, Spanish, French, German, Italian, Portuguese, Polish, Turkish, Russian, Dutch, Czech, Arabic, Chinese (Mandarin), Japanese, Korean, Hindi, Tamil, Indonesian, Malay, Swedish, Danish, Finnish, Greek, Ukrainian, Romanian, Bulgarian, Slovak, Croatian, Filipino, Hungarian, Vietnamese, Norwegian

### How it works

1. **You provide** a YouTube URL (or direct video link) + your ElevenLabs API key
2. **The actor downloads** the video in your chosen quality
3. **ElevenLabs AI** analyzes speakers, translates speech, and clones voices
4. **You get** dubbed video files + SRT transcripts in the output

### Input Parameters

| Parameter | Required | Default | Description |
|-----------|----------|---------|-------------|
| `videoUrl` | Yes | — | YouTube URL or direct link to video/audio |
| `elevenLabsApiKey` | Yes | — | Your ElevenLabs API key ([get one here](https://elevenlabs.io)) |
| `targetLanguages` | Yes | `["es"]` | Array of target language codes |
| `sourceLanguage` | No | `auto` | Source language (auto-detected by default) |
| `downloadQuality` | No | `hd` | `hd`, `fast`, or `audio_only` |
| `numSpeakers` | No | `0` | Number of speakers (0 = auto-detect) |
| `disableVoiceCloning` | No | `false` | Use library voices instead of cloning |
| `dropBackgroundAudio` | No | `false` | Remove background music from output |
| `includeTranscripts` | No | `true` | Export SRT subtitle files |

### Example Input

```json
{
  "videoUrl": "https://www.youtube.com/watch?v=dQw4w9WgXcQ",
  "elevenLabsApiKey": "xi-your-api-key-here",
  "targetLanguages": ["es", "fr", "de"],
  "sourceLanguage": "en",
  "downloadQuality": "hd",
  "includeTranscripts": true
}
````

### Example Output

The actor pushes results to the default dataset:

```json
[
  {
    "language": "es",
    "status": "completed",
    "videoKey": "dubbed_es",
    "transcriptKey": "transcript_es",
    "fileSize": 15234567,
    "durationMinutes": 3
  },
  {
    "language": "fr",
    "status": "completed",
    "videoKey": "dubbed_fr",
    "transcriptKey": "transcript_fr",
    "fileSize": 15198432,
    "durationMinutes": 3
  }
]
```

Dubbed videos and transcripts are stored in the actor's key-value store. Access them via the Apify API or Console.

### Cost Estimate

This actor uses **Pay-Per-Event** pricing, charged per dubbed minute:

| Video Length | 1 Language | 3 Languages | 5 Languages |
|-------------|-----------|------------|------------|
| 1 minute | ~$2-3 | ~$6-9 | ~$10-15 |
| 5 minutes | ~$10-15 | ~$30-45 | ~$50-75 |
| 10 minutes | ~$20-30 | ~$60-90 | ~$100-150 |

**Note:** You also pay for ElevenLabs API usage with your own API key. ElevenLabs Pro plan costs ~$0.50-1.10 per dubbed minute.

### Requirements

- **ElevenLabs API key** — Sign up at [elevenlabs.io](https://elevenlabs.io). A Pro plan ($99/mo) or higher is recommended for dubbing.
- **Apify account** — Free to sign up, pay-per-use pricing.

### Limitations

- Maximum video duration: 2.5 hours (ElevenLabs limit)
- Maximum file size: 1 GB
- Dubbing a 10-minute video takes approximately 5-15 minutes of processing time
- One language is dubbed at a time (sequential processing)

### Use Cases

- **Content creators** — Expand your YouTube audience to global markets
- **Course creators** — Translate educational content for international students
- **Marketing teams** — Localize promotional videos for different regions
- **Podcast producers** — Create multilingual versions of audio content
- **Media companies** — Automate video translation at scale

### Support

If you encounter issues, check that:

1. Your ElevenLabs API key is valid and has dubbing credits
2. The video URL is publicly accessible
3. The video is under 2.5 hours and 1 GB

For bugs or feature requests, open an issue on the actor's GitHub repository.

# Actor input Schema

## `videoUrl` (type: `string`):

YouTube URL or direct link to a video/audio file.

## `sourceLanguage` (type: `string`):

Language of the original video. Use 'auto' for automatic detection.

## `targetLanguages` (type: `array`):

Languages to dub the video into. Each language produces a separate output file.

## `elevenLabsApiKey` (type: `string`):

Your ElevenLabs API key. Get one at https://elevenlabs.io

## `numSpeakers` (type: `integer`):

Number of speakers in the video. Set to 0 for auto-detection.

## `disableVoiceCloning` (type: `boolean`):

Use library voices instead of cloning the original speaker's voice.

## `dropBackgroundAudio` (type: `boolean`):

Remove background music/audio from the dubbed output.

## `includeTranscripts` (type: `boolean`):

Export SRT subtitle files alongside dubbed videos.

## `downloadQuality` (type: `string`):

Video quality when downloading from YouTube/URLs.

## `youTubeCookies` (type: `string`):

Optional fallback: YouTube cookies in Netscape format. Only needed if the residential proxy doesn't work. Export from your browser using a cookie export extension.

## `proxyConfiguration` (type: `object`):

Proxy for downloading YouTube videos. Residential proxies are used automatically for YouTube URLs.

## Actor input object example

```json
{
  "videoUrl": "https://www.youtube.com/watch?v=example",
  "sourceLanguage": "auto",
  "targetLanguages": [
    "es"
  ],
  "numSpeakers": 0,
  "disableVoiceCloning": false,
  "dropBackgroundAudio": false,
  "includeTranscripts": true,
  "downloadQuality": "hd"
}
```

# Actor output Schema

## `resultsSummary` (type: `string`):

Overview of all dubbed languages with status

## `keyValueStore` (type: `string`):

Download dubbed video files (dubbed\_LANG) and SRT transcripts (transcript\_LANG) from the key-value store

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "videoUrl": "https://www.youtube.com/watch?v=example"
};

// Run the Actor and wait for it to finish
const run = await client.actor("zhanji/video-dubbing-translation").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = { "videoUrl": "https://www.youtube.com/watch?v=example" }

# Run the Actor and wait for it to finish
run = client.actor("zhanji/video-dubbing-translation").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "videoUrl": "https://www.youtube.com/watch?v=example"
}' |
apify call zhanji/video-dubbing-translation --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=zhanji/video-dubbing-translation",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Video Dubbing & Translation",
        "description": "Dub any video or audio into 32+ languages using AI-powered voice cloning. Supports YouTube URLs, direct video links, and SRT transcript export.",
        "version": "0.1",
        "x-build-id": "KlZ9ig6q665Job21V"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/zhanji~video-dubbing-translation/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-zhanji-video-dubbing-translation",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/zhanji~video-dubbing-translation/runs": {
            "post": {
                "operationId": "runs-sync-zhanji-video-dubbing-translation",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/zhanji~video-dubbing-translation/run-sync": {
            "post": {
                "operationId": "run-sync-zhanji-video-dubbing-translation",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "videoUrl",
                    "targetLanguages",
                    "elevenLabsApiKey"
                ],
                "properties": {
                    "videoUrl": {
                        "title": "Video URL",
                        "type": "string",
                        "description": "YouTube URL or direct link to a video/audio file."
                    },
                    "sourceLanguage": {
                        "title": "Source Language",
                        "enum": [
                            "auto",
                            "en",
                            "es",
                            "fr",
                            "de",
                            "it",
                            "pt",
                            "pl",
                            "tr",
                            "ru",
                            "nl",
                            "cs",
                            "ar",
                            "zh",
                            "ja",
                            "ko",
                            "hi",
                            "ta",
                            "id",
                            "ms",
                            "sv",
                            "da",
                            "fi",
                            "el",
                            "uk",
                            "ro",
                            "bg",
                            "sk",
                            "hr",
                            "fil",
                            "hu",
                            "vi",
                            "no"
                        ],
                        "type": "string",
                        "description": "Language of the original video. Use 'auto' for automatic detection.",
                        "default": "auto"
                    },
                    "targetLanguages": {
                        "title": "Target Languages",
                        "type": "array",
                        "description": "Languages to dub the video into. Each language produces a separate output file.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "en",
                                "es",
                                "fr",
                                "de",
                                "it",
                                "pt",
                                "pl",
                                "tr",
                                "ru",
                                "nl",
                                "cs",
                                "ar",
                                "zh",
                                "ja",
                                "ko",
                                "hi",
                                "ta",
                                "id",
                                "ms",
                                "sv",
                                "da",
                                "fi",
                                "el",
                                "uk",
                                "ro",
                                "bg",
                                "sk",
                                "hr",
                                "fil",
                                "hu",
                                "vi",
                                "no"
                            ],
                            "enumTitles": [
                                "English",
                                "Spanish",
                                "French",
                                "German",
                                "Italian",
                                "Portuguese",
                                "Polish",
                                "Turkish",
                                "Russian",
                                "Dutch",
                                "Czech",
                                "Arabic",
                                "Chinese (Mandarin)",
                                "Japanese",
                                "Korean",
                                "Hindi",
                                "Tamil",
                                "Indonesian",
                                "Malay",
                                "Swedish",
                                "Danish",
                                "Finnish",
                                "Greek",
                                "Ukrainian",
                                "Romanian",
                                "Bulgarian",
                                "Slovak",
                                "Croatian",
                                "Filipino",
                                "Hungarian",
                                "Vietnamese",
                                "Norwegian"
                            ]
                        },
                        "default": [
                            "es"
                        ]
                    },
                    "elevenLabsApiKey": {
                        "title": "ElevenLabs API Key",
                        "type": "string",
                        "description": "Your ElevenLabs API key. Get one at https://elevenlabs.io"
                    },
                    "numSpeakers": {
                        "title": "Number of Speakers",
                        "minimum": 0,
                        "maximum": 20,
                        "type": "integer",
                        "description": "Number of speakers in the video. Set to 0 for auto-detection.",
                        "default": 0
                    },
                    "disableVoiceCloning": {
                        "title": "Disable Voice Cloning",
                        "type": "boolean",
                        "description": "Use library voices instead of cloning the original speaker's voice.",
                        "default": false
                    },
                    "dropBackgroundAudio": {
                        "title": "Drop Background Audio",
                        "type": "boolean",
                        "description": "Remove background music/audio from the dubbed output.",
                        "default": false
                    },
                    "includeTranscripts": {
                        "title": "Include SRT Transcripts",
                        "type": "boolean",
                        "description": "Export SRT subtitle files alongside dubbed videos.",
                        "default": true
                    },
                    "downloadQuality": {
                        "title": "Download Quality (for URLs)",
                        "enum": [
                            "hd",
                            "fast",
                            "audio_only"
                        ],
                        "type": "string",
                        "description": "Video quality when downloading from YouTube/URLs.",
                        "default": "hd"
                    },
                    "youTubeCookies": {
                        "title": "YouTube Cookies (Netscape format)",
                        "type": "string",
                        "description": "Optional fallback: YouTube cookies in Netscape format. Only needed if the residential proxy doesn't work. Export from your browser using a cookie export extension."
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Proxy for downloading YouTube videos. Residential proxies are used automatically for YouTube URLs."
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
