TTS-API'en: Generering af tale
På denne side
Opdatering 2. november 2026 — Lydmodeller. Flere modeller i dette kursus er udfaset:
tts-1,tts-1-hdoggpt-4o-mini-ttslukkes ned den 6. januar 2027 (efterfølger:gpt-realtime-2.1-mini, som OpenAI TTS-guiden angiver ikke understøttes af/v1/audio/speech: migrationen af talesyntese flyttes til Realtime API);gpt-realtime,gpt-4o-realtimeog ældre lydmodeller den 20. januar 2027 (gpt-realtime-2.1,gpt-realtime-2.1-mini,gpt-audio-1.5);whisper-1,gpt-4o-transcribeog/v1/audio/translationsden 26. februar 2027 (gpt-transcribe,gpt-live-transcribe,v1/realtime/translations). Til fuld-duplex tale har GPT-Live 1 været tilgængelig i API’en siden 10. september 2026. Lektion korrigeret 3. november 2026:response.stream_to_file()på resultatet afspeech.create()er udfaset af SDK’en („På grund af en fejl streamer denne metode faktisk ikke lyden”) → brugwith_streaming_responsesom i den officielle guide; modeller og stemmer opdateret (gpt-4o-mini-ttsog dens stemmeinstruktioner, 13 stemmer inklusivemarinogcedar); nyt afsnit om migration tilgpt-realtime-2.1-minifør 6. januar 2027 baseret på guiden Realtime conversations. Kilder: Text to speech · Create speech · Realtime conversations · Deprecations.
TTS-API’en: Generering af tale
OpenAI’s Text-to-Speech (TTS) API konverterer tekst til lyd af høj kvalitet. I modsætning til Realtime API, der håndterer komplette talesamtaler, er TTS-API’en en „single-shot”-tjeneste: du sender tekst, og du modtager en lydfil. Det er det ideelle værktøj til at generere meddelelser, talemeddelelser, lydbøger eller tilgængeligt indhold.
Dit første TTS-kald
At generere tale er bemærkelsesværdigt simpelt:
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)
API’en returnerer en lydstream, som du kan gemme direkte eller streame til en afspiller. Brug with_streaming_response som vist her: at kalde stream_to_file() på resultatet af et almindeligt speech.create() er udfaset af SDK’en, som bemærker, at det faktisk ikke streamer lyden.
Tilgængelige modeller
De tre Audio API-modeller er udfaset og lukkes ned den 6. januar 2027: dette er overgangsperioden, hvor du stadig vil bruge dem.
| Model | Specifikitet | Stemmer |
|---|---|---|
gpt-4o-mini-tts | Accepterer instruktioner: accent, følelse, intonation, hastighed, tone, hvisken | 13 stemmer, inklusive marin og cedar, anbefalet for kvalitet |
tts-1 | Lavere ventetid, lavere kvalitet | 9 stemmer: alloy, ash, coral, echo, fable, onyx, nova, sage, shimmer |
tts-1-hd | Højere kvalitet end tts-1, højere ventetid | De samme 9 stemmer |
Instruktioner fungerer ikke med tts-1 og tts-1-hd. Parameteren speed, fra 0,25 til 4,0, justerer hastigheden med alle modeller. Ifølge guiden er stemmerne optimeret til engelsk: lyt til dem på fransk på OpenAI.fm før du vælger. OpenAI’s retningslinjer for brug kræver også, at du tydeligt informerer dine brugere om, at stemmen, de hører, er genereret af AI.
Output-formater
API’en producerer seks formater, valgt med response_format:
| Format | Anvendelse |
|---|---|
mp3 (standard) | Generel brug |
opus | Internet-streaming og kommunikation, lav ventetid |
aac | Digital komprimering, foretrukket af YouTube, Android og iOS |
flac | Tabsfri komprimering, til arkivering |
wav | Ukomprimeret, for at undgå afkodningsomkostninger |
pcm | Rå samples ved 24 kHz, 16-bit signed, ingen 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 to convert",
response_format=fmt,
) as response:
response.stream_to_file(f"example.{fmt}")
Til en taleagent bygget på Realtime API er formatet pcm mest bekvemt: dets 24 kHz, 16-bit samples matcher Realtime API’s audio/pcm-format ved 24 kHz.
Generering af lyd i batches
Ved store mængder tekst skal du behandle segmenter parallelt:
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")
Tegnbegrænsning og opdeling
TTS-API’en har en grænse på 4.096 tegn pr. anmodning. Ved længere tekster skal du opdele intelligent:
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
Efter 6. januar 2027: Få en Realtime-model til at tale
OpenAI udpeger gpt-realtime-2.1-mini som erstatning for de tre modeller og advarer: det er ikke en model til endpointet /v1/audio/speech; migrationen ændrer arbejdsgangen. Du går gennem en Realtime-session. Guiden Realtime conversations viser, hvordan du får et svar uden kontekst, hvilket ignorerer samtalen og kun følger dens instruktioner: dette er måden at få den til at sige en given tekst på.
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))
To forskelle i forhold til Audio API er vigtige i produktion. Resultatet er ikke længere garanteret ord-for-ord: en Realtime-model følger en instruktion; den læser ikke en fil op. Sammenlign derfor transskriptionen af det, den sagde, returneret i response.output_audio_transcript.delta, med den forventede tekst, og generér igen, hvis der er uoverensstemmelse. Faktureringen ændres også: den følger Realtime-modellens satser, i tekst- og lyd-tokens, som listed på dens specifikationsark. Endelig forhindrer en afvist nøgle ikke forbindelsen: den ankommer lige efter i en error-begivenhed.
Vigtige pointer
gpt-4o-mini-tts,tts-1ogtts-1-hdlukkes ned den 6. januar 2027;gpt-4o-mini-ttser den eneste, der accepterer stemmeinstruktioner (instructions)- Optag lyd med
with_streaming_response:stream_to_file()på et almindeligtspeech.create()er udfaset - Seks output-formater: MP3, Opus, AAC, FLAC, WAV og rå PCM
- PCM-formatet er ideelt til integration med Realtime API
- Grænse på 4.096 tegn pr. anmodning: opdel lange tekster ved sætningsgrænser
- Batch-behandling med async-klienten fremskynder generering af stort indhold
- Migration sker via en Realtime-session med
gpt-realtime-2.1-mini: kontekstfrit svar, 24 kHz PCM-lyd, transskription til sammenligning med tekst