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.
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 ».
Chaque modèle du catalogue TTS 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 :
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.https://api.allmodels.io/oai. Pointez le SDK OpenAI officiel vers cette URL de base et continuez d’appeler audio.speech.create.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.
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.
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.
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.
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.
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();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.
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())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.
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()));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.
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)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.
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"));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.
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")Définissez l’URL de base du SDK OpenAI sur https://api.allmodels.io/oai et demandez un fichier audio complet. Documentation TTS OpenAI.
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()));Définissez l’URL de base du SDK OpenAI sur https://api.allmodels.io/oai et demandez un fichier audio complet. Documentation TTS OpenAI.
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")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.
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();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.
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)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.
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));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.
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)Interfaces compatibles
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.
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 ElevenLabsRéponses rapides
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.
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.
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.
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é.
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, et vous l’appelez avec le SDK OpenAI ou ElevenLabs que vous utilisez déjà, ou en WebSocket.
Parcourez le catalogue 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.
provider/model.