Publicado el 12 de octubre de 2026 por AllModels

Una API para proveedores de texto a voz en tiempo real

Conéctate a varios modelos TTS a través de AllModels. Transmite audio por WebSocket, usa un SDK compatible con OpenAI o ElevenLabs y cambia de modelo sin reconstruir tu stack de voz.

AllModels es un servicio independiente y no está afiliado, respaldado ni patrocinado por los proveedores a cuyos modelos enruta.

Qué es una API de TTS unificada

Una API unificada de texto a voz (TTS) es una sola integración capaz de generar voz con modelos de muchos proveedores distintos. En lugar de escribir un cliente para Cartesia, otro para ElevenLabs, otro para MiniMax y otro para OpenAI, tu aplicación habla con un único endpoint usando una sola clave API. El modelo que eliges decide qué proveedor hace el trabajo. AllModels es una API de TTS unificada de este tipo: envías un ID de modelo como cartesia/sonic-3-6 o minimax/speech-2-8-hd, y AllModels enruta la solicitud a ese proveedor y te devuelve el audio en streaming. La misma idea recibe otros nombres: API agregadora de TTS, capa de abstracción de texto a voz o un "OpenRouter para texto a voz".

Cómo funciona AllModels

Cada modelo del catálogo de TTS de AllModels tiene un ID provider/model. Te autenticas una sola vez con una clave API de AllModels, que sustituye las claves y cuentas de facturación separadas que de otro modo tendrías con cada proveedor. AllModels ofrece tres formas de llamar a los mismos modelos:

WebSocket nativo en wss://api.allmodels.io/v1/tts. Envías el texto a medida que se genera y recibes el audio como mensajes binarios. Es la interfaz en tiempo real nativa de AllModels.
Compatible con OpenAI en https://api.allmodels.io/oai. Apunta el OpenAI SDK oficial a esta URL base y sigue llamando a audio.speech.create.
Compatible con ElevenLabs en https://api.allmodels.io/el. Apunta el ElevenLabs SDK oficial a esta URL base y sigue llamando a sus métodos de texto a voz, incluido el streaming.

Las tres acceden al mismo catálogo. Si tu código ya usa el OpenAI SDK o el ElevenLabs SDK, puedes pasarte a AllModels cambiando la URL base y la clave API.

Un catálogo, una clave, un saldo

Como agregador, AllModels también te da un solo lugar para comparar y controlar proveedores. GET /v1/models lista cada modelo TTS, los proveedores que lo ofrecen y su precio por cada 1,000 caracteres. Cuando un modelo está disponible en más de un proveedor, una preferencia provider elige entre ellos: only limita la solicitud a los proveedores que indiques, order los pone primero e ignore los excluye. El uso de todos los proveedores se cobra a un único saldo prepago de AllModels en lugar de una factura distinta por proveedor.

Cambia el modelo, conserva todo lo demás

Tu clave API, tu endpoint, tu cliente y tu código de solicitud se mantienen exactamente iguales de un proveedor a otro. Para usar otro modelo TTS, cambia el ID del modelo. AllModels se encarga del resto: se conecta al proveedor, gestiona su API y devuelve el audio a tu aplicación.

Transmite audio en tiempo real desde cualquier cliente

Elige un cliente, un modo y un lenguaje. Las líneas resaltadas son la URL base de AllModels y los valores de modelo y voz que cambias para probar otro modelo.

WebSocket nativo, streaming JavaScript · Node.js · ws

Conéctate a wss://api.allmodels.io/v1/tts, envía el texto a medida que se genera y recibe el audio como mensajes binarios. Guía de streaming.

import { once } from "node:events";
import { createWriteStream } from "node:fs";
import WebSocket from "ws";

const url = new URL("wss://api.allmodels.io/v1/tts");
url.searchParams.set("model", "grok/grok-tts");
url.searchParams.set("voice", "eve");
url.searchParams.set("format", "pcm");

const output = createWriteStream("reply.pcm");
const ws = new WebSocket(url, {
  headers: { Authorization: `Bearer ${process.env.ALLMODELS_API_KEY}` }
});

