API TTS : Génération de parole
Šajā lapā
Mise à jour du 2 novembre 2026 — Modèles audio. Plusieurs modèles de ce cours sont obsolètes :
tts-1,tts-1-hdetgpt-4o-mini-ttscesseront de fonctionner le 6 janvier 2027 (successeur :gpt-realtime-2.1-mini, que le guide TTS d’OpenAI indique comme non pris en charge par/v1/audio/speech: la migration de la synthèse vocale passe à l’API Realtime) ;gpt-realtime,gpt-4o-realtimeet les anciens modèles audio le 20 janvier 2027 (gpt-realtime-2.1,gpt-realtime-2.1-mini,gpt-audio-1.5) ;whisper-1,gpt-4o-transcribeet/v1/audio/translationsle 26 février 2027 (gpt-transcribe,gpt-live-transcribe,v1/realtime/translations). Pour la voix full-duplex, GPT-Live 1 est disponible dans l’API depuis le 10 septembre 2026. Leçon corrigée le 3 novembre 2026 :response.stream_to_file()sur le résultat despeech.create()est obsolète dans le SDK (« En raison d’un bug, cette méthode ne stream pas réellement ») → utilisezwith_streaming_response, comme dans le guide officiel ; modèles et voix mis à jour (gpt-4o-mini-ttset ses instructions vocales, 13 voix dontmarinetcedar) ; nouvelle section sur la migration versgpt-realtime-2.1-miniavant le 6 janvier 2027, basée sur le guide Realtime conversations. Sources : Text to speech · Create speech · Realtime conversations · Deprecations.
API TTS : Génération de parole
L’API Text-to-Speech (TTS) d’OpenAI convertit du texte en audio haute qualité. Contrairement à l’API Realtime, qui gère des conversations vocales complètes, l’API TTS est un service « one-shot » : vous envoyez du texte et recevez un fichier audio. C’est l’outil idéal pour générer des annonces, des notifications vocales, des livres audio ou du contenu accessible.
Votre premier appel TTS
Générer de la parole est remarquablement simple :
from openai import OpenAI
from pathlib import Path
client = OpenAI()
speech_file = Path("welcome.mp3")
with client.audio.speech.with_streaming_response.create(
model="gpt-4o-mini-tts",
voice="coral",
input="Welcome to Corsen Academy. "
"Your training on voice agents starts now.",
instructions="Speak in a warm, measured tone.",
) as response:
response.stream_to_file(speech_file)
L’API renvoie un flux audio que vous pouvez enregistrer directement ou diffuser vers un lecteur. Utilisez with_streaming_response, comme montré ici : appeler stream_to_file() sur le résultat d’un simple speech.create() est obsolète dans le SDK, qui précise que cela ne stream pas réellement l’audio.
Modèles disponibles
Les trois modèles de l’API Audio sont obsolètes et cesseront de fonctionner le 6 janvier 2027 : c’est la période de transition durant laquelle vous les utiliserez encore.
| Modèle | Spécificité | Voix |
|---|---|---|
gpt-4o-mini-tts | Accepte des instructions : accent, émotion, intonation, vitesse, ton, chuchotement | 13 voix, dont marin et cedar, recommandées pour la qualité |
tts-1 | Latence plus faible, qualité inférieure | 9 voix : alloy, ash, coral, echo, fable, onyx, nova, sage, shimmer |
tts-1-hd | Qualité supérieure à tts-1, latence plus élevée | Les mêmes 9 voix |
Les instructions ne fonctionnent pas avec tts-1 et tts-1-hd. Le paramètre speed, de 0,25 à 4,0, ajuste le débit avec tous les modèles. Selon le guide, les voix sont optimisées pour l’anglais : écoutez-les en français sur OpenAI.fm avant de choisir. Les politiques d’usage d’OpenAI exigent également que vous informiez clairement vos utilisateurs que la voix qu’ils entendent est générée par une IA.
Formats de sortie
L’API produit six formats, sélectionnés via response_format :
| Format | Usage |
|---|---|
mp3 (par défaut) | Usage général |
opus | Streaming internet et communication, faible latence |
aac | Compression numérique, préféré par YouTube, Android et iOS |
flac | Compression sans perte, pour l’archivage |
wav | Non compressé, pour éviter la surcharge de décodage |
pcm | Échantillons bruts à 24 kHz, 16 bits signés, sans en-tête |
for fmt in ("mp3", "opus", "aac", "flac", "wav", "pcm"):
with client.audio.speech.with_streaming_response.create(
model="gpt-4o-mini-tts",
voice="marin",
input="Text to convert",
response_format=fmt,
) as response:
response.stream_to_file(f"example.{fmt}")
Pour un agent vocal construit sur l’API Realtime, le format pcm est le plus pratique : ses échantillons 24 kHz, 16 bits correspondent au format audio/pcm de l’API Realtime à 24 kHz.
Génération d’audio par lots
Pour de grands volumes de texte, traitez les segments en parallèle :
import asyncio
from openai import AsyncOpenAI
async_client = AsyncOpenAI()
async def generate_speech_batch(segments: list[dict]) -> list[bytes]:
"""Generate audio for multiple segments in parallel."""
async def generate_one(segment):
response = await async_client.audio.speech.create(
model="gpt-4o-mini-tts",
voice=segment.get("voice", "alloy"),
input=segment["text"],
response_format="mp3"
)
return await response.aread()
tasks = [generate_one(seg) for seg in segments]
return await asyncio.gather(*tasks)
# Usage
segments = [
{"text": "Chapter one. Introduction to voice agents.", "voice": "onyx"},
{"text": "Voice agents transform human-computer interaction.", "voice": "onyx"},
{"text": "In this chapter, we'll explore the fundamentals.", "voice": "onyx"},
]
audio_chunks = asyncio.run(generate_speech_batch(segments))
# Concatenate files
from pydub import AudioSegment
import io
combined = AudioSegment.empty()
for chunk in audio_chunks:
segment = AudioSegment.from_mp3(io.BytesIO(chunk))
combined += segment
combined.export("chapter_1.mp3", format="mp3")
Limite de caractères et découpage
L’API TTS a une limite de 4 096 caractères par requête. Pour des textes plus longs, découpez intelligemment :
def split_text_for_tts(text: str, max_chars: int = 4000) -> list[str]:
"""Split text into segments respecting TTS limits."""
sentences = text.replace(". ", ".\n").split("\n")
segments = []
current = ""
for sentence in sentences:
if len(current) + len(sentence) + 1 > max_chars:
if current:
segments.append(current.strip())
current = sentence
else:
current += " " + sentence if current else sentence
if current:
segments.append(current.strip())
return segments
Après le 6 janvier 2027 : faire parler un modèle Realtime
OpenAI désigne gpt-realtime-2.1-mini comme remplaçant des trois modèles et prévient : ce n’est pas un modèle pour le point de terminaison /v1/audio/speech ; la migration change le flux de travail. Vous passez par une session Realtime. Le guide Realtime conversations montre comment obtenir une réponse sans contexte, qui ignore la conversation et suit uniquement ses instructions : c’est la façon de lui faire dire un texte donné.
import base64
import json
import os
import wave
import websocket # pip install websocket-client
TEXT = "Welcome to Corsen Academy. Your training on voice agents starts now."
ws = websocket.WebSocket()
ws.connect(
"wss://api.openai.com/v1/realtime?model=gpt-realtime-2.1-mini",
header=[f"Authorization: Bearer {os.environ['OPENAI_API_KEY']}"],
)
# Audio output only, 16-bit PCM at 24 kHz, with chosen voice
ws.send(json.dumps({
"type": "session.update",
"session": {
"type": "realtime",
"output_modalities": ["audio"],
"audio": {"output": {"format": {"type": "audio/pcm", "rate": 24000}, "voice": "marin"}},
},
}))
# A context-free response (empty input), which must say the text as-is
ws.send(json.dumps({
"type": "response.create",
"response": {
"input": [],
"output_modalities": ["audio"],
"instructions": f"Say exactly the following text, without adding anything:\n{TEXT}",
},
}))
audio, transcription = bytearray(), []
while True:
event = json.loads(ws.recv())
if event["type"] == "response.output_audio.delta":
audio += base64.b64decode(event["delta"])
elif event["type"] == "response.output_audio_transcript.delta":
transcription.append(event["delta"])
elif event["type"] == "error":
raise RuntimeError(event["error"]["message"])
elif event["type"] == "response.done":
break
ws.close()
with wave.open("welcome.wav", "wb") as wav:
wav.setnchannels(1)
wav.setsampwidth(2) # 16 bits
wav.setframerate(24000)
wav.writeframes(bytes(audio))
print("Spoken text:", "".join(transcription))
Deux différences avec l’API Audio comptent en production. Le résultat n’est plus garanti mot pour mot : un modèle Realtime suit une instruction ; il ne lit pas un fichier. Comparez donc la transcription de ce qu’il a dit, renvoyée dans response.output_audio_transcript.delta, au texte attendu, et régénérez en cas d’écart. La facturation change aussi : elle suit les tarifs du modèle Realtime, en jetons texte et audio, listés sur sa fiche technique. Enfin, une clé rejetée n’empêche pas la connexion : elle arrive juste après, dans un événement error.
Galvenās atziņas
gpt-4o-mini-tts,tts-1ettts-1-hdcesseront de fonctionner le 6 janvier 2027 ;gpt-4o-mini-ttsest le seul à accepter des instructions vocales (instructions)- Enregistrez l’audio avec
with_streaming_response:stream_to_file()sur un simplespeech.create()est obsolète - Six formats de sortie : MP3, Opus, AAC, FLAC, WAV et PCM brut
- Le format PCM est idéal pour l’intégration avec l’API Realtime
- Limite de 4 096 caractères par requête : découpez les longs textes aux limites des phrases
- Le traitement par lots avec le client asynchrone accélère la génération de grands contenus
- La migration passe par une session Realtime avec
gpt-realtime-2.1-mini: réponse sans contexte, audio PCM 24 kHz, transcription à comparer au texte