ElevenLabs est désormais sur OpenRouter

ElevenLabs est désormais sur OpenRouter avec neuf modèles de Text to Speech et deux modèles de Speech to Text.

Si votre application dialogue déjà avec un modèle de langage via OpenRouter, elle peut maintenant aussi parler et écouter. Narrez du contenu long avec un contrôle du ton et du débit grâce à Eleven v4, offrez à votre agent des réponses vocales plus rapides avec v4 Turbo, ou transcrivez des conversations avec des étiquettes de locuteur grâce à Scribe v2. Vous n'avez pas besoin d'un plan ElevenLabs séparé. Appelez simplement POST /api/v1/audio/speech et POST /api/v1/audio/transcriptions avec votre clé API OpenRouter.

Chaque modèle ElevenLabs bénéficie de 50% de réduction sur le prix catalogue d'OpenRouter pour tous les clients OpenRouter jusqu'au 19 octobre, 8h PT

Quel modèle utiliser

Commencez avec trois modèles et recourez aux autres quand une tâche les exige :

• Narration, personnages, vidéos produits : Eleven v4. Les balises audio permettent au script de porter l'interprétation.
• Agents vocaux et réponses en direct : Eleven v4 Turbo, qu'ElevenLabs a conçu pour une utilisation en temps réel, à la moitié du tarif de v4.
• Transcriptions, comptes rendus de réunion, sous-titres : Scribe v2, avec étiquettes de locuteur et horodatages par mot.

Utilisez Multilingual v2 quand l'audio long nécessite un contrôle de la vitesse, et Flash v2.5 pour des volumes élevés de voix allant jusqu'à 40,000 caractères par requête. Scribe v2 Medical est spécialement ajusté pour les termes médicaux.

Text to Speech

ElevenLabs facture ses modèles selon deux niveaux. Eleven v4, v3 et Multilingual v2 facturent le tarif complet par caractère, tandis que v4 Turbo, v3 Conversational, Flash et Turbo facturent la moitié. Les prix actuels par caractère figurent sur la page de chaque modèle dans la collection Text to Speech.

Speech to Text

Les deux modèles Scribe utilisent la même forme de requête et le même prix par seconde. Scribe v2 en temps réel via WebSocket ne fait pas partie de ce lancement.

Procédure pas à pas : d'un premier MP3 à un agent vocal

Nous allons construire une petite visite produit en trois étapes. D'abord, Eleven v4 la narre. Ensuite, un agent vocal répond aux questions à son sujet, et enfin Scribe v2 transforme la réunion d'évaluation de l'équipe en notes indiquant qui a dit quoi. Si une requête ne se comporte pas comme vous l'attendez, consultez les conseils à la fin.

Définissez votre clé une fois :

export OPENROUTER_API_KEY="your-api-key"

Étape 1 : Narrer une visite produit avec Eleven v4

Commencez par une ligne de narration :

curl https://openrouter.ai/api/v1/audio/speech \
  --fail-with-body \
  -H "Authorization: Bearer $OPENROUTER_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "elevenlabs/eleven-v4",
    "input": "[cheerfully] Welcome to the tour. [whispering] Let me show you the shortcut first.",
    "voice": "george",
    "response_format": "mp3"
  }' \
  --output intro.mp3

voice prend n'importe laquelle des 21 voix prédéfinies d'ElevenLabs par nom (george ici) ; les noms ne sont pas sensibles à la casse. Notez le response_format explicite — voir Conseils pour vos premières requêtes pour les deux.

Les mots entre crochets sont des balises audio. Eleven v4 et v3 lisent les balises telles que [whispering], [laughing], [sighs], et [curious] comme des indications de jeu vocal au lieu de les prononcer. Les balises comptent dans vos caractères facturés.

Un script de visite complet dépasse ce qu'une seule requête permet (10,000 caractères sur v4, 5,000 sur v3), divisez-le donc aux limites de paragraphes. Les paramètres réservés à ElevenLabs vont sous provider.options.elevenlabs. Passez le texte voisin comme previous_text et next_text pour que l'intonation reste cohérente aux jonctions, et fixez un seed pour que les réexécutions soient plus reproductibles :

import os

import requests

API = "https://openrouter.ai/api/v1"
HEADERS = {"Authorization": f"Bearer {os.environ['OPENROUTER_API_KEY']}"}
NARRATOR = "george"


def split_paragraphs(text: str, limit: int = 9000) -> list[str]:
    chunks, current = [], ""
    for para in text.split("\n\n"):
        if current and len(current) + len(para) + 2 > limit:
            chunks.append(current)
            current = para
        else:
            current = f"{current}\n\n{para}" if current else para
    return chunks + [current] if current else chunks


