Publicado el 15 de octubre de 2026 por AllModels

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

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.

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

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.

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

¿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.

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

¿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.

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

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.

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

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.

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

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.

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

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.

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

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.

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

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.

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

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.

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

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.

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)

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

Lee la documentación de transcripción 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 de voz a texto convert y realtime, ahora con un ID de modelo de AllModels.

Lee la documentación de transcripción de ElevenLabs

Respuestas rápidas

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 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 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.

Construye con AllModels

Empieza con una sola integración de STT.

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

Empieza gratis Explora los modelos STT