Spring til hovedindhold
Dansk— Vælg et sprog
Menu

TTS-API'en: Generering af tale

Lektion 10 af 18 Opdateret 3. november 2026 Udvikler
På denne side
  1. TTS-API’en: Generering af tale
  2. Dit første TTS-kald
  3. Tilgængelige modeller
  4. Output-formater
  5. Generering af lyd i batches
  6. Tegnbegrænsning og opdeling
  7. Efter 6. januar 2027: Få en Realtime-model til at tale
  8. Vigtige pointer

Opdatering 2. november 2026 — Lydmodeller. Flere modeller i dette kursus er udfaset: tts-1, tts-1-hd og gpt-4o-mini-tts lukkes 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-realtime og ældre lydmodeller den 20. januar 2027 (gpt-realtime-2.1, gpt-realtime-2.1-mini, gpt-audio-1.5); whisper-1, gpt-4o-transcribe og /v1/audio/translations den 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 af speech.create() er udfaset af SDK’en („På grund af en fejl streamer denne metode faktisk ikke lyden”) → brug with_streaming_response som i den officielle guide; modeller og stemmer opdateret (gpt-4o-mini-tts og dens stemmeinstruktioner, 13 stemmer inklusive marin og cedar); nyt afsnit om migration til gpt-realtime-2.1-mini fø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.

ModelSpecifikitetStemmer
gpt-4o-mini-ttsAccepterer instruktioner: accent, følelse, intonation, hastighed, tone, hvisken13 stemmer, inklusive marin og cedar, anbefalet for kvalitet
tts-1Lavere ventetid, lavere kvalitet9 stemmer: alloy, ash, coral, echo, fable, onyx, nova, sage, shimmer
tts-1-hdHøjere kvalitet end tts-1, højere ventetidDe 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:

FormatAnvendelse
mp3 (standard)Generel brug
opusInternet-streaming og kommunikation, lav ventetid
aacDigital komprimering, foretrukket af YouTube, Android og iOS
flacTabsfri komprimering, til arkivering
wavUkomprimeret, for at undgå afkodningsomkostninger
pcmRå 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-1 og tts-1-hd lukkes ned den 6. januar 2027; gpt-4o-mini-tts er den eneste, der accepterer stemmeinstruktioner (instructions)
  • Optag lyd med with_streaming_response: stream_to_file() på et almindeligt speech.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