---
title: "API TTS unifiée en temps réel : un agrégateur pour plusieurs fournisseurs"
description: "Une API de synthèse vocale unifiée et en temps réel qui agrège plusieurs fournisseurs de voix. Streamez l’audio en WebSocket ou utilisez les SDK compatibles OpenAI et ElevenLabs avec une seule clé."
canonical: "https://allmodels.io/fr/guides/universal-tts-api"
markdown: "https://allmodels.io/fr/guides/universal-tts-api.md"
author: "AllModels"
datePublished: "2026-10-12"
dateModified: "2026-10-16"
---

# Une seule API pour les fournisseurs de synthèse vocale en temps réel

Accédez à de nombreux modèles TTS via AllModels. Streamez l’audio en WebSocket, utilisez un SDK compatible OpenAI ou ElevenLabs, et changez de modèle sans reconstruire votre pile vocale.

> 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 TTS unifiée ?

Une API de synthèse vocale (TTS) unifiée est une intégration unique capable de générer de la parole avec des modèles de nombreux fournisseurs différents. Au lieu d’écrire un client pour Cartesia, un autre pour ElevenLabs, un autre pour MiniMax 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 fait le travail. AllModels est une API TTS unifiée de ce type : vous envoyez un ID de modèle comme `cartesia/sonic-3-6` ou `minimax/speech-2-8-hd`, AllModels route la requête vers ce fournisseur et vous renvoie l’audio en streaming. Le même concept porte d’autres noms : API d’agrégation TTS, couche d’abstraction de synthèse vocale, ou « OpenRouter de la synthèse vocale ».

### Comment fonctionne AllModels