chunks = split_paragraphs(open("tour-script.txt").read())

with open("tour.mp3", "wb") as out:
    for i, chunk in enumerate(chunks):
        options = {"seed": 7}
        if i > 0:
            options["previous_text"] = chunks[i - 1][-500:]
        if i + 1 < len(chunks):
            options["next_text"] = chunks[i + 1][:500]
        r = requests.post(
            f"{API}/audio/speech",
            headers=HEADERS,
            json={
                "model": "elevenlabs/eleven-v4",
                "input": chunk,
                "voice": NARRATOR,
                "response_format": "mp3",
                "provider": {"options": {"elevenlabs": options}},
            },
        )
        r.raise_for_status()
        out.write(r.content)

Étape 2 : Répondre aux questions avec un agent vocal

Permettez maintenant aux utilisateurs de poser les questions de la visite à voix haute. Un agent vocal enchaîne trois modèles : Scribe v2 pour la question, un modèle de chat pour la réponse, et Eleven v4 Turbo pour la réplique. ElevenLabs construit v4 Turbo pour une utilisation en temps réel, et il est facturé à la moitié du tarif de v4.

import base64


def transcribe(path: str) -> str:
    with open(path, "rb") as f:
        audio_b64 = base64.b64encode(f.read()).decode()
    r = requests.post(
        f"{API}/audio/transcriptions",
        headers=HEADERS,
        json={
            "model": "elevenlabs/scribe-v2",
            "input_audio": {"data": audio_b64, "format": "wav"},
        },
    )
    r.raise_for_status()
    return r.json()["text"]


def answer(question: str) -> str:
    r = requests.post(
        f"{API}/chat/completions",
        headers=HEADERS,
        json={
            "model": "openai/gpt-5-mini",
            "messages": [
                {"role": "system", "content": "You are the product tour guide. Answer in one or two sentences."},
                {"role": "user", "content": question},
            ],
        },
    )
    r.raise_for_status()
    return r.json()["choices"][0]["message"]["content"]


def speak(text: str, out_path: str) -> None:
    r = requests.post(
        f"{API}/audio/speech",
        headers=HEADERS,
        json={
            "model": "elevenlabs/eleven-v4-turbo",
            "input": text,
            "voice": NARRATOR,
            "response_format": "mp3",
        },
    )
    r.raise_for_status()
    with open(out_path, "wb") as f:
        f.write(r.content)


speak(answer(transcribe("question.wav")), "reply.mp3")

La réponse de transcription est un JSON avec la transcription dans text et un objet usage qui indique les secondes audio et le cost en dollars de la requête. Remplacez openai/gpt-5-mini par n'importe quel modèle de chat du catalogue sans toucher aux appels audio, et gardez le même voice pour que l'agent sonne comme le narrateur de l'étape 1.

Étape 3 : Transformer la réunion de review en notes étiquetées par locuteur

Lorsque votre équipe se réunit pour passer la visite en revue, Scribe v2 peut vous dire qui a dit quoi. Téléversez l'enregistrement en multipart, demandez verbose_json avec les horodatages par mot, et définissez diarize sous provider.options.elevenlabs. Chaque mot de la réponse comporte alors un locuteur. Si vous savez combien de personnes étaient présentes à la réunion, transmettez num_speakers pour améliorer la segmentation.

curl https://openrouter.ai/api/v1/audio/transcriptions \
  --fail-with-body \
  -H "Authorization: Bearer $OPENROUTER_API_KEY" \
  -F file="@tour-review.mp3" \
  -F model="elevenlabs/scribe-v2" \
  -F response_format="verbose_json" \
  -F "timestamp_granularities[]=word" \
  -F provider='{"options": {"elevenlabs": {"diarize": true, "num_speakers": 3, "tag_audio_events": true}}}'

Chaque entrée de words possède word, start, end, confidence, speaker (un entier), et speaker_label (speaker_0, speaker_1, et ainsi de suite). tag_audio_events ajoute des entrées telles que (laughter) aux côtés des mots. Regroupez les mots consécutifs par speaker pour obtenir des tours de parole, puis envoyez les tours à un modèle de chat pour un résumé et des actions à mener :

def to_turns(words: list[dict]) -> list[str]:
    turns: list[tuple[int, list[str]]] = []
    for w in words:
        if turns and turns[-1][0] == w.get("speaker"):
            turns[-1][1].append(w["word"])
        else:
            turns.append((w.get("speaker"), [w["word"]]))
    return [f"Speaker {s}: {' '.join(ws)}" for s, ws in turns]

