---
title: "API unificada de voz a texto en tiempo real para varios proveedores"
description: "Usa una sola API de voz a texto en tiempo real para varios proveedores de transcripción. Transmite audio por WebSocket o usa SDKs compatibles con OpenAI y ElevenLabs con AllModels."
canonical: "https://allmodels.io/es/guides/universal-stt-api"
markdown: "https://allmodels.io/es/guides/universal-stt-api.md"
author: "AllModels"
datePublished: "2026-10-15"
dateModified: "2026-10-15"
---

# Una API para proveedores de voz a texto en tiempo real

Transcribe con modelos STT de varios proveedores a través de AllModels. Transmite audio por WebSocket, usa un SDK compatible con OpenAI o ElevenLabs y cambia de modelo sin reconstruir tu pipeline de transcripción.

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

## Qué es una API de voz a texto unificada

Una API unificada de voz a texto (STT) es una sola integración capaz de transcribir audio con modelos de muchos proveedores distintos. En lugar de escribir un cliente para Deepgram, otro para AssemblyAI, otro para Soniox y otro para OpenAI, tu aplicación habla con un único endpoint usando una sola clave API. El modelo que eliges decide qué proveedor transcribe el audio. AllModels es una API de STT unificada de este tipo: envías un ID de modelo como `deepgram/nova-3`, `assemblyai/universal-3-5-pro-realtime` o `soniox/stt-rt-v5`, y AllModels enruta el audio a ese proveedor y te devuelve la transcripción.

### Cómo funciona AllModels