// Audio arrives as binary WebSocket messages.
ws.on("message", (data, isBinary) => {
  if (isBinary) output.write(data);
});

await once(ws, "open");
// Send text as your LLM or application produces it.
ws.send(JSON.stringify({ type: "text", text: "Your order has shipped. " }));
ws.send(JSON.stringify({ type: "text", text: "It arrives tomorrow." }));
ws.send(JSON.stringify({ type: "flush" }));
ws.send(JSON.stringify({ type: "close" }));

await once(ws, "close");
output.end();

WebSocket nativo, streaming Python · websockets

Conéctate a wss://api.allmodels.io/v1/tts, envía el texto a medida que se genera y recibe el audio como mensajes binarios. Guía de streaming.

import asyncio
import json
import os

import websockets

URL = (
    "wss://api.allmodels.io/v1/tts"
    "?model=grok%2Fgrok-tts&voice=eve&format=pcm"
)

async def receive_audio(socket):
    with open("reply.pcm", "wb", buffering=0) as output:
        async for message in socket:
            if isinstance(message, bytes):
                output.write(message)

async def main():
    async with websockets.connect(
        URL,
        additional_headers={
            "Authorization": f"Bearer {os.environ['ALLMODELS_API_KEY']}"
        },
    ) as socket:
        receiver = asyncio.create_task(receive_audio(socket))
        for text in ["Your order has shipped. ", "It arrives tomorrow."]:
            await socket.send(json.dumps({"type": "text", "text": text}))
        await socket.send(json.dumps({"type": "flush"}))
        await socket.send(json.dumps({"type": "close"}))
        await receiver

asyncio.run(main())

HTTP, solicitud única JavaScript · Node.js · fetch

¿Ya tienes el texto completo? Envíalo con POST a https://api.allmodels.io/oai/audio/speech y guarda el archivo de audio. Docs de TTS.

import { writeFile } from "node:fs/promises";

const response = await fetch("https://api.allmodels.io/oai/audio/speech", {
  method: "POST",
  headers: {
    Authorization: `Bearer ${process.env.ALLMODELS_API_KEY}`,
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
    model: "grok/grok-tts",
    voice: "eve",
    input: "Your order has shipped. It arrives tomorrow.",
    response_format: "mp3"
  })
});

if (!response.ok) throw new Error(await response.text());
await writeFile("speech.mp3", Buffer.from(await response.arrayBuffer()));

HTTP, solicitud única Python · requests

¿Ya tienes el texto completo? Envíalo con POST a https://api.allmodels.io/oai/audio/speech y guarda el archivo de audio. Docs de TTS.

import os

import requests

response = requests.post(
    "https://api.allmodels.io/oai/audio/speech",
    headers={"Authorization": f"Bearer {os.environ['ALLMODELS_API_KEY']}"},
    json={
        "model": "grok/grok-tts",
        "voice": "eve",
        "input": "Your order has shipped. It arrives tomorrow.",
        "response_format": "mp3",
    },
    timeout=60,
)
response.raise_for_status()

with open("speech.mp3", "wb") as output:
    output.write(response.content)

OpenAI SDK, streaming JavaScript · openai

Configura la URL base del OpenAI SDK como https://api.allmodels.io/oai y llama a audio.speech.create. El audio llega en streaming a medida que se genera. Docs de TTS de OpenAI.

import { createWriteStream } from "node:fs";
import { Readable } from "node:stream";
import OpenAI from "openai";

const client = new OpenAI({
  apiKey: process.env.ALLMODELS_API_KEY,
  baseURL: "https://api.allmodels.io/oai"
});

const response = await client.audio.speech.create({
  model: "grok/grok-tts",
  voice: "eve",
  input: "Your order has shipped. It arrives tomorrow.",
  response_format: "pcm",
  stream_format: "audio"
});

Readable.fromWeb(response.body).pipe(createWriteStream("speech.pcm"));

OpenAI SDK, streaming Python · openai

Configura la URL base del OpenAI SDK como https://api.allmodels.io/oai y transmite la respuesta a un archivo a medida que se genera. Docs de TTS de OpenAI.

import os
from openai import OpenAI

