---
title: "API de reconnaissance vocale unifiée en temps réel pour plusieurs fournisseurs"
description: "Une seule API de reconnaissance vocale en temps réel pour plusieurs fournisseurs de transcription. Streamez l’audio en WebSocket ou utilisez les SDK compatibles OpenAI et ElevenLabs avec AllModels."
canonical: "https://allmodels.io/fr/guides/universal-stt-api"
markdown: "https://allmodels.io/fr/guides/universal-stt-api.md"
author: "AllModels"
datePublished: "2026-10-15"
dateModified: "2026-10-15"
---

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

Client : Natif · Mode : Streaming · Langage : JS

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](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 natif, streaming — Python · websockets

Client : Natif · Mode : Streaming · Langage : Python

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](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, requête unique — JavaScript · Node.js · fetch

Client : Natif · Mode : Requête · Langage : JS

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

Client : Natif · Mode : Requête · Langage : Python

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

### SDK OpenAI, temps réel — JavaScript · openai

Client : SDK OpenAI · Mode : Streaming · Langage : JS

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](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" });
```

### SDK OpenAI, temps réel — Python · openai

Client : SDK OpenAI · Mode : Streaming · Langage : Python

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](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())
```

### SDK OpenAI, requête unique — JavaScript · openai

Client : SDK OpenAI · Mode : Requête · Langage : JS

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](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);
```

### SDK OpenAI, requête unique — Python · openai

Client : SDK OpenAI · Mode : Requête · Langage : Python

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](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)
```

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

Client : SDK ElevenLabs · Mode : Streaming · Langage : 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](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();
});
```

### SDK ElevenLabs, temps réel — Python · elevenlabs

Client : SDK ElevenLabs · Mode : Streaming · Langage : Python

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](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())
```

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

Client : SDK ElevenLabs · Mode : Requête · Langage : 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](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);
```

### SDK ElevenLabs, requête unique — Python · elevenlabs

Client : SDK ElevenLabs · Mode : Requête · Langage : Python

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](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)
```

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

### Compatible OpenAI

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

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://allmodels.io/audio/docs/openai/transcription)

### Compatible ElevenLabs

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

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

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

## Commencez avec une seule intégration STT.

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

- [Commencer gratuitement](https://dash.allmodels.io/signup)
- [Parcourir les modèles STT](https://allmodels.io/fr/audio/models?type=stt)
- [Lire la documentation AllModels](https://allmodels.io/audio/docs)
- [Voir le guide HTML canonique](https://allmodels.io/fr/guides/universal-stt-api)