ElevenLabs ya está en OpenRouter

ElevenLabs ya está en OpenRouter con nueve modelos de Texto a Voz y dos modelos de Voz a Texto.

Si tu aplicación ya se comunica con un modelo de lenguaje a través de OpenRouter, ahora también puede hablar y escuchar. Narra contenido de formato largo con dirección sobre el tono y la entrega con Eleven v4, da a tu agente respuestas habladas más rápidas con v4 Turbo, o transcribe conversaciones con etiquetas de hablante con Scribe v2. No necesitas un plan separado de ElevenLabs. Simplemente llama a POST /api/v1/audio/speech y POST /api/v1/audio/transcriptions con tu clave API de OpenRouter.

Cada modelo de ElevenLabs tiene un 50% de descuento sobre el precio de lista de OpenRouter para todos los clientes de OpenRouter hasta el 19 de octubre, 8am PT

Qué modelo usar

Comienza con tres modelos y recurre al resto cuando un trabajo los necesite:

• Narración, personajes, vídeos de producto: Eleven v4. Las etiquetas de audio permiten que el guion lleve la interpretación.
• Agentes de voz y respuestas en vivo: Eleven v4 Turbo, ElevenLabs lo construyó para uso en tiempo real, a la mitad de la tarifa de v4.
• Transcripciones, notas de reuniones, subtítulos: Scribe v2, con etiquetas de hablante y marcas de tiempo por palabra.

Usa Multilingual v2 cuando el audio de formato largo necesite control de velocidad, y Flash v2.5 para voz de alto volumen de hasta 40,000 caracteres por solicitud. Scribe v2 Medical está ajustado para términos médicos.

Texto a Voz

ElevenLabs precia sus modelos en dos niveles. Eleven v4, v3 y Multilingual v2 facturan la tarifa completa por carácter, y v4 Turbo, v3 Conversational, Flash y Turbo facturan la mitad. Los precios actuales por carácter están en la página de cada modelo en la colección Text to Speech.

Speech to Text

Ambos modelos Scribe usan la misma forma de solicitud y el mismo precio por segundo. Scribe v2 en tiempo real por WebSocket no forma parte de este lanzamiento.

Recorrido: desde un primer MP3 hasta un agente de voz

Construiremos un pequeño recorrido de producto en tres pasos. Primero Eleven v4 lo narra. Luego un agente de voz responde preguntas sobre él, y finalmente Scribe v2 convierte la reunión de revisión del equipo en notas que muestran quién dijo qué. Si una solicitud no se comporta como espera, consulte los consejos al final.

Configure su clave una vez:

export OPENROUTER_API_KEY="your-api-key"

Paso 1: Narre un recorrido de producto con Eleven v4

Comience con una línea de narración:

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 toma cualquiera de las 21 voces prediseñadas de ElevenLabs por nombre (george aquí); los nombres no distinguen mayúsculas y minúsculas. Observe el response_format explícito — véase Consejos para sus primeras solicitudes para ambos.

Las palabras entre corchetes son etiquetas de audio. Eleven v4 y v3 leen etiquetas como [whispering], [laughing], [sighs], y [curious] como instrucciones de interpretación en lugar de pronunciarlas. Las etiquetas cuentan para sus caracteres facturados.

Un guion de recorrido completo es más largo de lo que permite una sola solicitud (10,000 caracteres en v4, 5,000 en v3), así que divídelo en límites de párrafo. Las opciones exclusivas de ElevenLabs van bajo provider.options.elevenlabs. Pasa el texto vecino como previous_text y next_text para que la entonación se mantenga consistente en las uniones, y fija una seed para que las repeticiones sean más reproducibles:

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)

Paso 2: Responder preguntas con un agente de voz

Ahora deja que los usuarios hagan las preguntas del recorrido en voz alta. Un agente de voz encadena tres modelos: Scribe v2 para la pregunta, un modelo de chat para la respuesta y Eleven v4 Turbo para la réplica. ElevenLabs construye v4 Turbo para uso en tiempo real, y factura a la mitad de la tarifa 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 respuesta de transcripción es JSON con la transcripción en text y un usage objeto que informa los segundos de audio y el dólar cost de la solicitud. Sustituye openai/gpt-5-mini por cualquier modelo de chat en el catálogo sin tocar las llamadas de audio, y mantén el mismo voice para que el agente suene como el narrador del paso 1.

Paso 3: Convertir la reunión de revisión en notas etiquetadas por hablante

