ElevenLabs ist jetzt auf OpenRouter

ElevenLabs ist jetzt auf OpenRouter mit neun Text to Speech-Modellen und zwei Speech to Text-Modellen.

Wenn deine App bereits über OpenRouter mit einem Sprachmodell kommuniziert, kann sie jetzt auch sprechen und zuhören. Erzähle lange Inhalte mit Vorgaben zu Ton und Darbietung mit Eleven v4, gib deinem Agenten schnellere gesprochene Antworten mit v4 Turbo oder transkribiere Gespräche mit Sprecherkennzeichnung mit Scribe v2. Du brauchst keinen separaten ElevenLabs-Plan. Rufe einfach POST /api/v1/audio/speech und POST /api/v1/audio/transcriptions mit deinem OpenRouter API-Key auf.

Jedes ElevenLabs-Modell ist 50% unter dem Listenpreis von OpenRouter für alle OpenRouter-Kunden bis zum 19. Oktober, 8 Uhr PT

Welches Modell du verwenden solltest

Beginne mit drei Modellen und greife auf die übrigen zurück, wenn eine Aufgabe sie erfordert:

• Erzählungen, Charaktere, Produktvideos: Eleven v4. Audio-Tags lassen das Skript die Darbietung steuern.
• Sprachagenten und Live-Antworten: Eleven v4 Turbo, ElevenLabs hat es für den Echtzeiteinsatz gebaut, zum halben v4-Preis.
• Transkripte, Meeting-Notizen, Untertitel: Scribe v2, mit Sprecherkennzeichnung und Wort-Zeitstempeln.

Verwende Multilingual v2, wenn langes Audio Geschwindigkeitskontrolle benötigt, und Flash v2.5 für Sprachausgabe in großem Volumen mit bis zu 40,000 Zeichen pro Anfrage. Scribe v2 Medical ist auf medizinische Begriffe feinabgestimmt.

Text to Speech

ElevenLabs berechnet seine Modelle in zwei Stufen. Eleven v4, v3 und Multilingual v2 werden zum vollen Preis pro Zeichen abgerechnet, während v4 Turbo, v3 Conversational, Flash und Turbo die Hälfte davon berechnen. Die aktuellen Preise pro Zeichen finden Sie auf der jeweiligen Modellseite in der Text to Speech-Kollektion.

Speech to Text

Beide Scribe-Modelle verwenden dieselbe Anfrageform und denselben Preis pro Sekunde. Realtime Scribe v2 über WebSocket ist nicht Teil dieses Launches.

Walkthrough: von einer ersten MP3 zu einem Voice-Agenten

Wir bauen eine kleine Produkttour in drei Schritten. Zunächst kommentiert Eleven v4 sie. Dann beantwortet ein Voice-Agent Fragen dazu, und schließlich verwandelt Scribe v2 die Besprechung des Teams in Notizen, die zeigen, wer was gesagt hat. Wenn sich eine Anfrage nicht so verhält, wie Sie es erwarten, schauen Sie in die Tipps am Ende.

Legen Sie Ihren Schlüssel einmal fest:

export OPENROUTER_API_KEY="your-api-key"

Schritt 1: Kommentieren Sie eine Produkttour mit Eleven v4

Beginnen Sie mit einer Zeile Kommentar:

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 nimmt jeden der 21 vorgefertigten Voices von ElevenLabs namentlich entgegen (george hier); die Namen unterscheiden nicht zwischen Groß- und Kleinschreibung. Beachten Sie das ausdrückliche response_format — siehe Tipps für Ihre ersten Anfragen für beide.

Die Wörter in eckigen Klammern sind Audio-Tags. Eleven v4 und v3 lesen Tags wie [whispering], [laughing], [sighs]und [curious] als Anweisungen zur Vortragsweise, anstatt sie zu sprechen. Tags zählen zu den abgerechneten Zeichen.

Ein vollständiges Tour-Skript ist länger, als eine Anfrage erlaubt (10,000 Zeichen bei v4, 5,000 bei v3), also teile es an Absatzgrenzen. Nur-ElevenLabs-Einstellungen werden unter provider.options.elevenlabsabgelegt. Übergib den benachbarten Text als previous_text und next_text damit die Intonation über die Übergänge hinweg konsistent bleibt, und lege einen seed fest, damit Wiederholungen besser reproduzierbar sind:

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)

Schritt 2: Fragen mit einem Voice-Agent beantworten

Jetzt können Nutzer die Tour-Fragen laut stellen. Ein Voice-Agent verkettet drei Modelle: Scribe v2 für die Frage, ein Chat-Modell für die Antwort und Eleven v4 Turbo für die Antwortwiedergabe. ElevenLabs baut v4 Turbo für die Echtzeitnutzung und rechnet es mit der Hälfte des v4-Preises ab.

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")

Die Transkriptionsantwort ist JSON mit dem Transkript in text und einem usage Objekt, das die Audiosekunden und den Dollar cost der Anfrage meldet. Tauschen Sie openai/gpt-5-mini gegen ein beliebiges Chat-Modell aus dem Katalog aus, ohne die Audio-Aufrufe anzufassen, und behalten Sie dasselbe voice bei, damit der Agent wie der Erzähler aus Schritt 1 klingt.

Schritt 3: Die Besprechung in sprechermarkierte Notizen verwandeln

