Real-time audiostreaming
Op deze pagina
Update 2 november 2026 — Audiomodellen. Verschillende modellen in deze cursus zijn verouderd:
tts-1,tts-1-hdengpt-4o-mini-ttsstoppen op 6 januari 2027 (opvolger:gpt-realtime-2.1-mini, waarvan de OpenAI TTS-gids aangeeft dat deze niet wordt ondersteund door/v1/audio/speech: de migratie van spraaksynthese verschuift naar de Realtime API);gpt-realtime,gpt-4o-realtimeen legacy audiomodellen op 20 januari 2027 (gpt-realtime-2.1,gpt-realtime-2.1-mini,gpt-audio-1.5);whisper-1,gpt-4o-transcribeen/v1/audio/translationsop 26 februari 2027 (gpt-transcribe,gpt-live-transcribe,v1/realtime/translations). Voor full-duplex spraak is GPT-Live 1 beschikbaar in de API sinds 10 september 2026. Bijgewerkt 3 november 2026: De LLM → TTS-pipeline verwerkte eerder elke gebeurtenis met eendelta-veld, inclusief argumenten voor functieaanroepen of redeneringssamenvattingen; nu filtert deze strikt opresponse.output_text.delta, de daadwerkelijke responstekst.
Real-time audiostreaming
Bij een spraakagent introduceert het wachten op het genereren van het volledige audiobestand voordat het afspelen begint, een onaanvaardbare latentie. Met TTS-streaming kunt u beginnen met afspelen zodra de eerste bytes binnenkomen, waardoor de tijd tot de eerste respons terugloopt tot enkele honderden milliseconden.
Streamen met de TTS-API
De TTS-API ondersteunt streaming native. In plaats van te wachten op het volledige bestand, ontvangt u audio in chunks:
from openai import OpenAI
import pyaudio
client = OpenAI()
def stream_tts_to_speaker(text: str, voice: str = "alloy"):
"""Genereer en speel audio af in streaming-modus."""
# Initialiseer de audiospeler
pa = pyaudio.PyAudio()
player = pa.open(
format=pyaudio.paInt16,
channels=1,
rate=24000,
output=True
)
try:
# Maak de streaming-respons
with client.audio.speech.with_streaming_response.create(
model="tts-1",
voice=voice,
input=text,
response_format="pcm" # Ruwe PCM voor directe weergave
) as response:
# Lees en speel chunk voor chunk af
for chunk in response.iter_bytes(chunk_size=4096):
player.write(chunk)
finally:
player.stop_stream()
player.close()
pa.terminate()
stream_tts_to_speaker("Hello, here is a real-time streaming response.")
Het pcm-formaat is ideaal voor streaming omdat er geen decodering nodig is: de ruwe bytes zijn direct klaar voor afspelen.
Latentie meten
Time to First Byte (TTFB) is de belangrijkste metriek voor streamingprestaties:
import time
def measure_tts_latency(text: str, voice: str = "alloy") -> dict:
"""Meet TTS-streaminglatenties."""
start_time = time.time()
first_byte_time = None
total_bytes = 0
with client.audio.speech.with_streaming_response.create(
model="tts-1",
voice=voice,
input=text,
response_format="pcm"
) as response:
for chunk in response.iter_bytes(chunk_size=4096):
if first_byte_time is None:
first_byte_time = time.time()
total_bytes += len(chunk)
end_time = time.time()
return {
"ttfb_ms": round((first_byte_time - start_time) * 1000),
"total_ms": round((end_time - start_time) * 1000),
"total_bytes": total_bytes,
"audio_duration_s": round(total_bytes / (24000 * 2), 2)
}
metrics = measure_tts_latency("Hello, how are you?")
print(f"TTFB: {metrics['ttfb_ms']}ms, Total: {metrics['total_ms']}ms")
Asynchroon streamen
Voor servertoepassingen gebruikt u de asynchrone client:
from openai import AsyncOpenAI
import asyncio
async_client = AsyncOpenAI()
async def stream_tts_async(text: str, voice: str = "alloy"):
"""Asynchrone TTS-streaming voor servers."""
chunks = []
async with async_client.audio.speech.with_streaming_response.create(
model="tts-1",
voice=voice,
input=text,
response_format="pcm"
) as response:
async for chunk in response.iter_bytes(chunk_size=4096):
chunks.append(chunk)
# Hier zou u de chunk via WebSocket naar de client sturen
yield chunk
# Gebruik in een FastAPI-server
from fastapi import FastAPI
from fastapi.responses import StreamingResponse
app = FastAPI()
@app.get("/tts/stream")
async def tts_stream(text: str, voice: str = "alloy"):
return StreamingResponse(
stream_tts_async(text, voice),
media_type="audio/pcm"
)
Pre-fill buffer
Om vloeiende weergave zonder hiaten te garanderen, bouwt u eerst een kleine buffer op voordat u begint:
async def buffered_tts_playback(
text: str,
voice: str = "alloy",
buffer_size: int = 3 # Aantal chunks om vooraf te laden
):
"""TTS-weergave met een pre-fill buffer."""
pa = pyaudio.PyAudio()
player = pa.open(
format=pyaudio.paInt16,
channels=1,
rate=24000,
output=True
)
buffer = []
playback_started = False
try:
async with async_client.audio.speech.with_streaming_response.create(
model="tts-1",
voice=voice,
input=text,
response_format="pcm"
) as response:
async for chunk in response.iter_bytes(chunk_size=4096):
buffer.append(chunk)
if not playback_started and len(buffer) >= buffer_size:
playback_started = True
# Leeg de initiële buffer
for buffered_chunk in buffer:
player.write(buffered_chunk)
buffer.clear()
elif playback_started:
player.write(chunk)
# Speel resterende chunks af
for remaining in buffer:
player.write(remaining)
finally:
player.stop_stream()
player.close()
pa.terminate()
Integratie met een LLM + TTS-pipeline
In een niet-Realtime spraakagent kunt u LLM-streaming combineren met TTS-streaming:
async def llm_to_tts_pipeline(user_message: str):
"""Pipeline: Streaming LLM → Real-time streaming TTS."""
# Fase 1: Accumuleer LLM-respons per zin
sentence_buffer = ""
stream = client.responses.create(
model="gpt-5.6-luna",
input=[{"role": "user", "content": user_message}],
stream=True
)
for event in stream:
# Alleen responstekst moet worden uitgesproken
if event.type == "response.output_text.delta":
sentence_buffer += event.delta
# Detecteer einde van zin
if sentence_buffer.rstrip().endswith((".", "!", "?")):
sentence = sentence_buffer.strip()
sentence_buffer = ""
# Fase 2: Stream deze zin naar TTS
stream_tts_to_speaker(sentence)
# Verwerk resterende buffer
if sentence_buffer.strip():
stream_tts_to_speaker(sentence_buffer.strip())
Belangrijkste punten
- TTS-streaming reduceert TTFB tot enkele honderden milliseconden door het afspelen te starten voordat de generatie voltooid is
- Het
pcm-formaat is optimaal voor streaming: geen decodering vereist, directe weergave - Een pre-fill buffer van 2–3 chunks voorkomt hiaten aan het begin van de weergave
- De asynchrone client is essentieel voor servers die meerdere gelijktijdige verbindingen afhandelen
- Het combineren van streaming LLM en streaming TTS maakt een responsieve spraakagent mogelijk zonder de Realtime API