Cuando tu equipo se reúne para revisar el recorrido, Scribe v2 puede decirte quién dijo qué. Sube la grabación como multipart, pide verbose_json con marcas de tiempo por palabra, y establece diarize bajo provider.options.elevenlabs. Cada palabra de la respuesta lleva entonces un hablante. Si sabes cuántas personas había en la reunión, pasa num_speakers para mejorar la división.

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

Cada entrada en words tiene word, start, end, confidence, speaker (un entero), y speaker_label (speaker_0, speaker_1, y así sucesivamente). tag_audio_events añade entradas como (laughter) junto a las palabras. Agrupa las palabras consecutivas por speaker para obtener turnos, y luego envía los turnos a un modelo de chat para un resumen y elementos de acción:

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]

Las subidas están limitadas a 25 MB, lo que cubre unos 27 minutos de MP3 a 128 kbps.

Para grabaciones más largas, pasa una URL pública y ElevenLabs descarga el archivo directamente, de modo que el límite de 25 MB no aplica:

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

Los archivos muy largos aún pueden alcanzar el tiempo de espera de solicitud de 180 segundos del servicio ascendente, así que divide las grabaciones que duren mucho.

Consejos para tus primeras solicitudes

1. Elige una voz por nombre o ID. Para voice, pasa cualquiera de las 21 voces prediseñadas de ElevenLabs por nombre: george, sarah, adam, alice, bella, brian, charlie, daniel, jessica, roger, will y más (lista completa en la página de cada modelo). Los nombres no distinguen mayúsculas. Para usar cualquier otra voz, pasa su ID de voz de ElevenLabs como voice — cópialo de la Biblioteca de voces de ElevenLabs. Las voces que clonas o diseñas viven en tu propia cuenta de ElevenLabs, así que úsalas con BYOK.
2. Pide mp3 cuando quieras un archivo que puedas reproducir Si omites response_format, nuestro endpoint de voz devuelve PCM sin procesar (mono de 16 bits little-endian a 24 kHz). Eso sirve para un pipeline de audio, pero la mayoría de los reproductores no pueden abrirlo. Establece "response_format": "mp3" para obtener un archivo reproducible de 44.1 kHz y 128 kbps.
3. Usa Multilingual v2 o Flash para controlar la velocidad Multilingual v2 y Flash aceptan speed de 0.7 a 1.2. Eleven v4 y v4 Turbo no tienen control de velocidad y rechazan un speedno predeterminado, así que omítelo en esos modelos y cambia el ritmo con etiquetas de audio en su lugar.
4. Divide los guiones largos Cada modelo tiene un límite de caracteres por solicitud (consulta la tabla de modelos). Las etiquetas de audio cuentan para el límite y para tus caracteres facturados. Divide en los límites de párrafo como en el paso 1 y pasa previous_text y next_text para que las uniones suenen naturales.
5. Los ajustes específicos de ElevenLabs van bajo provider.options.elevenlabs Text to Speech acepta 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) y output_format (un nombre de formato de ElevenLabs como mp3_22050_32 o pcm_16000; debe coincidir con tu response_format codec). Speech to Text acepta diarize, num_speakers, diarization_threshold, tag_audio_events, no_verbatim, y seed. num_speakers y diarization_threshold necesitan diarize: true, y puedes establecer uno u otro, no ambos. Usa los nombres de campo exactamente como se enumeran. Las claves que no están en estas listas se ignoran; una clave listada con un valor incorrecto devuelve un 400.
6. Scribe devuelve códigos de idioma de tres letras Puedes enviar una pista language de dos letras (en). El idioma detectado se devuelve como un código ISO 639-3 (eng).

Primeros pasos

1. Cree una clave de API de OpenRouter.
2. Realice su primera solicitud con el ejemplo de curl en el Paso 1 anterior.
3. Para conocer todos los parámetros, consulte las guías de Texto a Voz y de Voz a Texto .

Text to Speech se factura por carácter de entrada, contado como puntos de código Unicode, por lo que un emoji o un carácter CJK cuenta como uno. Las etiquetas de audio cuentan como caracteres. Scribe se factura por segundo de audio, y el campo usage.cost en cada respuesta de transcripción indica lo que costó esa solicitud. Traspasamos los precios de ElevenLabs sin recargo; consulte la página de cada modelo para conocer la tarifa actual.

¿Ya tiene una cuenta de ElevenLabs?

Añada su clave con BYOK para usar sus propias voces clonadas, diccionarios de pronunciación y formatos de mayor calidad como mp3_44100_192.

Cree una clave de API de OpenRouter, o pruebe primero un modelo en el Playground. Las guías de Text to Speech y Speech to Text incluyen la referencia completa de solicitudes.