client = OpenAI(
    api_key=os.environ["ALLMODELS_API_KEY"],
    base_url="https://api.allmodels.io/oai",
)

with client.audio.speech.with_streaming_response.create(
    model="grok/grok-tts",
    voice="eve",
    input="Your order has shipped. It arrives tomorrow.",
    response_format="pcm",
) as response:
    response.stream_to_file("speech.pcm")

OpenAI SDK, solicitud única JavaScript · openai

Configura la URL base del OpenAI SDK como https://api.allmodels.io/oai y solicita un archivo de audio completo. Docs de TTS de OpenAI.

import { writeFile } from "node:fs/promises";
import OpenAI from "openai";

const client = new OpenAI({
  apiKey: process.env.ALLMODELS_API_KEY,
  baseURL: "https://api.allmodels.io/oai"
});

const audio = await client.audio.speech.create({
  model: "grok/grok-tts",
  voice: "eve",
  input: "Your order has shipped. It arrives tomorrow.",
  response_format: "mp3"
});

await writeFile("speech.mp3", Buffer.from(await audio.arrayBuffer()));

OpenAI SDK, solicitud única Python · openai

Configura la URL base del OpenAI SDK como https://api.allmodels.io/oai y solicita un archivo de audio completo. Docs de TTS de OpenAI.

import os
from openai import OpenAI

client = OpenAI(
    api_key=os.environ["ALLMODELS_API_KEY"],
    base_url="https://api.allmodels.io/oai",
)

audio = client.audio.speech.create(
    model="grok/grok-tts",
    voice="eve",
    input="Your order has shipped. It arrives tomorrow.",
    response_format="mp3",
)

audio.write_to_file("speech.mp3")

ElevenLabs SDK, streaming JavaScript · @elevenlabs/elevenlabs-js

Configura la URL base del ElevenLabs SDK como https://api.allmodels.io/el y transmite fragmentos de audio a medida que se generan. Docs de TTS de ElevenLabs.

import { createWriteStream } from "node:fs";
import { ElevenLabsClient } from "@elevenlabs/elevenlabs-js";

const client = new ElevenLabsClient({
  apiKey: process.env.ALLMODELS_API_KEY,
  baseUrl: "https://api.allmodels.io/el"
});

const audio = await client.textToSpeech.stream("eve", {
  text: "Your order has shipped. It arrives tomorrow.",
  modelId: "grok/grok-tts",
  outputFormat: "mp3_44100_128"
});

const output = createWriteStream("speech.mp3");
for await (const chunk of audio) {
  output.write(Buffer.from(chunk));
}
output.end();

ElevenLabs SDK, streaming Python · elevenlabs

Configura la URL base del ElevenLabs SDK como https://api.allmodels.io/el. convert_realtime envía el texto por un WebSocket a medida que se genera y devuelve el audio conforme llega. Docs de TTS de ElevenLabs.

import os
from elevenlabs.client import ElevenLabs

client = ElevenLabs(
    api_key=os.environ["ALLMODELS_API_KEY"],
    base_url="https://api.allmodels.io/el",
)

def generated_text():
    # Yield text as your LLM or application produces it.
    yield "Your order has shipped. "
    yield "It arrives tomorrow."

audio = client.text_to_speech.convert_realtime(
    "eve",
    text=generated_text(),
    model_id="grok/grok-tts",
    output_format="pcm_24000",
)

with open("reply.pcm", "wb", buffering=0) as output:
    for chunk in audio:
        output.write(chunk)

ElevenLabs SDK, solicitud única JavaScript · @elevenlabs/elevenlabs-js

Configura la URL base del ElevenLabs SDK como https://api.allmodels.io/el y convierte un texto completo en un archivo de audio. Docs de TTS de ElevenLabs.

import { writeFile } from "node:fs/promises";
import { ElevenLabsClient } from "@elevenlabs/elevenlabs-js";

const client = new ElevenLabsClient({
  apiKey: process.env.ALLMODELS_API_KEY,
  baseUrl: "https://api.allmodels.io/el"
});

const audio = await client.textToSpeech.convert("eve", {
  text: "Your order has shipped. It arrives tomorrow.",
  modelId: "grok/grok-tts",
  outputFormat: "mp3_44100_128"
});

