How ElevenLabs AI Dubbing Works: Steps and API (2026)

ElevenLabs AI dubbing is the feature that takes a finished video or audio file and produces a version in another language, with the original speakers re-voiced rather than replaced by a generic narrator. You upload a file or paste a link, pick target languages, and get back a translated audio track that tries to keep each person’s voice, tone and timing. This guide explains how that pipeline works, what drives the cost, where automatic dubs go wrong, and how to build a script-first dub yourself with ElevenLabs voices through an API when you need more control.

What is ElevenLabs AI dubbing?

Dubbing means replacing the spoken audio in a piece of media with speech in another language. Traditional dubbing uses translators, voice actors and a studio. ElevenLabs AI dubbing automates every one of those roles: speech recognition writes the transcript, a translation model converts it, and a speech synthesis model (software that generates human-sounding speech from text) voices the result.

The feature lives in two forms inside the ElevenLabs app:

• Automatic dubbing. Upload a file, choose source and target languages, wait, download. Good for quick tests and content where small errors are acceptable.
• Dubbing Studio. The same pipeline, but you can open the result in an editor, fix transcript lines, rewrite translations, reassign speakers, change voices and regenerate individual segments. This is where serious localisation work happens.

Two voice options matter. ElevenLabs can create a voice clone (a synthetic copy of a real person’s voice built from their audio) for each detected speaker, so the Spanish version of your video still sounds like you. Alternatively, you can map a speaker to a similar voice from the ElevenLabs Voice Library, which is useful when cloning is not appropriate or the source audio is too noisy to clone well.

The output is audio. ElevenLabs AI dubbing does not alter the video frames, so on-camera speakers’ lips will not move to match the new language. For screen recordings, voice-over explainers, podcasts and documentary narration, that is rarely a problem. For close-up talking heads it is noticeable.

How the dubbing workflow runs, step by step

Whether you use the app or the dubbing API, the job passes through the same stages. Knowing them helps you predict where things will break.

1. Ingest. The system pulls your file or link and separates the speech from background audio such as music and effects. Clean separation is what lets the final mix keep your original soundtrack.
2. Speaker detection. Also called diarization: working out who speaks when. Each speaker gets a label and, later, a voice. Errors here cause one person’s line to come out in another person’s voice.
3. Transcription. Speech recognition turns each speaker’s audio into timed text. Product names, jargon and accents are the usual weak spots.
4. Translation. The transcript is translated segment by segment. Good systems try to keep each translated line roughly the same spoken length as the original so timing holds.
5. Voice synthesis. Each translated segment is spoken in the cloned or library voice for that speaker, guided by the emotion and pacing of the source line.
6. Mix and export. The new speech is laid back over the separated background audio and exported as a video, an audio file or individual tracks.

In Dubbing Studio, you can step in between stages 3 and 5. Fixing a transcript line or a translation and regenerating only that segment is much faster and cheaper than redoing the whole dub. That editing loop is the main reason to use the Studio rather than one-click dubbing for anything you plan to publish.

Where to intervene for the biggest quality gain

If you only have time for one review pass, check the translation, not the voice. Voices are usually convincing; the meaning is what drifts. Read the target-language script (or have a native speaker skim it), fix names, units and idioms, then regenerate. A five-minute script review removes most of the errors viewers actually notice.

What does ElevenLabs AI dubbing cost?

ElevenLabs bills dubbing in credits from your subscription. The cost of a dub depends on three variables:

• The dubbing model you select, since newer or higher-quality models consume credits at different rates.
• The duration of the source media. A ten-minute video costs more than a two-minute one, regardless of how much of it is speech.
• The number of target languages. Each language is a separate dub, so five languages cost roughly five times one.

Plans and allowances change, so check the current ElevenLabs pricing page for exact numbers rather than relying on screenshots in old tutorials. The practical point is that cost scales with minutes times languages. A long webinar with silent stretches still pays for the silence.

A script-first approach (covered below) scales differently: you pay for the characters you actually speak. For content with lots of pauses, B-roll or on-screen demos, that can work out cheaper. For dense, fast talk with several speakers, the automatic route saves you real assembly work, and your time has a price too.

Where automatic dubbing falls short

ElevenLabs AI dubbing is strong for its category, but every automatic dub fails in predictable ways. Plan for these before you promise a client ten languages by Friday.

Timing and speech length

German and Spanish often take more syllables than English to say the same thing; Japanese or Chinese may take fewer. The system compresses or stretches delivery to fit the original segment, and when the gap is large, speech can sound rushed. The fix is to shorten the translation, not to speed up the voice.

