Publié le 15 octobre 2026 par AllModels

Une seule API pour les fournisseurs de reconnaissance vocale en temps réel

Transcrivez avec des modèles STT de plusieurs fournisseurs via AllModels. Streamez l’audio en WebSocket, utilisez un SDK compatible OpenAI ou ElevenLabs, et changez de modèle sans reconstruire votre pipeline de transcription.

AllModels est un service indépendant, sans affiliation avec les fournisseurs vers lesquels il route les modèles, ni approuvé ou sponsorisé par eux.

Qu’est-ce qu’une API de reconnaissance vocale unifiée ?

Une API de reconnaissance vocale (STT) unifiée est une intégration unique capable de transcrire de l’audio avec des modèles de nombreux fournisseurs différents. Au lieu d’écrire un client pour Deepgram, un autre pour AssemblyAI, un autre pour Soniox et un autre encore pour OpenAI, votre application s’adresse à un seul endpoint avec une seule clé API. C’est le modèle choisi qui détermine le fournisseur qui transcrit l’audio. AllModels est une API STT unifiée de ce type : vous envoyez un ID de modèle comme deepgram/nova-3, assemblyai/universal-3-5-pro-realtime ou soniox/stt-rt-v5, AllModels route l’audio vers ce fournisseur et vous renvoie la transcription.

Comment fonctionne AllModels

Chaque modèle du catalogue STT d’AllModels possède un ID provider/model. Vous vous authentifiez une seule fois avec une clé API AllModels, qui remplace les clés et comptes de facturation distincts que vous auriez sinon chez chaque fournisseur. AllModels propose ensuite trois façons d’appeler les mêmes modèles :

WebSocket natif sur wss://api.allmodels.io/v1/stt. Vous envoyez les trames audio brutes au fur et à mesure de leur capture et recevez des événements stt.transcript.partial et stt.transcript.final dans un format normalisé unique, quel que soit le fournisseur derrière le modèle.
Compatible OpenAI sur https://api.allmodels.io/oai. Pointez le SDK OpenAI officiel vers cette URL de base et continuez d’appeler audio.transcriptions.create pour les fichiers, ou son client realtime pour l’audio en direct.
Compatible ElevenLabs sur https://api.allmodels.io/el. Pointez le SDK ElevenLabs officiel vers cette URL de base et continuez d’appeler ses méthodes de reconnaissance vocale, transcription en temps réel comprise.

Les trois donnent accès au même catalogue. Si votre code utilise déjà le SDK OpenAI ou ElevenLabs, il suffit de changer l’URL de base et la clé API pour passer à AllModels.

Audio en direct et fichiers complets

Pour les microphones, les appels et les agents vocaux, streamez l’audio via un WebSocket et lisez les transcriptions partielles pendant que la personne parle encore. Si l’enregistrement complet existe déjà, envoyez-le en une seule requête HTTP et récupérez la transcription intégrale. Pour utiliser un autre modèle STT, changez l’ID du modèle ; votre clé API, votre endpoint et votre code client restent les mêmes.

Transcrivez de l’audio en temps réel depuis n’importe quel client

Choisissez un client, un mode et un langage. Les lignes en surbrillance sont l’URL de base AllModels et les valeurs de modèle à modifier pour essayer un autre modèle.

WebSocket natif, streaming JavaScript · Node.js · ws

Connectez-vous à wss://api.allmodels.io/v1/stt, envoyez de l’audio PCM 16 kHz en trames binaires et lisez les transcriptions partielles et finales. Documentation 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 natif, streaming Python · websockets

Connectez-vous à wss://api.allmodels.io/v1/stt, envoyez de l’audio PCM 16 kHz en trames binaires et lisez les transcriptions partielles et finales. Documentation 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, requête unique JavaScript · Node.js · fetch

Vous avez déjà l’enregistrement ? Envoyez-le en POST à https://api.allmodels.io/oai/audio/transcriptions et lisez la transcription. Documentation 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, requête unique Python · requests

Vous avez déjà l’enregistrement ? Envoyez-le en POST à https://api.allmodels.io/oai/audio/transcriptions et lisez la transcription. Documentation 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"])

SDK OpenAI, temps réel JavaScript · openai

Définissez l’URL de base du SDK OpenAI sur https://api.allmodels.io/oai, ouvrez une session de transcription en temps réel et envoyez de l’audio PCM 24 kHz. Documentation realtime 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" });

