rodrvc/personal-brand

Doublage ElevenLabs

Doublez de l'audio ou de la vidéo dans d'autres langues tout en conservant les voix des intervenants originaux. Créez un projet à partir d'un fichier ou d'une URL, révisez et éditez la transcription source, ajoutez une ou plusieurs langues cibles, affinez les traductions par segment et régénérez les sorties.

Important : Utilisez l'API Dubbing Projects — elevenlabs.dubbing.project.* dans les SDK, ou les endpoints REST /v1/dubbing/project. N'utilisez pas l'ancienne surface de doublage v1 (client.dubbing.create(), client.dubbing.get(), client.dubbing.audio.get(), ou les routes /v1/dubbing nues) — il s'agit de l'API de doublage plus ancienne, désormais sous Legacy dans la référence de l'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 SDK lisent ELEVENLABS_API_KEY automatiquement.

Concepts

Concept	Signification
Projet	Un média source (fichier ou URL) plus sa transcription source. Préparé (transcrit) une fois, puis reste ready pendant que vous ajoutez des langues.
Transcription source	Segments éditables (texte, intervenant, timing) transcrits à partir de la source. La source unique de vérité à partir de laquelle chaque langue est traduite.
Langue (cible)	Une langue de sortie doublée. Chacune a sa propre transcription (segments source + une traduction par segment) et son propre audio doublé.
Révisions	Compteurs monotones indépendants. La revision du projet est incrémentée lors des modifications de la transcription source ; la revision d'une langue est incrémentée lors des modifications de traduction ou des modifications source qui l'affectent. La output_revision d'une langue est la révision à partir de laquelle son audio actuel a été généré — lorsqu'elle est en retard sur revision, la sortie est obsolète.

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 fait que chaque langue part du texte correct — modifier la source après qu'une langue soit terminée la marque stale et nécessite une régénération (facturée).

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

Workflow

1. Créez le projet à partir d'un fichier ou d'une URL → queued
2. Interrogez le projet jusqu'à ready
3. Révisez et finalisez la transcription source (éditez/ajoutez/supprimez des segments)
4. Ajoutez une langue par cible → queued → processing → completed
5. Téléchargez chaque outputs.lossless_audio de la langue lorsque completed
6. Affinez les traductions par segment si nécessaire → la langue devient stale
7. Régénérez 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éez un projet à partir d'un fichier local (ou passez source_url=... à la place de file)
with open("promo.mp4", "rb") as f:
    project = elevenlabs.dubbing.project.create(
        file=f,
        source_language="en",
        reference="Vidéo marketing Q3",
    )

# 2. Attendez 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("La préparation du projet a échoué")
    time.sleep(5)

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

# 4. Attendez que le doublage soit généré
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("La génération du doublage a échoué")
    time.sleep(5)

# 5. Téléchargez l'audio doublé (URL signée, valide ~1 heure — récupérez la langue pour une nouvelle URL)
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éez un projet (sourceUrl illustré ; le téléchargement de fichier est également pris en charge)
let project = await elevenlabs.dubbing.project.create({
  sourceUrl: "https://example.com/promo.mp4",
  sourceLanguage: "en",
  reference: "Vidéo marketing Q3",
});

// 2. Attendez 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("La préparation du projet a échoué");
  await new Promise((resolve) => setTimeout(resolve, 5000));
}

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

// 4. Attendez que le doublage soit généré
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("La génération du doublage a échoué");
  await new Promise((resolve) => setTimeout(resolve, 5000));
}

// 5. Téléchargez 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éez un projet (utilisez -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 "[email protected]" \
  -F "source_language=en"
# → {"project_id": "proj_...", "status": "queued", ...}

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

# 3. Ajoutez 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. Interrogez la langue jusqu'à "completed", puis téléchargez 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) :

Champ	Requis	Remarques
file	l'un de file/source_url	Média source à doubler (audio ou vidéo), jusqu'à 3 Gio
source_url	l'un de file/source_url	URL publique pour récupérer le média source
source_language	non	Code ISO 639 (ex. en). Omettez pour détection automatique — la langue détectée est signalée dans le champ language de la transcription source
reference	non	Étiquette libre pour identifier le projet de votre côté (max 500 caractères)
model_id	non	dubbing_v2 (par défaut)
target_language	non	Optionnellement, mettez en file d'attente la première langue cible lors de la création ; ajoutez-en d'autres avec language.create
keyterms	non	Termes pour orienter la transcription/traduction (noms de produits/marques). Jusqu'à 100 termes de 200 caractères chacun ; répétez le champ une fois par terme en multipart

Édition de la transcription source

Une fois le projet ready, lisez la transcription, puis corrigez-la avant d'ajouter des langues. Chaque édition incrémente la revision du projet. Chaque segment a un id stable utilisé pour l'éditer 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 — envoyez uniquement les champs à modifier (text, speaker_id, start_s, end_s)
elevenlabs.dubbing.project.transcript.update_segment(
    project_id,
    segment_id=transcript.segments[0].id,
    text="Bienvenue dans notre dernière démo produit.",
)

# Ajouter un segment (réutilisez un speaker_id existant pour qu'il soit doublé avec la voix de cet intervenant)
added = elevenlabs.dubbing.project.transcript.create_segment(
    project_id,
    text="Merci d'avoir regardé.",
    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 uniquement 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": "Bienvenue dans notre dernière démo produit."}'

Affinage des traductions et régénération

La transcription d'une langue associe chaque segment source à sa translation (null = pas encore traduit ; les identifiants de segment correspondent à ceux de la source). Modifiez une seule traduction, puis régénérez. (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 (passez translation=None pour l'effacer et la marquer pour retraduction)
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 n'affecte que cette langue. Après la modification, une langue completed devient stale — elle continue de servir sa sortie précédente jusqu'à ce que vous régénériez. Interrogez jusqu'à completed ; output_revision est alors égal à revision et outputs.lossless_audio reflète la transcription actuelle.

Doublage en plusieurs langues

Ajoutez une langue cible par langue — chacune génère indépendamment. Suivez-les 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

Projet :

Statut	Signification
queued	Créé ; la récupération et la préparation de la source sont en file d'attente
preparing	La préparation (transcription) est en cours
ready	Transcription source disponible ; ajoutez/générez des langues. Les projets restent ready — la progression par langue vit sur les langues
failed	La préparation a échoué (ex. la source n'a pas pu être récupérée ou décodée)

Langue :

Statut	Signification
queued	En attente que le projet devienne ready, ou d'un worker de génération
processing	Le doublage est en cours de génération
completed	Terminé ; outputs rempli avec une URL de téléchargement signée (valide ~1 heure — récupérez à nouveau pour une URL fraîche)
stale	Précédemment terminé, mais la transcription a changé ; conserve la dernière sortie jusqu'à régénération
failed	La génération a échoué

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 un model_id optionnel (par défaut celui du projet) et des voice_settings (ex. {"cloning_strength": 7}, plage 0–10, défaut 7 — contrôle la force avec laquelle les intervenants doublés clonent les voix sources).

Gestion des erreurs

• 401 : Clé API invalide
• 409 Conflict lors de la régénération : Le projet n'est pas ready ou la langue n'est pas stabilisée (ex. déjà en cours de génération) — attendez et réessayez
• URL de téléchargement expirée : outputs.lossless_audio est signée et valide ~1 heure ; récupérez la langue pour une nouvelle URL
• Édition de transcription / régénération indisponible : Ces endpoints sont réservés aux entreprises — sur d'autres plans, créez le projet avec une source finalisée et ajoutez directement les langues

Références

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