ElevenLabs Dubbing

Dubbing audio ou vidéo dans d'autres langues tout en préservant les voix des locuteurs originaux. Créez un projet à partir d'un fichier ou d'une URL, passez en revue et modifiez la transcription source, ajoutez une ou plusieurs langues cibles, affinez les traductions par segment et régénérez les résultats.

Important : Utilisez l'API Dubbing Projects — elevenlabs.dubbing.project.* dans les SDKs, ou les endpoints REST /v1/dubbing/project. Ne n'utilisez pas la surface de dubbing v1 héritée (client.dubbing.create(), client.dubbing.get(), client.dubbing.audio.get(), ou les routes /v1/dubbing nues) — c'est l'ancienne API de dubbing, désormais dans Legacy dans la référence API.

Configuration : Consultez le Guide d'installation. L'URL de base REST est https://api.elevenlabs.io avec votre clé API dans l'en-tête xi-api-key ; les SDKs lisent ELEVENLABS_API_KEY automatiquement.

Concepts

Ordre d'opérations recommandé : finalisez la transcription source avant d'ajouter des langues. Les traductions sont produites à partir de la source, donc corriger la source en premier signifie que chaque langue commence à partir du bon texte — modifier la source après la fin d'une langue la marque comme stale et nécessite une régénération (facturée).

Enterprise : La modification de transcription et la régénération sont disponibles pour les espaces de travail enterprise uniquement. La création de projets, l'ajout de langues et le téléchargement de doublages fonctionnent sur tous les plans.

Workflow

1. Créer le projet à partir d'un fichier ou d'une URL → queued
2. Interroger le projet jusqu'à ready
3. Passer en revue et finaliser la transcription source (modifier/ajouter/supprimer des segments)
4. Ajouter une langue par cible → queued → processing → completed
5. Télécharger l'outputs.lossless_audio de chaque langue quand completed
6. Affiner les traductions par segment si nécessaire → la langue devient stale
7. Régénérer la langue → completed à nouveau avec une sortie fraîche

Démarrage rapide (Python)

import os
import time
import requests
from elevenlabs.client import ElevenLabs

elevenlabs = ElevenLabs(api_key=os.getenv("ELEVENLABS_API_KEY"))

# 1. Créer un projet à partir d'un fichier local (ou passer source_url=... au lieu de file)
with open("promo.mp4", "rb") as f:
    project = elevenlabs.dubbing.project.create(
        file=f,
        source_language="en",
        reference="Q3 marketing video",
    )

# 2. Attendre que le média source soit transcrit
while True:
    project = elevenlabs.dubbing.project.get(project.project_id)
    if project.status == "ready":
        break
    if project.status == "failed":
        raise RuntimeError("Project preparation failed")
    time.sleep(5)

# 3. Ajouter une cible de langue espagnole
language = elevenlabs.dubbing.project.language.create(
    project.project_id,
    target_language="es",
)

# 4. Attendre que le doublage finisse de se générer
while True:
    language = elevenlabs.dubbing.project.language.get(
        project.project_id, language.language_id
    )
    if language.status == "completed":
        break
    if language.status == "failed":
        raise RuntimeError("Dub generation failed")
    time.sleep(5)

# 5. Télécharger l'audio doublé (URL signée, valide ~1 heure — réinterroger la langue pour une nouvelle)
audio = requests.get(language.outputs.lossless_audio)
with open("promo_es.wav", "wb") as f:
    f.write(audio.content)

Démarrage rapide (JavaScript)

import { ElevenLabsClient } from "@elevenlabs/elevenlabs-js";
import { writeFile } from "fs/promises";

const elevenlabs = new ElevenLabsClient();

// 1. Créer un projet (sourceUrl montré ; l'upload de fichier est aussi supporté)
let project = await elevenlabs.dubbing.project.create({
  sourceUrl: "https://example.com/promo.mp4",
  sourceLanguage: "en",
  reference: "Q3 marketing video",
});

// 2. Attendre que le média source soit transcrit
while (true) {
  project = await elevenlabs.dubbing.project.get(project.projectId);
  if (project.status === "ready") break;
  if (project.status === "failed") throw new Error("Project preparation failed");
  await new Promise((resolve) => setTimeout(resolve, 5000));
}

// 3. Ajouter une cible de langue espagnole
let language = await elevenlabs.dubbing.project.language.create(project.projectId, {
  targetLanguage: "es",
});

// 4. Attendre que le doublage finisse de se générer
while (true) {
  language = await elevenlabs.dubbing.project.language.get(project.projectId, language.languageId);
  if (language.status === "completed") break;
  if (language.status === "failed") throw new Error("Dub generation failed");
  await new Promise((resolve) => setTimeout(resolve, 5000));
}

// 5. Télécharger l'audio doublé depuis l'URL signée
const response = await fetch(language.outputs!.losslessAudio!);
await writeFile("promo_es.wav", Buffer.from(await response.arrayBuffer()));

Démarrage rapide (cURL)

# 1. Créer un projet (utiliser -F "source_url=https://..." au lieu de file pour doubler depuis une URL)
curl -X POST "https://api.elevenlabs.io/v1/dubbing/project" \
  -H "xi-api-key: $ELEVENLABS_API_KEY" \
  -F "file=@promo.mp4" \
  -F "source_language=en"
