Die TTS-API: Spracherzeugung

Update vom 2. November 2026 — Audio-Modelle. Mehrere Modelle in diesem Kurs sind veraltet: tts-1, tts-1-hd und gpt-4o-mini-tts werden am 6. Januar 2027 abgeschaltet (Nachfolger: gpt-realtime-2.1-mini, der laut OpenAI-TTS-Leitfaden nicht durch /v1/audio/speech unterstützt wird: Die Migration der Spracherstellung erfolgt über die Realtime API); gpt-realtime, gpt-4o-realtime und veraltete Audio-Modelle am 20. Januar 2027 (gpt-realtime-2.1, gpt-realtime-2.1-mini, gpt-audio-1.5); whisper-1, gpt-4o-transcribe und /v1/audio/translations am 26. Februar 2027 (gpt-transcribe, gpt-live-transcribe, v1/realtime/translations). Für die Voll-Duplex-Stimme ist GPT-Live 1 seit dem 10. September 2026 in der API verfügbar. Lektion korrigiert am 3. November 2026: response.stream_to_file() auf dem Ergebnis von speech.create() ist im SDK veraltet (“Aufgrund eines Bugs strömt diese Methode tatsächlich nicht”) → verwenden Sie with_streaming_response, wie im offiziellen Leitfaden gezeigt; Modelle und Stimmen aktualisiert (gpt-4o-mini-tts und seine Stimmanweisungen, 13 Stimmen einschließlich marin und cedar); neuer Abschnitt zur Migration zu gpt-realtime-2.1-mini vor dem 6. Januar 2027, basierend auf dem Leitfaden Realtime conversations. Quellen: Text-to-Speech · Create speech · Realtime conversations · Deprecations.

Die Text-to-Speech (TTS) API von OpenAI wandelt Text in hochwertige Audioinhalte um. Im Gegensatz zur Realtime API, die vollständige Sprachkonversationen verarbeitet, ist die TTS-API ein Einmal-Dienst: Sie senden Text und erhalten eine Audio-Datei zurück. Sie ist das ideale Werkzeug für die Erstellung von Ankündigungen, Sprachbenachrichtigungen, Hörbüchern oder barrierefreien Inhalten.

Ihr erster TTS-Aufruf

Die Spracherzeugung ist bemerkenswert einfach:

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="Willkommen bei Corsen Academy. "
          "Ihre Schulung zu Voice Agents beginnt jetzt.",
    instructions="Sprechen Sie in einem warmen, gemessenen Ton.",
) as response:
    response.stream_to_file(speech_file)

Die API gibt einen Audio-Stream zurück, den Sie direkt speichern oder an einen Player streamen können. Verwenden Sie with_streaming_response, wie hier gezeigt: Der Aufruf von stream_to_file() auf dem Ergebnis einer einfachen speech.create() ist im SDK veraltet, da das SDK darauf hinweist, dass dabei das Audio nicht tatsächlich gestreamt wird.

Verfügbare Modelle

Die drei Audio-API-Modelle sind veraltet und werden am 6. Januar 2027 abgeschaltet: Dies ist die Übergangsphase, in der Sie diese weiterhin nutzen können.

Modell	Spezifität	Stimmen
`gpt-4o-mini-tts`	Akzeptiert Anweisungen: Akzent, Emotion, Intonation, Geschwindigkeit, Ton, Flüstern	13 Stimmen, einschließlich `marin` und `cedar`, empfohlen für Qualität
`tts-1`	Geringere Latenz, geringere Qualität	9 Stimmen: `alloy`, `ash`, `coral`, `echo`, `fable`, `onyx`, `nova`, `sage`, `shimmer`
`tts-1-hd`	Höhere Qualität als `tts-1`, höhere Latenz	Die gleichen 9 Stimmen

Anweisungen funktionieren nicht mit tts-1 und tts-1-hd. Der Parameter speed, von 0,25 bis 4,0, passt die Geschwindigkeit bei allen Modellen an. Laut dem Leitfaden sind die Stimmen für Englisch optimiert: Hören Sie sie auf OpenAI.fm auf Französisch, bevor Sie sich entscheiden. Die Nutzungsrichtlinien von OpenAI verlangen zudem, dass Sie Ihre Nutzer klar darüber informieren, dass die von ihnen gehörte Stimme durch KI generiert wurde.

Ausgabeformate

Die API erzeugt sechs Formate, die mit response_format ausgewählt werden:

Format	Verwendung
`mp3` (Standard)	Allgemeiner Einsatz
`opus`	Internet-Streaming und Kommunikation, geringe Latenz
`aac`	Digitale Komprimierung, bevorzugt von YouTube, Android und iOS
`flac`	Verlustfreie Komprimierung, für die Archivierung
`wav`	Unkomprimiert, um Decodierungs-Overhead zu vermeiden
`pcm`	Rohdaten bei 24 kHz, 16-Bit vorzeichenbehaftet, ohne Header

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 zum Konvertieren",
        response_format=fmt,
    ) as response:
        response.stream_to_file(f"example.{fmt}")