Les téléversements sont limités à 25 MB, ce qui couvre environ 27 minutes de MP3 à 128 kbps.

Pour des enregistrements plus longs, transmettez une URL publique et ElevenLabs télécharge directement le fichier, si bien que la limite de 25 MB ne s'applique pas :

"input_audio":{ "url": "https://example.com/tour-review.mp3" }

Les fichiers très longs peuvent toujours atteindre le délai d'expiration de requête en amont de 180 secondes, donc découpez les enregistrements qui durent longtemps.

Conseils pour vos premières requêtes

1. Choisissez une voix par nom ou par ID. Pour voice, transmettez n'importe laquelle des 21 voix prédéfinies d'ElevenLabs par nom : george, sarah, adam, alice, bella, brian, charlie, daniel, jessica, roger, will et plus encore (liste complète sur chaque page de modèle). Les noms ne sont pas sensibles à la casse. Pour utiliser toute autre voix, transmettez son ID de voix ElevenLabs comme voice — copiez-le depuis la Bibliothèque de voix ElevenLabs. Les voix que vous clonez ou concevez se trouvent dans votre propre compte ElevenLabs, utilisez donc celles-ci avec BYOK.
2. Demandez mp3 lorsque vous voulez un fichier que vous pouvez lire Si vous omettez response_format, notre point de terminaison de synthèse vocale renvoie du PCM brut (16 bits, petit-boutiste, mono à 24 kHz). Cela convient à un pipeline audio, mais la plupart des lecteurs ne peuvent pas l’ouvrir. Définissez "response_format": "mp3" pour obtenir un fichier lisible en 44.1 kHz, 128 kbps.
3. Utilisez Multilingual v2 ou Flash pour contrôler la vitesse Multilingual v2 et Flash acceptent speed de 0.7 à 1.2. Eleven v4 et v4 Turbo n’ont pas de contrôle de la vitesse et rejettent une valeur non par défaut de speed, laissez donc ce paramètre de côté sur ces modèles et modifiez le rythme avec des balises audio à la place.
4. Divisez les longs scripts Chaque modèle a une limite de caractères par requête (voir le tableau des modèles). Les balises audio comptent dans la limite et dans vos caractères facturés. Divisez aux limites de paragraphes comme à l’étape 1, et passez previous_text et next_text pour que les jointures sonnent naturellement.
5. Les paramètres propres à ElevenLabs vont sous provider.options.elevenlabs Text to Speech accepte seed, previous_text, next_text, language_code, apply_text_normalization, apply_language_text_normalization, pronunciation_dictionary_locators, voice_settings (stability, similarity_boost, style, use_speaker_boost, speed), et output_format (un nom de format ElevenLabs tel que mp3_22050_32 ou pcm_16000; il doit correspondre à votre response_format codec). Speech to Text accepte diarize, num_speakers, diarization_threshold, tag_audio_events, no_verbatim, et seed. num_speakers et diarization_threshold nécessitent diarize: true, et vous pouvez définir l’un ou l’autre, mais pas les deux. Utilisez les noms de champs exactement tels qu’ils sont listés. Les clés qui ne figurent pas sur ces listes sont ignorées ; une clé listée avec une valeur incorrecte renvoie une erreur 400.
6. Scribe renvoie des codes de langue à trois lettres Vous pouvez envoyer un indice language à deux lettres (en). La langue détectée est renvoyée sous forme de code ISO 639-3 (eng).

Premiers pas

1. Créez une clé d'API OpenRouter API key.
2. Effectuez votre première requête avec l'exemple curl de l'étape 1 ci-dessus.
3. Pour chaque paramètre, consultez les guides Text to Speech et Speech to Text .

Text to Speech est facturé par caractère d'entrée, compté en points de code Unicode, ainsi un emoji ou un caractère CJK compte pour un. Les balises audio comptent comme des caractères. Scribe est facturé par seconde d'audio, et le champ usage.cost sur chaque réponse de transcription vous indique le coût de cette requête. Nous répercutons les tarifs d'ElevenLabs sans majoration ; consultez la page de chaque modèle pour le tarif actuel.

Vous avez déjà un compte ElevenLabs ?

Ajoutez votre clé avec BYOK pour utiliser vos propres voix clonées, vos dictionnaires de prononciation et des formats de meilleure qualité tels que mp3_44100_192.

Créez une clé API OpenRouter, ou essayez d'abord un modèle dans le Playground. Les guides Text to Speech et Speech to Text contiennent la référence complète des requêtes.