Wenn Ihr Team sich trifft, um die Tour zu überprüfen, kann Scribe v2 Ihnen sagen, wer was gesagt hat. Laden Sie die Aufnahme als multipart hoch, fordern Sie verbose_json mit Wort-Zeitstempeln an und setzen Sie diarize unter provider.options.elevenlabs. Jedes Wort in der Antwort trägt dann einen Sprecher. Wenn Sie wissen, wie viele Personen an der Besprechung teilgenommen haben, übergeben Sie num_speakers , um die Aufteilung zu verbessern.

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}}}'

Jeder Eintrag in words hat word, start, end, confidence, speaker (eine ganze Zahl), und speaker_label (speaker_0, speaker_1usw.). tag_audio_events fügt Einträge wie (laughter) neben den Wörtern hinzu. Gruppieren Sie aufeinanderfolgende Wörter nach speaker zu Sprechanteilen und senden Sie diese dann zur Zusammenfassung und Aufgabenliste an ein Chat-Modell:

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]

Uploads sind auf 25 MB begrenzt, was etwa 27 Minuten 128 kbps MP3 entspricht.

Für längere Aufnahmen übergeben Sie eine öffentliche URL, und ElevenLabs lädt die Datei direkt herunter, sodass die 25-MB-Grenze nicht gilt:

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

Sehr lange Dateien können trotzdem den 180-Sekunden-Timeout der Upstream-Anfrage erreichen, teilen Sie also Aufnahmen, die lang sind.

Tipps für Ihre ersten Anfragen

1. Wählen Sie eine Stimme nach Name oder ID. Für voiceübergeben Sie einen der 21 vorgefertigten Stimmen von ElevenLabs nach Name: george, sarah, adam, alice, bella, brian, charlie, daniel, jessica, roger, will und mehr (vollständige Liste auf jeder Modellseite). Namen unterscheiden nicht zwischen Groß- und Kleinschreibung. Um eine andere Stimme zu verwenden, übergeben Sie deren ElevenLabs-Voice-ID als voice — kopieren Sie sie aus dem ElevenLabs-Sprachbibliothek. Stimmen, die Sie klonen oder entwerfen, befinden sich in Ihrem eigenen ElevenLabs-Konto, verwenden Sie diese also mit BYOK.
2. Fragen Sie nach mp3 wenn Sie eine Datei möchten, die Sie abspielen können Wenn Sie response_formatweglassen, gibt unser Speech-Endpunkt rohes PCM zurück (16-Bit Little-Endian Mono mit 24 kHz). Das passt zu einer Audio-Pipeline, aber die meisten Player können es nicht öffnen. Setzen Sie "response_format": "mp3" um eine abspielbare Datei mit 44.1 kHz und 128 kbps zu erhalten.
3. Verwenden Sie Multilingual v2 oder Flash für Geschwindigkeitssteuerung Multilingual v2 und Flash akzeptieren speed von 0.7 bis 1.2. Eleven v4 und v4 Turbo haben keine Geschwindigkeitssteuerung und weisen einen nicht standardmäßigen Wert für speedzurück, lassen Sie ihn also bei diesen Modellen weg und ändern Sie das Tempo stattdessen mit Audio-Tags.
4. Teilen Sie lange Skripte auf Jedes Modell hat ein Zeichenlimit pro Anfrage (siehe Modelltabelle). Audio-Tags zählen zum Limit und zu Ihren abgerechneten Zeichen. Teilen Sie an Absatzgrenzen wie in Schritt 1 und übergeben Sie previous_text und next_text damit die Übergänge natürlich klingen.
5. ElevenLabs-spezifische Einstellungen stehen unter provider.options.elevenlabs Text to Speech akzeptiert 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) und output_format (einen ElevenLabs-Formatnamen wie mp3_22050_32 oder pcm_16000; er muss zu Ihrem response_format Codec passen). Speech to Text akzeptiert diarize, num_speakers, diarization_threshold, tag_audio_events, no_verbatim, und seed. num_speakers und diarization_threshold benötigen diarize: true, und Sie können entweder das eine oder das andere setzen, nicht beides. Verwenden Sie die Feldnamen genau wie aufgeführt. Schlüssel, die nicht auf diesen Listen stehen, werden ignoriert; ein aufgelisteter Schlüssel mit einem ungültigen Wert gibt einen 400 zurück.
6. Scribe gibt dreibuchstabige Sprachcodes zurück Sie können einen zweibuchstabigen language Hinweis senden (en). Die erkannte Sprache kommt als ISO 639-3-Code zurück (eng).

Erste Schritte

1. Erstellen Sie einen OpenRouter API-Schlüssel.
2. Machen Sie Ihre erste Anfrage mit dem curl-Beispiel in Schritt 1 oben.
3. Für jeden Parameter siehe die Text to Speech und Speech to Text Anleitungen.

Text to Speech wird pro Eingabezeichen abgerechnet, gezählt als Unicode-Codepunkte, sodass ein Emoji oder ein CJK-Zeichen einfach einmal zählt. Audio-Tags zählen als Zeichen. Scribe wird pro Sekunde Audio abgerechnet, und das Feld usage.cost in jeder Transkriptionsantwort zeigt dir, was diese Anfrage gekostet hat. Wir geben die Preise von ElevenLabs ohne Aufschlag weiter; die aktuellen Tarife findest du auf den jeweiligen Modellseiten.

Du hast bereits ein ElevenLabs-Konto?

Füge deinen Schlüssel mit BYOK hinzu, um deine eigenen geklonten Stimmen, Aussprachewörterbücher und hochwertigere Formate wie mp3_44100_192 zu verwenden.

Erstelle einen OpenRouter API keyoder probiere zuerst ein Modell im Playgroundaus. Die Anleitungen zu Text to Speech und Speech to Text enthalten die vollständige Anfrage-Referenz.