const chunks = await Array.fromAsync(audio, (chunk) => Buffer.from(chunk));
await writeFile("speech.mp3", Buffer.concat(chunks));

ElevenLabs SDK, solicitud única Python · elevenlabs

Configura la URL base del ElevenLabs SDK como https://api.allmodels.io/el y convierte un texto completo en un archivo de audio. Docs de TTS de ElevenLabs.

import os
from elevenlabs.client import ElevenLabs

client = ElevenLabs(
    api_key=os.environ["ALLMODELS_API_KEY"],
    base_url="https://api.allmodels.io/el",
)

audio = client.text_to_speech.convert(
    "eve",
    text="Your order has shipped. It arrives tomorrow.",
    model_id="grok/grok-tts",
    output_format="mp3_44100_128",
)

with open("speech.mp3", "wb") as output:
    for chunk in audio:
        output.write(chunk)

Interfaces compatibles

Usa el cliente que tu equipo ya conoce

https://api.allmodels.io/oai

Compatible con OpenAI

¿Ya usas el OpenAI SDK? Configura su URL base para AllModels y sigue llamando a audio.speech.create, ahora con un ID de modelo de AllModels. Funcionan tanto el streaming como las solicitudes únicas.

Lee la documentación de TTS de OpenAI

https://api.allmodels.io/el

Compatible con ElevenLabs

¿Ya usas el ElevenLabs SDK? Configura su URL base para AllModels y sigue usando sus métodos convert, stream y realtime, ahora con un ID de modelo de AllModels.

Lee la documentación de TTS de ElevenLabs

Respuestas rápidas

Conceptos básicos de una API de TTS en tiempo real

¿Qué es una API de TTS unificada?

Una API de TTS unificada ofrece a las aplicaciones una sola superficie de integración para varios modelos de texto a voz. Con AllModels, el ID de modelo elegido determina la ruta, mientras que la autenticación y el flujo principal de las solicitudes no cambian.

¿AllModels admite audio en tiempo real?

Sí. La interfaz nativa transmite por WebSocket en /v1/tts, el ElevenLabs SDK de Python envía el texto por un WebSocket compatible, y ambos SDKs pueden recibir el audio en streaming por HTTP. La compatibilidad con streaming varía según el modelo.

¿Puedo usar todas las funciones de cada proveedor?

Sí. Los ajustes comunes usan los campos estándar, y cualquier ajuste específico de un proveedor, como la configuración de voz, va en provider_options y se pasa directamente al proveedor.

¿Existe un OpenRouter para texto a voz?

Sí. AllModels funciona como OpenRouter para voz: una clave API y un endpoint te dan modelos de texto a voz de varios proveedores, elegidos por su ID provider/model. También acepta los SDKs oficiales de OpenAI y ElevenLabs, así que el código existente solo necesita una nueva URL base y una nueva clave.

¿En qué se diferencia una API agregadora de TTS de una biblioteca de abstracción de código abierto?

Una biblioteca de abstracción de código abierto se ejecuta dentro de tu aplicación y sigue necesitando tu propia cuenta, clave API y facturación con cada proveedor que envuelve. Una API agregadora como AllModels es un servicio alojado: una clave y un saldo prepago cubren todo el catálogo de TTS, y la llamas con el SDK de OpenAI o ElevenLabs que ya usas, o por WebSocket.

¿Cómo comparo proveedores?

Explora el catálogo de TTS para comparar los modelos disponibles, rutas, precios, idiomas, voces y ejemplos de API antes de cambiar el ID de modelo en tu aplicación.

Una integración en tres pasos

1
Elige un modelo. Elige un modelo TTS del catálogo en vivo por su ID provider/model.
2
Usa una sola clave API. Autentícate con AllModels en lugar de usar una clave distinta para cada proveedor.
3
Transmite o genera. Transmite por WebSocket para audio en vivo, o solicita un archivo completo por HTTP.

Construye con AllModels

Empieza con una sola integración de TTS.

Elige un modelo ahora y conserva la libertad de cambiarlo después.

Empieza gratis Explora los modelos TTS