Overlapping speakers and crosstalk

Panels, interviews and podcasts where people interrupt each other confuse speaker detection. Expect to reassign lines in Dubbing Studio. If you control the recording, separate microphones per speaker help more than anything you can do afterwards.

Noisy or music-heavy audio

Clones built from noisy audio sound noisy, and separation struggles when speech and music share the same frequency range. Library voices are often a cleaner choice for these files.

Terminology

Brand names, code identifiers, chemical names and acronyms get transcribed or translated wrongly. Keep a glossary and check every instance.

Consent and rights

Cloning someone’s voice for a dub requires their permission. If you are localising a guest’s interview, ask, or map them to a library voice. In the EU, the AI Act adds transparency obligations for synthetic audio in some contexts, so label AI-dubbed content where your audience or platform expects it.

Building a script-first dub with ElevenLabs models via API

Automatic dubbing starts from the audio and guesses the script. A script-first dub starts from a script you control: you translate and edit the text, then render it with an ElevenLabs voice and place the clips on your editing timeline. You give up automatic speaker detection and background separation; you gain exact wording, predictable timing and per-character pricing.

This suits explainer videos, product demos, courses, ads and anything that already had a written script. It also suits developers building localisation into an app, where a pipeline that calls an API beats clicking through an editor.

On Unicorn API you get three ElevenLabs speech models under one key, priced in credits (monthly plans give credits at $0.01 each; top-ups cost $0.015 per credit and never expire):

Model	Best for	Price	Key inputs
ElevenLabs Text to Speech Multilingual V2	Final narration in many languages, best expressiveness	12 credits per 1,000 characters, per request	text, voice, language_code, stability, similarity_boost, style, speed, previous_text, next_text, timestamps
ElevenLabs Text to Speech Turbo V2.5	Drafts, previews, high-volume or cost-sensitive dubs	6 credits per 1,000 characters, per request	Same fields as Multilingual V2
ElevenLabs Text to Dialogue V3	Short multi-speaker scenes rendered in one request	14 credits per request	dialogue (list of text and voice pairs), stability, language_code

A few fields do most of the dubbing work. language_code sets the target language. speed lets you nudge a line to fit its slot. previous_text and next_text pass the surrounding lines as context so each segment’s intonation flows into the next, which matters a lot when you render line by line. timestamps returns timing data you can use to align captions.

You can try any of these voices in the browser at the audio playground before writing code, and full request details are in the API documentation.

Complete Python example: render a translated script segment by segment

This script takes translated segments with their start times, renders each one with Multilingual V2 in Spanish, passes neighbouring lines as context, and saves numbered MP3 files you can drop onto a timeline. Create a key at /keys and export it as UNICORN_API_KEY.

import os
import time
import requests

API = "https://api.unicornapi.net"
HEADERS = {
    "Authorization": f"Bearer {os.environ['UNICORN_API_KEY']}",
    "Content-Type": "application/json",
}
MODEL = "elevenlabs-text-to-speech-multilingual-v2"
VOICE = "EkK5I93UQWFDigLMpZcX"  # pick any voice ID you have tested

# Translated script: (start time in seconds, Spanish line)
segments = [
    (0.0,  "Hola, en este vídeo te muestro cómo configurar tu primer proyecto."),
    (6.5,  "Primero, abre el panel y crea una clave nueva."),
    (12.0, "Después, copia la clave y guárdala como variable de entorno."),
    (18.5, "Eso es todo. Ya puedes hacer tu primera petición."),
]

def run_job(body):
    r = requests.post(f"{API}/v1/jobs", headers=HEADERS, json=body)
    r.raise_for_status()
    job = r.json()
    while job["status"] not in ("succeeded", "failed"):
        time.sleep(2)
        r = requests.get(f"{API}/v1/jobs/{job['id']}", headers=HEADERS)
        r.raise_for_status()
        job = r.json()
    if job["status"] != "succeeded":
        raise RuntimeError(f"Job {job['id']} failed: {job}")
    return job["outputs"][0]["url"]

os.makedirs("dub_es", exist_ok=True)

for i, (start, text) in enumerate(segments):
    body = {
        "model": MODEL,
        "input": {
            "text": text,
            "voice": VOICE,
            "language_code": "es",
            "previous_text": segments[i - 1][1] if i > 0 else "",
            "next_text": segments[i + 1][1] if i + 1 < len(segments) else "",
        },
    }
    url = run_job(body)
    audio = requests.get(url)
    audio.raise_for_status()
    path = f"dub_es/{i:03d}_{start:07.2f}s.mp3"
    with open(path, "wb") as f:
        f.write(audio.content)
    print("saved", path)