SDK OpenAI, temps réel Python · openai

Définissez l’URL de base du SDK OpenAI sur https://api.allmodels.io/oai, ouvrez une session de transcription en temps réel et envoyez de l’audio PCM 24 kHz. Documentation realtime 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())

SDK OpenAI, requête unique JavaScript · openai

Définissez l’URL de base du SDK OpenAI sur https://api.allmodels.io/oai et transcrivez un fichier complet avec audio.transcriptions.create. Documentation de transcription 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);

SDK OpenAI, requête unique Python · openai

Définissez l’URL de base du SDK OpenAI sur https://api.allmodels.io/oai et transcrivez un fichier complet avec audio.transcriptions.create. Documentation de transcription 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)

SDK ElevenLabs, temps réel JavaScript · @elevenlabs/elevenlabs-js

Définissez l’URL de base du SDK ElevenLabs sur https://api.allmodels.io/el et streamez de l’audio PCM 16 kHz via son client de reconnaissance vocale en temps réel. Documentation realtime 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();
});

SDK ElevenLabs, temps réel Python · 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())

SDK ElevenLabs, requête unique JavaScript · @elevenlabs/elevenlabs-js

Définissez l’URL de base du SDK ElevenLabs sur https://api.allmodels.io/el et transcrivez un fichier complet. Le SDK JavaScript vérifie les ID de modèle : utilisez un ID qu’il reconnaît, comme scribe_v2. Documentation de transcription 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);

SDK ElevenLabs, requête unique Python · elevenlabs

Définissez l’URL de base du SDK ElevenLabs sur https://api.allmodels.io/el et transcrivez un fichier complet avec n’importe quel ID de modèle STT AllModels. Documentation de transcription 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

Utilisez le client que votre équipe connaît déjà

https://api.allmodels.io/oai

Compatible OpenAI

Vous utilisez déjà le SDK OpenAI ? Pointez son URL de base vers AllModels et continuez d’appeler audio.transcriptions.create ou le client realtime, désormais avec un ID de modèle AllModels.

Lire la documentation de transcription OpenAI

https://api.allmodels.io/el

Compatible ElevenLabs

Vous utilisez déjà le SDK ElevenLabs ? Pointez son URL de base vers AllModels et continuez d’utiliser ses méthodes de reconnaissance vocale convert et realtime, désormais avec un ID de modèle AllModels.

Lire la documentation de transcription ElevenLabs

Réponses rapides

L’essentiel sur les API STT en temps réel

Qu’est-ce qu’une API de reconnaissance vocale unifiée ?

Une API STT unifiée offre aux applications une seule surface d’intégration pour plusieurs modèles de transcription. Avec AllModels, l’ID du modèle choisi détermine le fournisseur, tandis que l’authentification et le déroulement des requêtes restent les mêmes.

AllModels prend-il en charge la transcription en temps réel ?

Oui. L’interface native streame en WebSocket sur /v1/stt et renvoie les transcriptions partielles et finales sous forme d’événements stt.* normalisés. Les SDK OpenAI et ElevenLabs streament via leurs propres clients realtime. La prise en charge du streaming varie selon le modèle.

Puis-je utiliser toutes les fonctionnalités d’un fournisseur ?

Oui. Les réglages courants passent par les champs standard, et tout réglage propre à un fournisseur, comme les paramètres de diarisation, se place dans provider_options et est transmis tel quel au fournisseur.

Comment comparer les fournisseurs ?

Parcourez le catalogue STT pour comparer les modèles disponibles, la prise en charge du streaming, les tarifs et les exemples d’API avant de changer l’ID du modèle dans votre application.

Une intégration en trois étapes

1
Choisissez un modèle. Sélectionnez un modèle STT dans le catalogue en direct par son ID provider/model.
2
Utilisez une seule clé API. Authentifiez-vous auprès d’AllModels au lieu de gérer une clé par fournisseur.
3
Streamez ou envoyez un fichier. Streamez l’audio en WebSocket pour des transcriptions en direct, ou envoyez un fichier complet en HTTP.

Développez avec AllModels

Commencez avec une seule intégration STT.

Choisissez un modèle aujourd’hui et gardez la liberté d’en changer plus tard.

Commencer gratuitement Parcourir les modèles STT