Telefonie-integratie (Twilio, enz.)
Op deze pagina
Bijgewerkt op 3 november 2026 op basis van de Realtime API-documentatie: het G.711 μ-law-formaat heet
audio/pcmu(de tekst citeerde eerderg711_ulaw, wat de bètanaam was). Bron: Realtime API.
Update 2 november 2026 — Audiomodellen. Verschillende modellen in deze cursus zijn verouderd:
tts-1,tts-1-hdengpt-4o-mini-ttsstoppen op 6 januari 2027 (de aangegeven vervanger isgpt-realtime-2.1-mini, waarvan de OpenAI TTS-gids stelt dat deze niet wordt ondersteund door/v1/audio/speech: migratie van spraaksynthese moet via 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.
Telefonie-integratie (Twilio, enz.)
Een voice-agent wordt pas echt nuttig wanneer deze telefonisch bereikbaar is. Cloudtelefonieplatforms zoals Twilio, LiveKit en Daily stellen u in staat de Realtime API te verbinden met het wereldwijde telefoonnetwerk. Een gebruiker belt een nummer en uw agent neemt in realtime op.
Telefonie-architectuur
Telefonie-integratie voegt een laag toe tussen het telefoonnetwerk en de Realtime API:
Inkomende oproep → Twilio
De gebruiker belt een telefoonnummer. Twilio ontvangt de oproep en stuurt een webhook naar uw server.
Uw server → Mediastream
Uw server reageert met TwiML-instructies die een bidirectionele Media Stream WebSocket openen.
Mediastream ↔ Realtime API
Uw server relayt audio tussen de Twilio Media Stream en de OpenAI Realtime API.
Spraakrespons → Gebruiker
De responsaudio van de Realtime API wordt via Twilio teruggestuurd naar de telefoon van de gebruiker.
Implementatie met Twilio
Webhook voor inkomende oproepen
Wanneer een oproep binnenkomt, stuurt Twilio een HTTP-verzoek naar uw server. U reageert met TwiML die een Media Stream opent:
from fastapi import FastAPI, Request
from fastapi.responses import Response
app = FastAPI()
@app.post("/incoming-call")
async def incoming_call(request: Request):
"""Twilio-webhook voor inkomende oproepen."""
twiml = """<?xml version="1.0" encoding="UTF-8"?>
<Response>
<Say language="en-US">
Welcome to Corsen AI. Connecting you to your voice assistant.
</Say>
<Connect>
<Stream url="wss://your-server.com/media-stream">
<Parameter name="caller" value="{caller_number}" />
</Stream>
</Connect>
</Response>"""
form_data = await request.form()
caller = form_data.get("From", "unknown")
twiml = twiml.replace("{caller_number}", caller)
return Response(content=twiml, media_type="application/xml")
De brug tussen Mediastream en Realtime API
De WebSocket-server ontvangt audio van Twilio en relayt deze naar de Realtime API:
from fastapi import WebSocket
import websockets
import json
import base64
import audioop
import asyncio
OPENAI_API_KEY = "sk-..."
REALTIME_URL = "wss://api.openai.com/v1/realtime?model=gpt-realtime-2.1"
@app.websocket("/media-stream")
async def media_stream(twilio_ws: WebSocket):
"""Brug tussen Twilio Media Stream en de Realtime API."""
await twilio_ws.accept()
# Verbinden met de Realtime API
headers = {
"Authorization": f"Bearer {OPENAI_API_KEY}"
}
async with websockets.connect(REALTIME_URL, additional_headers=headers) as openai_ws:
await openai_ws.recv() # session.created
# De sessie configureren
await openai_ws.send(json.dumps({
"type": "session.update",
"session": {
"type": "realtime",
"output_modalities": ["audio"],
"instructions": "You are a phone assistant. "
"Respond in English, concisely.",
"audio": {
"input": {
"format": {"type": "audio/pcmu"},
"turn_detection": {
"type": "server_vad",
"threshold": 0.5,
"silence_duration_ms": 600
}
},
"output": {
"format": {"type": "audio/pcmu"},
"voice": "marin"
}
}
}
}))
await openai_ws.recv()
stream_sid = None
async def twilio_to_openai():
nonlocal stream_sid
async for message in twilio_ws.iter_text():
data = json.loads(message)
if data["event"] == "media":
audio_b64 = data["media"]["payload"]
await openai_ws.send(json.dumps({
"type": "input_audio_buffer.append",
"audio": audio_b64
}))
elif data["event"] == "start":
stream_sid = data["start"]["streamSid"]
async def openai_to_twilio():
async for message in openai_ws:
event = json.loads(message)
if event["type"] == "response.output_audio.delta":
await twilio_ws.send_json({
"event": "media",
"streamSid": stream_sid,
"media": {
"payload": event["delta"]
}
})
await asyncio.gather(twilio_to_openai(), openai_to_twilio())
G.711-audioformaat
Telefonie gebruikt het G.711 μ-law-formaat (8 kHz, één byte per sample). De Realtime API ondersteunt dit native onder de naam audio/pcmu, die u zowel voor input als output declareert (audio.input.format en audio.output.format, zoals in de bovenstaande code). Dit voorkomt conversie aan de serverzijde. De naam g711_ulaw behoorde tot de API-bèta; het A-law-equivalent heet audio/pcma.
Alternatieven voor Twilio
| Platform | Sterkte | Integratie Realtime API |
|---|---|---|
| Twilio | Compleet ecosysteem, nummers in 100+ landen | Native WebSocket Media Streams |
| LiveKit | Open source, lage latentie, WebRTC | Officiële OpenAI-plug-in |
| Daily | Eenvoudig, gehost, goed voor prototyping | Pipecat SDK met Realtime-connector |
Belangrijkste punten
- Twilio Media Streams stelt u in staat een telefoongesprek te verbinden met een bidirectionele WebSocket
- Uw server fungeert als brug tussen de Twilio Media Stream en de OpenAI Realtime API
- Het G.711 μ-law-formaat is native aan telefonie en wordt direct ondersteund door de Realtime API
- LiveKit (open source, WebRTC) en Daily (gehost) zijn levensvatbare alternatieven voor Twilio
- De architectuur is altijd hetzelfde: telefonie → uw server → Realtime API