The filenames carry each segment’s start time, so placing them in your editor is mechanical. If a clip overruns its slot, shorten the Spanish line first; only reach for speed when the wording is already as tight as it can be.

Check the price before you run it

Every request can be priced in advance with POST /v1/models/price, sending the same model and input you would send to /v1/jobs:

curl https://api.unicornapi.net/v1/models/price \
  -H "Authorization: Bearer $UNICORN_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"model":"elevenlabs-text-to-speech-multilingual-v2","input":{"text":"Hola, en este vídeo te muestro cómo configurar tu primer proyecto.","voice":"EkK5I93UQWFDigLMpZcX","language_code":"es"}}'

Run this across a whole script to get an exact total before you commit credits to five languages.

Worked example: dubbing a short tutorial into three languages

Say you have a narrated product tutorial and the Spanish translation of its script comes to 2,600 characters. You want Spanish, French and German.

Option A: one request per language. Multilingual V2 charges 12 credits per started block of 1,000 characters, per request. 2,600 characters rounds up to 3 blocks, so each language costs 36 credits, and three languages cost about 108 credits. On a monthly plan that is roughly $1.08; on top-up credits about $1.62. (French and German scripts will differ in length, so price each one.)

Option B: one request per segment. If you split that same script into 20 short lines, every line is under 1,000 characters but still costs a full block: 20 × 12 = 240 credits per language, 720 for three. That is over six times Option A for the same audio.

The lesson is that the per-request rounding rewards fewer, longer requests. A sensible middle ground:

• Group consecutive lines into chunks just under 1,000 characters, aligned to natural pauses such as scene changes or slide transitions.
• Render each chunk with timestamps enabled, then split it in your editor where needed.
• Use Turbo V2.5 at 6 credits per block for review drafts, then render finals with Multilingual V2.

For a two-person scene, such as a short scripted conversation in an ad, Text to Dialogue V3 renders both speakers in one request for a flat 14 credits, which keeps the back-and-forth natural and is simpler than stitching two voices together.

If your original video’s music cannot be separated from the speech, you can generate a replacement bed with Ai Music API Sounds at 2.5 credits per track and mix your new narration over it. Compare monthly plans and top-ups on the pricing page.

Common mistakes when dubbing with AI

1. Publishing the first pass. Whether you use ElevenLabs AI dubbing or a script-first pipeline, a native-speaker read of the translation is the cheapest quality check you can buy.
2. Fixing timing with speed instead of words. Speeding a voice up to fit a slot makes it sound anxious. Rewrite the line shorter.
3. Rendering line by line without context. Each segment then starts and ends with “fresh” intonation, which sounds choppy. Pass previous_text and next_text.
4. Paying for tiny requests. As the worked example shows, per-request rounding can multiply costs. Batch lines into larger chunks.
5. Cloning without permission. Get consent from every person whose voice you reproduce, or use a library voice.
6. Using one voice for every language without listening. A voice that sounds natural in English can sound accented in another language. Audition a few voices per target language in the playground first.
7. Forgetting captions and on-screen text. A Spanish voice over English slides feels half-finished. Budget for translated subtitles and graphics.

Which route should you pick?

The right choice depends on what you start with: finished media or a script.

Situation	Better fit	Why
Existing interviews, podcasts or vlogs with no script	ElevenLabs AI dubbing (Dubbing Studio)	Speaker detection, transcription and background separation are done for you
Several overlapping speakers	Dubbing Studio	You can reassign speakers in an editor instead of rebuilding the timeline
Scripted explainers, courses, ads, demos	Script-first via API	Exact wording, per-character pricing, no paying for silence
Localisation built into your own app or pipeline	Script-first via API	Programmatic control, prices known before each request
On-camera talking heads where lip sync matters	Either, plus a lip-sync video tool	Neither route changes mouth movements

Many teams use both: ElevenLabs AI dubbing for back-catalogue videos that never had scripts, and a script-first API pipeline for new content written with localisation in mind. If you work from an editor like Cursor or Claude Code, you can also drive the same models through the agent integrations and let your assistant batch the requests.

Start small either way: dub one minute into one language, have a native speaker review it, and fix the process before you scale to the whole library. Browse the other voice and audio options in the model catalog when you are ready to expand.