L'API TTS : générer de la parole
Šiame puslapyje
Mise à jour du 2 novembre 2026 — Modèles audio. Plusieurs modèles de ce cours sont dépréciés :
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 en 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 déprécié par 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.
L’API TTS : générer de la 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.
Ton 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 tu peux enregistrer directement ou diffuser vers un lecteur. Utilise with_streaming_response, comme montré ici : appeler stream_to_file() sur le résultat d’un speech.create() simple est déprécié par 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 dépréciés et cesseront de fonctionner le 6 janvier 2027 : c’est la période de transition durant laquelle tu les utiliseras 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 : écoute-les en français sur OpenAI.fm avant de choisir. Les politiques d’usage d’OpenAI t’obligent aussi à informer clairement tes 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érer de l’audio par lots
Pour de gros volumes de texte, traite 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écoupe 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. Tu passes par une session Realtime. Le guide Realtime conversations montre comment obtenir une réponse sans contexte, qui ignore la conversation et suit seulement 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. Compare donc la transcription de ce qu’il a dit, renvoyée dans response.output_audio_transcript.delta, au texte attendu, et régénère 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.
Svarbiausi punktai
gpt-4o-mini-tts,tts-1ettts-1-hdcesseront de fonctionner le 6 janvier 2027 ;gpt-4o-mini-ttsest le seul à accepter les instructions vocales (instructions)- Enregistre l’audio avec
with_streaming_response:stream_to_file()sur unspeech.create()simple est déprécié - 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écoupe les longs textes aux limites des phrases
- Le traitement par lots avec le client asynchrone accélère la génération de gros 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