# → {"project_id": "proj_...", "status": "queued", ...}

# 2. Interroger jusqu'à ce que le statut soit "ready"
curl "https://api.elevenlabs.io/v1/dubbing/project/proj_..." \
  -H "xi-api-key: $ELEVENLABS_API_KEY"

# 3. Ajouter une langue cible
curl -X POST "https://api.elevenlabs.io/v1/dubbing/project/proj_.../language" \
  -H "xi-api-key: $ELEVENLABS_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"target_language": "es"}'

# 4. Interroger la langue jusqu'à "completed", puis télécharger outputs.lossless_audio
curl "https://api.elevenlabs.io/v1/dubbing/project/proj_.../language/lang_..." \
  -H "xi-api-key: $ELEVENLABS_API_KEY"

Options de création

POST /v1/dubbing/project prend multipart/form-data avec soit file soit source_url (pas les deux) :

Modification de la transcription source

Une fois le projet ready, lisez la transcription, puis corrigez-la avant d'ajouter des langues. Chaque modification augmente la revision du projet. Chaque segment a un id stable utilisé pour le modifier ou le supprimer. (Espaces de travail enterprise uniquement.)

# Lire la transcription source
transcript = elevenlabs.dubbing.project.transcript.get(project_id)

# Corriger le texte d'un segment — envoyer seulement les champs à changer (text, speaker_id, start_s, end_s)
elevenlabs.dubbing.project.transcript.update_segment(
    project_id,
    segment_id=transcript.segments[0].id,
    text="Welcome to our latest product demo.",
)

# Ajouter un segment (réutiliser un speaker_id existant pour qu'il soit doublé avec la voix de ce locuteur)
added = elevenlabs.dubbing.project.transcript.create_segment(
    project_id,
    text="Thanks for watching.",
    speaker_id=transcript.segments[0].speaker_id,
    start_s=40.0,
    end_s=42.0,
)

# Supprimer un segment
elevenlabs.dubbing.project.transcript.delete_segment(project_id, segment_id=added.segment.id)

Via REST : GET /v1/dubbing/project/{project_id}/transcript, puis PATCH .../transcript/segment/{segment_id} avec seulement les champs modifiés :

curl -X PATCH "https://api.elevenlabs.io/v1/dubbing/project/{project_id}/transcript/segment/{segment_id}" \
  -H "xi-api-key: $ELEVENLABS_API_KEY" -H "Content-Type: application/json" \
  -d '{"text": "Welcome to our latest product demo."}'

Affinage des traductions et régénération

La transcription d'une langue associe chaque segment source à sa translation (null = pas encore traduit ; les ids de segment correspondent à la source). Modifier une seule traduction, puis régénérer. (Espaces de travail enterprise uniquement.)

# Lire les traductions de la langue
target = elevenlabs.dubbing.project.language.transcript.get(project_id, language_id)

# Affiner une seule traduction (passer translation=None pour l'effacer et le marquer pour re-traduction)
elevenlabs.dubbing.project.language.transcript.update_segment(
    project_id,
    language_id,
    segment_id=target.segments[0].id,
    translation="Bienvenido a nuestra última demostración de producto.",
)

# Régénérer le doublage à partir de la transcription actuelle (facturé comme une génération)
elevenlabs.dubbing.project.language.transcript.regenerate(project_id, language_id)

Via REST : PATCH /v1/dubbing/project/{project_id}/language/{language_id}/transcript/segment/{segment_id} avec {"translation": "..."}, puis POST .../language/{language_id}/transcript/regenerate (retourne 202 Accepted).

Une modification de traduction affecte seulement cette langue. Après la modification, une langue completed devient stale — elle continue de servir sa sortie précédente jusqu'à ce que vous la régénériez. Interroger jusqu'à completed ; output_revision égale alors revision et outputs.lossless_audio reflète la transcription actuelle.

Doublage en plusieurs langues

Ajouter une cible de langue par langue — chacune se génère indépendamment. Les suivre toutes avec language.list au lieu d'interroger une par une :

for lang in ["es", "fr", "de", "ja"]:
    elevenlabs.dubbing.project.language.create(project_id, target_language=lang)

while True:
    result = elevenlabs.dubbing.project.language.list(project_id)
    if not any(l.status in ("queued", "processing") for l in result.languages):
        break
    time.sleep(5)

États

Project :

Language :

Vous pouvez ajouter une langue avant que le projet soit ready — elle reste queued et démarre automatiquement une fois le projet ready. L'ajout d'une langue accepte optionnel model_id (par défaut celui du projet) et voice_settings (ex. {"cloning_strength": 7}, plage 0–10, défaut 7 — contrôle la force de clonage des voix source des locuteurs doublés).

Gestion des erreurs

• 401 : Clé API invalide
• 409 Conflict sur régénération : Le projet n'est pas ready ou la langue n'est pas stabilisée (ex. génération en cours) — attendre et réessayer
• URL de téléchargement expirée : outputs.lossless_audio est signée et valide ~1 heure ; réinterroger la langue pour une URL fraîche
• Modification de transcription / régénération indisponible : Ces endpoints sont réservés aux enterprise — sur d'autres plans, créez le projet avec une source finalisée et ajoutez les langues directement

Références

• Guide d'installation
• Référence API — chaque endpoint avec les schémas complets de requête/réponse et les noms de méthode SDK