Chaque modèle du [catalogue TTS d’AllModels](https://allmodels.io/fr/audio/models?type=tts) 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/tts`. Vous envoyez le texte au fur et à mesure qu’il est produit et recevez l’audio sous forme de messages binaires. C’est l’interface temps réel native d’AllModels.
- **Compatible OpenAI** sur `https://api.allmodels.io/oai`. Pointez le SDK OpenAI officiel vers cette URL de base et continuez d’appeler `audio.speech.create`.
- **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 synthèse vocale, streaming compris.

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.

### Un catalogue, une clé, un solde

En tant qu’agrégateur, AllModels vous offre aussi un point unique pour comparer et contrôler les fournisseurs. `GET /v1/models` liste chaque modèle TTS, les fournisseurs qui le servent et son prix pour 1 000 caractères. Lorsqu’un modèle est disponible chez plusieurs fournisseurs, une préférence `provider` permet de choisir : `only` limite la requête aux fournisseurs indiqués, `order` les place en priorité et `ignore` les exclut. La consommation de tous les fournisseurs est débitée d’un seul solde prépayé AllModels, au lieu d’une facture par fournisseur.

### Changez le modèle, gardez tout le reste

Votre clé API, votre endpoint, votre client et votre code de requête restent strictement identiques d’un fournisseur à l’autre. Pour utiliser un autre modèle TTS, changez l’ID du modèle. AllModels s’occupe du reste : il se connecte au fournisseur, gère son API et renvoie l’audio à votre application.

## Streamez 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 ainsi que les valeurs de modèle et de voix à 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/tts`, envoyez le texte au fur et à mesure qu’il est produit et recevez l’audio sous forme de messages binaires. [Guide du 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 natif, streaming — Python · websockets

Client : Natif · Mode : Streaming · Langage : Python

Connectez-vous à `wss://api.allmodels.io/v1/tts`, envoyez le texte au fur et à mesure qu’il est produit et recevez l’audio sous forme de messages binaires. [Guide du 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, requête unique — JavaScript · Node.js · fetch

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

Vous avez déjà le texte complet ? Envoyez-le en POST à `https://api.allmodels.io/oai/audio/speech` et enregistrez le fichier audio. [Documentation 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, requête unique — Python · requests

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

Vous avez déjà le texte complet ? Envoyez-le en POST à `https://api.allmodels.io/oai/audio/speech` et enregistrez le fichier audio. [Documentation 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)
```

### SDK OpenAI, streaming — JavaScript · openai

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

Définissez l’URL de base du SDK OpenAI sur `https://api.allmodels.io/oai` et appelez `audio.speech.create`. L’audio est renvoyé en streaming au fil de sa génération. [Documentation TTS 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"));
```

### SDK OpenAI, streaming — Python · openai

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

Définissez l’URL de base du SDK OpenAI sur `https://api.allmodels.io/oai` et écrivez la réponse en streaming dans un fichier au fil de sa génération. [Documentation TTS 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")
```

### 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 demandez un fichier audio complet. [Documentation TTS 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()));
```

### 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 demandez un fichier audio complet. [Documentation TTS 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")
```

### SDK ElevenLabs, streaming — 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 recevez les blocs audio en streaming au fil de leur génération. [Documentation TTS 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();
```

### SDK ElevenLabs, streaming — Python · elevenlabs

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

Définissez l’URL de base du SDK ElevenLabs sur `https://api.allmodels.io/el`. `convert_realtime` envoie le texte via un WebSocket au fur et à mesure qu’il est produit et renvoie l’audio dès qu’il arrive. [Documentation TTS 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)
```

### 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 convertissez un texte complet en fichier audio. [Documentation TTS 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));
```

### 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 convertissez un texte complet en fichier audio. [Documentation TTS 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)
```

## 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.speech.create`, désormais avec un ID de modèle AllModels. Le streaming comme les requêtes uniques fonctionnent.

- [Lire la documentation TTS OpenAI](https://allmodels.io/audio/docs/openai/text-to-speech)

### 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 convert, stream et realtime, désormais avec un ID de modèle AllModels.

- [Lire la documentation TTS ElevenLabs](https://allmodels.io/audio/docs/elevenlabs/text-to-speech)

## L’essentiel sur les API TTS en temps réel

### Qu’est-ce qu’une API TTS unifiée ?

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

### AllModels prend-il en charge l’audio en temps réel ?

Oui. L’interface native streame en WebSocket sur `/v1/tts`, le SDK Python ElevenLabs envoie le texte en streaming via un WebSocket compatible, et les deux SDK peuvent renvoyer l’audio en streaming en HTTP. 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 voix, se place dans `provider_options` et est transmis tel quel au fournisseur.

### Existe-t-il un OpenRouter pour la synthèse vocale ?

Oui. AllModels fonctionne comme OpenRouter pour la voix : une clé API et un endpoint vous donnent accès aux modèles de synthèse vocale de plusieurs fournisseurs, sélectionnés par leur ID `provider/model`. Il accepte aussi les SDK officiels OpenAI et ElevenLabs : votre code existant n’a besoin que d’une nouvelle URL de base et d’une nouvelle clé.

### En quoi une API d’agrégation TTS diffère-t-elle d’une bibliothèque d’abstraction open source ?

Une bibliothèque d’abstraction open source s’exécute dans votre application et nécessite toujours votre propre compte, votre clé API et votre facturation chez chaque fournisseur qu’elle encapsule. Une API d’agrégation comme AllModels est un service hébergé : une clé et un solde prépayé couvrent tout le [catalogue TTS](https://allmodels.io/fr/audio/models?type=tts), et vous l’appelez avec le SDK OpenAI ou ElevenLabs que vous utilisez déjà, ou en WebSocket.

### Comment comparer les fournisseurs ?

Parcourez le [catalogue TTS](https://allmodels.io/fr/audio/models?type=tts) pour comparer les modèles disponibles, les routes, les tarifs, les langues, les voix 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 TTS dans le [catalogue en direct](https://allmodels.io/fr/audio/models?type=tts) 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 générez.** Streamez en WebSocket pour l’audio en direct, ou demandez un fichier complet en HTTP.

## Commencez avec une seule intégration TTS.

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 TTS](https://allmodels.io/fr/audio/models?type=tts)
- [Lire la documentation AllModels](https://allmodels.io/audio/docs)
- [Voir le guide HTML canonique](https://allmodels.io/fr/guides/universal-tts-api)