ElevenLabs Synthèse vocale-à-texte

Transcrivez l'audio en texte avec Scribe v2 - supporte 90+ langues, diarisation des locuteurs et timestamps au niveau des mots.

Installation : Voir Guide d'installation. Pour JavaScript, utilisez uniquement les packages @elevenlabs/*.

Démarrage rapide

Python

from elevenlabs import ElevenLabs

client = ElevenLabs()

with open("audio.mp3", "rb") as audio_file:
    result = client.speech_to_text.convert(file=audio_file, model_id="scribe_v2")

print(result.text)

JavaScript

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

const client = new ElevenLabsClient();
const result = await client.speechToText.convert({
  file: createReadStream("audio.mp3"),
  modelId: "scribe_v2",
});
console.log(result.text);

cURL

curl -X POST "https://api.elevenlabs.io/v1/speech-to-text" \
  -H "xi-api-key: $ELEVENLABS_API_KEY" -F "file=@audio.mp3" -F "model_id=scribe_v2"

Modèles

Transcription avec timestamps

Les timestamps au niveau des mots incluent la classification de type et l'identification du locuteur :

result = client.speech_to_text.convert(
    file=audio_file, model_id="scribe_v2", timestamps_granularity="word"
)

for word in result.words:
    print(f"{word.text}: {word.start}s - {word.end}s (type: {word.type})")

Diarisation des locuteurs

Identifiez QUI a dit QUOI - le modèle étiquette chaque mot avec un ID de locuteur, utile pour les réunions, interviews ou tout audio multi-locuteur :

result = client.speech_to_text.convert(
    file=audio_file,
    model_id="scribe_v2",
    diarize=True
)

for word in result.words:
    print(f"[{word.speaker_id}] {word.text}")

Pour les enregistrements d'appels, l'API batch peut étiqueter les locuteurs diarisés comme agent et customer en définissant detect_speaker_roles=true aux côtés de diarize=true. Cette option n'est pas compatible avec use_multi_channel=true.

curl -X POST "https://api.elevenlabs.io/v1/speech-to-text" \
  -H "xi-api-key: $ELEVENLABS_API_KEY" \
  -F "file=@call.mp3" \
  -F "model_id=scribe_v2" \
  -F "diarize=true" \
  -F "detect_speaker_roles=true"

Keyterm Prompting

Aidez le modèle à reconnaître des mots spécifiques qu'il pourrait mal entendre - noms de produits, jargon technique ou orthographes inhabituelles (jusqu'à 100 termes) :

result = client.speech_to_text.convert(
    file=audio_file,
    model_id="scribe_v2",
    keyterms=["ElevenLabs", "Scribe", "API"]
)

Détection de langue

Détection automatique avec indice de langue optionnel :

result = client.speech_to_text.convert(
    file=audio_file,
    model_id="scribe_v2",
    language_code="eng"  # Code ISO 639-1 ou ISO 639-3
)

print(f"Détecté : {result.language_code} ({result.language_probability:.0%})")

Formats supportés

Audio : MP3, WAV, M4A, FLAC, OGG, WebM, AAC, AIFF, Opus Vidéo : MP4, AVI, MKV, MOV, WMV, FLV, WebM, MPEG, 3GPP

Limites : Jusqu'à 3 GB, durée maximale 10 heures

Format de réponse

{
  "text": "Le texte de transcription complet",
  "language_code": "eng",
  "language_probability": 0.98,
  "words": [
    {"text": "Le", "start": 0.0, "end": 0.15, "type": "word", "speaker_id": "speaker_0"},
    {"text": " ", "start": 0.15, "end": 0.16, "type": "spacing", "speaker_id": "speaker_0"}
  ]
}

Types de mots :

• word - Un mot réellement parlé
• spacing - Espace blanc entre les mots (utile pour un timing précis)
• audio_event - Sons non-verbaux détectés par le modèle (rire, applaudissements, musique, etc.)

Gestion des erreurs

try:
    result = client.speech_to_text.convert(file=audio_file, model_id="scribe_v2")
except Exception as e:
    print(f"La transcription a échoué : {e}")

Erreurs courantes :

• 401 : Clé API invalide
• 422 : Paramètres invalides
• 429 : Limite de débit dépassée

Suivi des coûts

Surveillez l'utilisation via l'en-tête de réponse request-id :

response = client.speech_to_text.convert.with_raw_response(file=audio_file, model_id="scribe_v2")
result = response.parse()
print(f"Request ID: {response.headers.get('request-id')}")

Streaming en temps réel

Pour la transcription en direct avec une latence ultra-faible (~150 ms), utilisez l'API temps réel. L'API temps réel produit deux types de transcriptions :

• Transcriptions partielles : Résultats intermédiaires qui se mettent à jour fréquemment au fur et à mesure du traitement de l'audio - utilisez-les pour les retours en direct (par exemple, afficher le texte au fur et à mesure que l'utilisateur parle)
• Transcriptions validées : Résultats finaux et stables après « validation » - utilisez-les comme source de vérité pour votre application

Une « validation » indique au modèle de finaliser le segment actuel. Vous pouvez valider manuellement (par exemple, quand l'utilisateur fait une pause) ou utiliser Voice Activity Detection (VAD) pour valider automatiquement en cas de silence.

Python (Côté serveur)

import asyncio
from elevenlabs import ElevenLabs

client = ElevenLabs()

async def transcribe_realtime():
    async with client.speech_to_text.realtime.connect(
        model_id="scribe_v2_realtime",
        include_timestamps=True,
    ) as connection:
        await connection.stream_url("https://example.com/audio.mp3")

        async for event in connection:
            if event.type == "partial_transcript":
                print(f"Partielle : {event.text}")
            elif event.type == "committed_transcript":
                print(f"Finale : {event.text}")

asyncio.run(transcribe_realtime())

JavaScript (Côté client avec React)

import { useScribe, CommitStrategy } from "@elevenlabs/react";

function TranscriptionComponent() {
  const [transcript, setTranscript] = useState("");

  const scribe = useScribe({
    modelId: "scribe_v2_realtime",
    commitStrategy: CommitStrategy.VAD, // Validation auto en cas de silence pour l'entrée mic
    onPartialTranscript: (data) => console.log("Partielle :", data.text),
    onCommittedTranscript: (data) => setTranscript((prev) => prev + data.text),
  });

  const start = async () => {
    // Récupérez le token depuis votre backend (n'exposez jamais la clé API au client)
    const { token } = await fetch("/scribe-token").then((r) => r.json());

    await scribe.connect({
      token,
      microphone: { echoCancellation: true, noiseSuppression: true },
    });
  };

  return <button onClick={start}>Commencer l'enregistrement</button>;
}

Stratégies de validation

// React : définissez commitStrategy sur le hook (recommandé pour l'entrée mic)
import { useScribe, CommitStrategy } from "@elevenlabs/react";

const scribe = useScribe({
  modelId: "scribe_v2_realtime",
  commitStrategy: CommitStrategy.VAD,
  // Ajustement VAD optionnel :
  vadSilenceThresholdSecs: 1.5,
  vadThreshold: 0.4,
});

// Client JavaScript : passez la config vad à la connexion
const connection = await client.speechToText.realtime.connect({
  modelId: "scribe_v2_realtime",
  vad: {
    silenceThresholdSecs: 1.5,
    threshold: 0.4,
  },
});

Types d'événements

Consultez les références temps réel pour la documentation complète.

Références

• Guide d'installation
• Options de transcription
• Streaming temps réel côté client
• Streaming temps réel côté serveur
• Stratégies de validation
• Référence des événements temps réel