Cada modelo del [catálogo de STT de AllModels](https://allmodels.io/es/audio/models?type=stt) 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/stt`. Envías frames de audio sin procesar a medida que se capturan y recibes eventos `stt.transcript.partial` y `stt.transcript.final` en un único formato normalizado, sea cual sea el proveedor detrás del modelo.
- **Compatible con OpenAI** en `https://api.allmodels.io/oai`. Apunta el OpenAI SDK oficial a esta URL base y sigue llamando a `audio.transcriptions.create` para archivos, o a su cliente realtime para audio en vivo.
- **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 voz a texto, incluida la transcripción en tiempo real.

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.

### Audio en vivo y archivos completos

Para micrófonos, llamadas y agentes de voz, transmite el audio por WebSocket y lee transcripciones parciales mientras la persona sigue hablando. Cuando ya tienes la grabación completa, súbela en una sola solicitud HTTP y recibe la transcripción entera. Para usar otro modelo STT, cambia el ID del modelo; tu clave API, tu endpoint y el código de tu cliente no cambian.

## Transcribe 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 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/stt`, envía audio PCM a 16 kHz como frames binarios y lee las transcripciones parciales y finales. [Docs de STT](https://allmodels.io/audio/docs/speech-to-text).

```javascript
import { readFile } from "node:fs/promises";
import WebSocket from "ws";

const url = new URL("wss://api.allmodels.io/v1/stt");
url.searchParams.set("model", "deepgram/nova-3");
url.searchParams.set("audio_format", "pcm_16000");
url.searchParams.set("language", "en");
url.searchParams.set("commit_strategy", "manual");

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

ws.on("message", (data) => {
  const event = JSON.parse(data.toString());
  if (event.type === "stt.transcript.partial") console.log("partial:", event.text);
  if (event.type === "stt.transcript.final") {
    console.log("final:", event.text);
    ws.send(JSON.stringify({ type: "stt.session.close" }));
  }
});

ws.on("open", async () => {
  const audio = await readFile("speech-16khz.pcm");
  for (let offset = 0; offset < audio.length; offset += 3200) {
    ws.send(audio.subarray(offset, offset + 3200));
  }
  ws.send(JSON.stringify({ type: "stt.audio.commit" }));
});
```

### WebSocket nativo, streaming — Python · websockets

Cliente: Nativo · Modo: Streaming · Lenguaje: Python

Conéctate a `wss://api.allmodels.io/v1/stt`, envía audio PCM a 16 kHz como frames binarios y lee las transcripciones parciales y finales. [Docs de STT](https://allmodels.io/audio/docs/speech-to-text).

```python
import asyncio
import json
import os
from pathlib import Path
from urllib.parse import urlencode

import websockets

async def main():
    query = urlencode({
        "model": "deepgram/nova-3",
        "audio_format": "pcm_16000",
        "language": "en",
        "commit_strategy": "manual",
    })
    headers = {"Authorization": f"Bearer {os.environ['ALLMODELS_API_KEY']}"}
    async with websockets.connect(
        f"wss://api.allmodels.io/v1/stt?{query}", additional_headers=headers
    ) as ws:
        audio = Path("speech-16khz.pcm").read_bytes()
        for offset in range(0, len(audio), 3200):
            await ws.send(audio[offset:offset + 3200])
        await ws.send(json.dumps({"type": "stt.audio.commit"}))

        async for message in ws:
            event = json.loads(message)
            if event["type"] == "stt.transcript.partial":
                print("partial:", event["text"])
            elif event["type"] == "stt.transcript.final":
                print("final:", event["text"])
                break

asyncio.run(main())
```

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

Cliente: Nativo · Modo: Solicitud · Lenguaje: JS

¿Ya tienes la grabación? Envíala con POST a `https://api.allmodels.io/oai/audio/transcriptions` y lee la transcripción. [Docs de STT](https://allmodels.io/audio/docs/speech-to-text).

```javascript
import { readFile } from "node:fs/promises";

const form = new FormData();
form.set("model", "deepgram/nova-3");
form.set("language", "en");
form.set("file", new Blob([await readFile("call.wav")], { type: "audio/wav" }), "call.wav");

const response = await fetch("https://api.allmodels.io/oai/audio/transcriptions", {
  method: "POST",
  headers: { Authorization: `Bearer ${process.env.ALLMODELS_API_KEY}` },
  body: form
});

if (!response.ok) throw new Error(await response.text());
const transcript = await response.json();
console.log(transcript.text);
```

### HTTP, solicitud única — Python · requests

Cliente: Nativo · Modo: Solicitud · Lenguaje: Python

¿Ya tienes la grabación? Envíala con POST a `https://api.allmodels.io/oai/audio/transcriptions` y lee la transcripción. [Docs de STT](https://allmodels.io/audio/docs/speech-to-text).

```python
import os
import requests

with open("call.wav", "rb") as audio:
    response = requests.post(
        "https://api.allmodels.io/oai/audio/transcriptions",
        headers={"Authorization": f"Bearer {os.environ['ALLMODELS_API_KEY']}"},
        data={"model": "deepgram/nova-3", "language": "en"},
        files={"file": ("call.wav", audio, "audio/wav")},
        timeout=60,
    )

response.raise_for_status()
print(response.json()["text"])
```

### OpenAI SDK, tiempo real — JavaScript · openai

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

Configura la URL base del OpenAI SDK como `https://api.allmodels.io/oai`, abre una sesión de transcripción en tiempo real y envía audio PCM a 24 kHz. [Docs de realtime de OpenAI](https://allmodels.io/audio/docs/openai/realtime).

```javascript
import { once } from "node:events";
import { readFile } from "node:fs/promises";
import OpenAI from "openai";
import { OpenAIRealtimeWebSocket } from "openai/realtime/websocket";

const client = new OpenAI({
  apiKey: process.env.ALLMODELS_API_KEY,
  baseURL: "https://api.allmodels.io/oai"
});
const realtime = await OpenAIRealtimeWebSocket.create(client, {
  model: "openai/gpt-realtime-whisper"
});
if (realtime.socket.readyState !== 1) await once(realtime.socket, "open");

realtime.on("conversation.item.input_audio_transcription.delta", ({ delta }) => {
  process.stdout.write(delta);
});
realtime.on("conversation.item.input_audio_transcription.completed", ({ transcript }) => {
  console.log("\nfinal:", transcript);
  realtime.close();
});

realtime.send({
  type: "session.update",
  session: {
    type: "transcription",
    audio: {
      input: {
        format: { type: "audio/pcm", rate: 24000 },
        transcription: { model: "openai/gpt-realtime-whisper", language: "en" },
        turn_detection: null
      }
    }
  }
});

const audio = await readFile("speech-24khz.pcm");
for (let offset = 0; offset < audio.length; offset += 4800) {
  realtime.send({
    type: "input_audio_buffer.append",
    audio: audio.subarray(offset, offset + 4800).toString("base64")
  });
}
realtime.send({ type: "input_audio_buffer.commit" });
```

### OpenAI SDK, tiempo real — Python · openai

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

Configura la URL base del OpenAI SDK como `https://api.allmodels.io/oai`, abre una sesión de transcripción en tiempo real y envía audio PCM a 24 kHz. [Docs de realtime de OpenAI](https://allmodels.io/audio/docs/openai/realtime).

```python
import asyncio
import base64
import os
from pathlib import Path

from openai import AsyncOpenAI

async def main():
    client = AsyncOpenAI(
        api_key=os.environ["ALLMODELS_API_KEY"],
        base_url="https://api.allmodels.io/oai",
    )
    async with client.realtime.connect(
        model="openai/gpt-realtime-whisper",
        extra_query={"intent": "transcription"},
    ) as connection:
        await connection.session.update(session={
            "type": "transcription",
            "audio": {
                "input": {
                    "format": {"type": "audio/pcm", "rate": 24000},
                    "transcription": {"model": "openai/gpt-realtime-whisper", "language": "en"},
                    "turn_detection": None,
                }
            },
        })

        audio = Path("speech-24khz.pcm").read_bytes()
        for offset in range(0, len(audio), 4800):
            chunk = base64.b64encode(audio[offset:offset + 4800]).decode("ascii")
            await connection.input_audio_buffer.append(audio=chunk)
        await connection.input_audio_buffer.commit()

        async for event in connection:
            if event.type == "conversation.item.input_audio_transcription.delta":
                print(event.delta, end="", flush=True)
            elif event.type == "conversation.item.input_audio_transcription.completed":
                print("\nfinal:", event.transcript)
                break

asyncio.run(main())
```

### 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 transcribe un archivo completo con `audio.transcriptions.create`. [Docs de transcripción de OpenAI](https://allmodels.io/audio/docs/openai/transcription).

```javascript
import { createReadStream } from "node:fs";
import OpenAI from "openai";

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

const transcript = await client.audio.transcriptions.create({
  file: createReadStream("call.wav"),
  model: "deepgram/nova-3",
  language: "en"
});

console.log(transcript.text);
```

### 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 transcribe un archivo completo con `audio.transcriptions.create`. [Docs de transcripción de OpenAI](https://allmodels.io/audio/docs/openai/transcription).

```python
import os
from openai import OpenAI

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

with open("call.wav", "rb") as audio:
    transcript = client.audio.transcriptions.create(
        file=audio,
        model="deepgram/nova-3",
        language="en",
    )

print(transcript.text)
```

### ElevenLabs SDK, tiempo real — 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 audio PCM a 16 kHz a través de su cliente de voz a texto en tiempo real. [Docs de realtime de ElevenLabs](https://allmodels.io/audio/docs/elevenlabs/realtime).

```javascript
import { readFile } from "node:fs/promises";
import { AudioFormat, CommitStrategy, ElevenLabsClient, RealtimeEvents } from "@elevenlabs/elevenlabs-js";

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

const connection = await client.speechToText.realtime.connect({
  modelId: "deepgram/nova-3",
  audioFormat: AudioFormat.PCM_16000,
  sampleRate: 16000,
  languageCode: "en",
  commitStrategy: CommitStrategy.MANUAL
});

connection.on(RealtimeEvents.PARTIAL_TRANSCRIPT, ({ text }) => console.log("partial:", text));
connection.on(RealtimeEvents.COMMITTED_TRANSCRIPT, ({ text }) => {
  console.log("final:", text);
  connection.close();
});

connection.on(RealtimeEvents.SESSION_STARTED, async () => {
  const audio = await readFile("speech-16khz.pcm");
  for (let offset = 0; offset < audio.length; offset += 3200) {
    connection.send({ audioBase64: audio.subarray(offset, offset + 3200).toString("base64") });
  }
  connection.commit();
});
```

### ElevenLabs SDK, tiempo real — Python · elevenlabs

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

Configura la URL base del ElevenLabs SDK como `https://api.allmodels.io/el` y transmite audio PCM a 16 kHz a través de su cliente de voz a texto en tiempo real. [Docs de realtime de ElevenLabs](https://allmodels.io/audio/docs/elevenlabs/realtime).

```python
import asyncio
import base64
import os
from pathlib import Path

from elevenlabs import AudioFormat, CommitStrategy, ElevenLabs, RealtimeEvents

async def main():
    client = ElevenLabs(
        api_key=os.environ["ALLMODELS_API_KEY"],
        base_url="https://api.allmodels.io/el",
    )
    connection = await client.speech_to_text.realtime.connect({
        "model_id": "deepgram/nova-3",
        "audio_format": AudioFormat.PCM_16000,
        "sample_rate": 16000,
        "language_code": "en",
        "commit_strategy": CommitStrategy.MANUAL,
    })

    finished = asyncio.Event()

    def on_committed(event):
        print("final:", event["text"])
        finished.set()

    connection.on(RealtimeEvents.PARTIAL_TRANSCRIPT, lambda event: print("partial:", event["text"]))
    connection.on(RealtimeEvents.COMMITTED_TRANSCRIPT, on_committed)

    audio = Path("speech-16khz.pcm").read_bytes()
    for offset in range(0, len(audio), 3200):
        chunk = base64.b64encode(audio[offset:offset + 3200]).decode("ascii")
        await connection.send({"audio_base_64": chunk})
    await connection.commit()
    await finished.wait()
    await connection.close()

asyncio.run(main())
```

### 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 transcribe un archivo completo. El SDK de JavaScript valida los IDs de modelo, así que usa un ID que reconozca, como `scribe_v2`. [Docs de transcripción de ElevenLabs](https://allmodels.io/audio/docs/elevenlabs/transcription).

```javascript
import { File } from "node:buffer";
import { readFile } 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 bytes = await readFile("call.wav");
const transcript = await client.speechToText.convert({
  file: new File([bytes], "call.wav", { type: "audio/wav" }),
  modelId: "scribe_v2",
  languageCode: "en"
});

console.log(transcript.text);
```

### 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 transcribe un archivo completo con cualquier ID de modelo STT de AllModels. [Docs de transcripción de ElevenLabs](https://allmodels.io/audio/docs/elevenlabs/transcription).

```python
import os
from elevenlabs.client import ElevenLabs

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

with open("call.wav", "rb") as audio:
    transcript = client.speech_to_text.convert(
        file=audio,
        model_id="deepgram/nova-3",
        language_code="en",
    )

print(transcript.text)
```

## 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.transcriptions.create` o al cliente realtime, ahora con un ID de modelo de AllModels.

- [Lee la documentación de transcripción de OpenAI](https://allmodels.io/audio/docs/openai/transcription)

### 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 de voz a texto convert y realtime, ahora con un ID de modelo de AllModels.

- [Lee la documentación de transcripción de ElevenLabs](https://allmodels.io/audio/docs/elevenlabs/transcription)

## Conceptos básicos de una API de STT en tiempo real

### ¿Qué es una API de voz a texto unificada?

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

### ¿AllModels admite transcripción en tiempo real?

Sí. La interfaz nativa transmite por WebSocket en `/v1/stt` y devuelve transcripciones parciales y finales como eventos `stt.*` normalizados. Los SDKs de OpenAI y ElevenLabs transmiten a través de sus propios clientes realtime. 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 diarización, va en `provider_options` y se pasa directamente al proveedor.

### ¿Cómo comparo proveedores?

Explora el [catálogo de STT](https://allmodels.io/es/audio/models?type=stt) para comparar los modelos disponibles, la compatibilidad con streaming, los precios y los 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 STT del [catálogo en vivo](https://allmodels.io/es/audio/models?type=stt) 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 sube.** Transmite audio por WebSocket para obtener transcripciones en vivo, o sube un archivo completo por HTTP.

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

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

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