Für einen Voice Agent, der auf der Realtime API basiert, ist das pcm-Format am praktischsten: Seine 24 kHz, 16-Bit-Abtastwerte entsprechen dem audio/pcm-Format der Realtime API bei 24 kHz.

Audio in Batches erzeugen

Für große Textmengen verarbeiten Sie Segmente parallel:

import asyncio
from openai import AsyncOpenAI

async_client = AsyncOpenAI()

async def generate_speech_batch(segments: list[dict]) -> list[bytes]:
    """Erzeugt Audio für mehrere Segmente 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)

# Verwendung
segments = [
    {"text": "Kapitel eins. Einführung in Voice Agents.", "voice": "onyx"},
    {"text": "Voice Agents transformieren die Mensch-Maschine-Interaktion.", "voice": "onyx"},
    {"text": "In diesem Kapitel werden wir die Grundlagen erkunden.", "voice": "onyx"},
]

audio_chunks = asyncio.run(generate_speech_batch(segments))

# Dateien zusammenfügen
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")

Zeichenlimit und Aufteilen

Die TTS-API hat ein Limit von 4.096 Zeichen pro Anfrage. Bei längeren Texten teilen Sie diese intelligent auf:

def split_text_for_tts(text: str, max_chars: int = 4000) -> list[str]:
    """Teilt Text in Segmente auf, die TTS-Limits respektieren."""
    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

Ab dem 6. Januar 2027: Ein Realtime-Modell sprechen lassen

OpenAI benennt gpt-realtime-2.1-mini als Ersatz für die drei Modelle und warnt: Es ist kein Modell für den Endpunkt /v1/audio/speech; die Migration ändert den Arbeitsablauf. Sie gehen über eine Realtime-Sitzung. Der Leitfaden Realtime conversations zeigt, wie man eine Antwort ohne Kontext erhält, die die Konversation ignoriert und nur den Anweisungen folgt: So lässt man es einen bestimmten Text sagen.

import base64
import json
import os
import wave

import websocket  # pip install websocket-client

TEXT = "Willkommen bei Corsen Academy. Ihre Schulung zu Voice Agents beginnt jetzt."

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']}"],
)

# Nur Audio-Ausgabe, 16-Bit PCM bei 24 kHz, mit gewählter Stimme
ws.send(json.dumps({
    "type": "session.update",
    "session": {
        "type": "realtime",
        "output_modalities": ["audio"],
        "audio": {"output": {"format": {"type": "audio/pcm", "rate": 24000}, "voice": "marin"}},
    },
}))

# Eine kontextfreie Antwort (leerer Input), die den Text wörtlich sagen muss
ws.send(json.dumps({
    "type": "response.create",
    "response": {
        "input": [],
        "output_modalities": ["audio"],
        "instructions": f"Sagen Sie genau folgenden Text, ohne etwas hinzuzufügen:\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("Gesprochener Text:", "".join(transcription))

Zwei Unterschiede zur Audio-API sind in der Produktion relevant. Das Ergebnis ist nicht mehr garantiert wortwörtlich: Ein Realtime-Modell folgt einer Anweisung; es liest keine Datei. Vergleichen Sie daher die Transkription dessen, was es gesagt hat, die in response.output_audio_transcript.delta zurückgegeben wird, mit dem erwarteten Text und regenerieren Sie, falls ein Missstand besteht. Auch die Abrechnung ändert sich: Sie folgt den Sätzen des Realtime-Modells in Text- und Audio-Tokens, die in dessen Spezifikation aufgeführt sind. Schließlich verhindert ein abgelehnter Schlüssel nicht die Verbindung: Er kommt direkt danach in einem error-Event an.

Wichtige Erkenntnisse

gpt-4o-mini-tts, tts-1 und tts-1-hd werden am 6. Januar 2027 abgeschaltet; gpt-4o-mini-tts ist das einzige, das Stimmanweisungen (instructions) akzeptiert
Audio mit with_streaming_response aufnehmen: stream_to_file() auf einer einfachen speech.create() ist veraltet
Sechs Ausgabeformate: MP3, Opus, AAC, FLAC, WAV und rohes PCM
PCM-Format ist ideal für die Integration mit der Realtime API
4.096-Zeichen-Limit pro Anfrage: Teilen Sie lange Texte an Satzgrenzen auf
Batch-Verarbeitung mit dem asynchronen Client beschleunigt die Erzeugung großer Inhalte
Die Migration erfolgt über eine Realtime-Sitzung mit gpt-realtime-2.1-mini: kontextfreie Antwort, PCM-Audio bei 24 kHz, Transkription zum Vergleich mit dem Text