---
title: "API unificada de TTS en tiempo real: un agregador para varios proveedores"
description: "Una API unificada de TTS en tiempo real y un agregador para varios proveedores de voz. Transmite audio por WebSocket o usa SDKs compatibles con OpenAI y ElevenLabs con una sola clave."
canonical: "https://allmodels.io/es/guides/universal-tts-api"
markdown: "https://allmodels.io/es/guides/universal-tts-api.md"
author: "AllModels"
datePublished: "2026-10-12"
dateModified: "2026-10-16"
---

# 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](https://allmodels.io/es/audio/models?type=tts) 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

Cliente: Nativo · Modo: Streaming · Lenguaje: JS

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](https://allmodels.io/audio/docs/streaming-realtime).

```javascript
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

Cliente: Nativo · Modo: Streaming · Lenguaje: Python

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](https://allmodels.io/audio/docs/streaming-realtime).

```python
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

Cliente: Nativo · Modo: Solicitud · Lenguaje: JS

¿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](https://allmodels.io/audio/docs/text-to-speech).

```javascript
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

Cliente: Nativo · Modo: Solicitud · Lenguaje: Python

¿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](https://allmodels.io/audio/docs/text-to-speech).

```python
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

Cliente: OpenAI SDK · Modo: Streaming · Lenguaje: JS

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](https://allmodels.io/audio/docs/openai/text-to-speech).

```javascript
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

Cliente: OpenAI SDK · Modo: Streaming · Lenguaje: Python

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](https://allmodels.io/audio/docs/openai/text-to-speech).

```python
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

Cliente: OpenAI SDK · Modo: Solicitud · Lenguaje: JS

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](https://allmodels.io/audio/docs/openai/text-to-speech).

```javascript
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

Cliente: OpenAI SDK · Modo: Solicitud · Lenguaje: Python

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](https://allmodels.io/audio/docs/openai/text-to-speech).

```python
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

Cliente: ElevenLabs SDK · Modo: Streaming · Lenguaje: 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](https://allmodels.io/audio/docs/elevenlabs/text-to-speech).

```javascript
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

Cliente: ElevenLabs SDK · Modo: Streaming · Lenguaje: Python

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](https://allmodels.io/audio/docs/elevenlabs/text-to-speech).

```python
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

Cliente: ElevenLabs SDK · Modo: Solicitud · Lenguaje: 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](https://allmodels.io/audio/docs/elevenlabs/text-to-speech).

```javascript
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

Cliente: ElevenLabs SDK · Modo: Solicitud · Lenguaje: Python

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](https://allmodels.io/audio/docs/elevenlabs/text-to-speech).

```python
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)
```

## Usa el cliente que tu equipo ya conoce

### Compatible con OpenAI

Endpoint: `https://api.allmodels.io/oai`

¿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://allmodels.io/audio/docs/openai/text-to-speech)

### Compatible con ElevenLabs

Endpoint: `https://api.allmodels.io/el`

¿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](https://allmodels.io/audio/docs/elevenlabs/text-to-speech)

## 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](https://allmodels.io/es/audio/models?type=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](https://allmodels.io/es/audio/models?type=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](https://allmodels.io/es/audio/models?type=tts) 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.

## Empieza con una sola integración de TTS.

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

- [Empieza gratis](https://dash.allmodels.io/signup)
- [Explora los modelos TTS](https://allmodels.io/es/audio/models?type=tts)
- [Lee la documentación de AllModels](https://allmodels.io/audio/docs)
- [Ver la guía HTML canónica](https://allmodels.io/es/guides/universal-tts-api)