Pāriet uz galveno saturu
Latviešu— Izvēlēties valodu
Izvēlne

API TTS : Génération de parole

Nodarbība 10 no 18 Atjaunota 2026. gada 3. novembris Programmētājs
Šajā lapā
  1. API TTS : Génération de parole
  2. Votre premier appel TTS
  3. Modèles disponibles
  4. Formats de sortie
  5. Génération d’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. Galvenās atziņas

Mise à jour du 2 novembre 2026 — Modèles audio. Plusieurs modèles de ce cours sont obsolètes : 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 obsolète dans 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é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è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 : é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 :

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