Lähe põhisisu juurde
Eesti— Vali keel
Menüü

API TTS : générer de la parole

Õppetund 10 / 18 Värskendatud 3. november 2026 Arendajatele
Sellel lehel
  1. API TTS : générer de la parole
  2. Ton premier appel TTS
  3. Modèles disponibles
  4. Formats de sortie
  5. Générer de l’audio par lots
  6. Limite de caractères et découpage
  7. Après le 6 janvier 2027 : faire parler un modèle Realtime
  8. Peamised punktid

Mise à jour du 2 novembre 2026 — Modèles audio. Plusieurs modèles de ce cours sont dépréciés : tts-1, tts-1-hd et gpt-4o-mini-tts cesseront 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-realtime et 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-transcribe et /v1/audio/translations le 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 de speech.create() est déprécié par le SDK (« En raison d’un bug, cette méthode ne stream pas réellement ») → utilisez with_streaming_response, comme dans le guide officiel ; modèles et voix mis à jour (gpt-4o-mini-tts et ses instructions vocales, 13 voix dont marin et cedar) ; nouvelle section sur la migration vers gpt-realtime-2.1-mini avant le 6 janvier 2027, basée sur le guide Realtime conversations. Sources : Text to speech · Create speech · Realtime conversations · Deprecations.

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 » : tu envoies du texte et tu reçois 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èleSpécificitéVoix
gpt-4o-mini-ttsAccepte des instructions : accent, émotion, intonation, vitesse, ton, chuchotement13 voix, dont marin et cedar, recommandées pour la qualité
tts-1Latence plus faible, qualité inférieure9 voix : alloy, ash, coral, echo, fable, onyx, nova, sage, shimmer
tts-1-hdQualité supérieure à tts-1, latence plus élevéeLes 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 :

FormatUsage
mp3 (par défaut)Usage général
opusStreaming internet et communication, faible latence
aacCompression numérique, préféré par YouTube, Android et iOS
flacCompression sans perte, pour l’archivage
wavNon 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.

Peamised punktid

  • gpt-4o-mini-tts, tts-1 et tts-1-hd cesseront de fonctionner le 6 janvier 2027 ; gpt-4o-mini-tts est le seul à accepter des instructions vocales (instructions)
  • Enregistre l’audio avec with_streaming_response : stream_to_file() sur un speech.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