Ga naar hoofdinhoud
Nederlands— Kies een taal
Menu

Telefonie-integratie (Twilio, enz.)

Les 15 van 18 Bijgewerkt op 3 november 2026 Ontwikkelaar
Op deze pagina
  1. Telefonie-integratie (Twilio, enz.)
  2. Telefonie-architectuur
  3. Implementatie met Twilio
  4. Alternatieven voor Twilio
  5. Belangrijkste punten

Bijgewerkt op 3 november 2026 op basis van de Realtime API-documentatie: het G.711 μ-law-formaat heet audio/pcmu (de tekst citeerde eerder g711_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-hd en gpt-4o-mini-tts stoppen op 6 januari 2027 (de aangegeven vervanger is gpt-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-realtime en legacy audiomodellen op 20 januari 2027 (gpt-realtime-2.1, gpt-realtime-2.1-mini, gpt-audio-1.5); whisper-1, gpt-4o-transcribe en /v1/audio/translations op 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:

1

Inkomende oproep → Twilio

De gebruiker belt een telefoonnummer. Twilio ontvangt de oproep en stuurt een webhook naar uw server.

2

Uw server → Mediastream

Uw server reageert met TwiML-instructies die een bidirectionele Media Stream WebSocket openen.

3

Mediastream ↔ Realtime API

Uw server relayt audio tussen de Twilio Media Stream en de OpenAI Realtime API.

4

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