WebSocket-arkitekturen for Realtime API
På denne side
Opdateret 2. november 2026 — Lydmodeller. Flere modeller i dette kursus er udfaset:
tts-1,tts-1-hdoggpt-4o-mini-ttsophører med at fungere den 6. januar 2027 (erstatning:gpt-realtime-2.1-mini, som OpenAI’s TTS-guide angiver ikke understøttes af/v1/audio/speech: migrationen af talesyntese flytter 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. Tillæg 3. november 2026: afsnit om OpenAI’s tre stemmearkitekturer (GPT-Live, Realtime API, behandlingskæde) og valg af transport (WebRTC, WebSocket, SIP), baseret på guiderne Voice agents, Audio and voice og Getting started with the Realtime API; maksimal sessionsvarighed: 60 minutter (Realtime conversations).
WebSocket-arkitekturen for Realtime API
OpenAI’s Realtime API repræsenterer et fundamentalt paradigmeskift i måden, du interagerer med sprogmodeller på. I modsætning til traditionelle REST-API’er, der opererer på en anmodning-svar-cyklus, bruger Realtime API WebSocket-protokollen til at etablere en vedvarende, todvejsforbindelse mellem din applikation og modellen.
Denne arkitektur muliggør udveksling af lyd i realtid: Du sender lyd, modellen behandler den og svarer verbalt med lav latency, hvor den springer mellemtrin som transskription eller tekst-til-tale over. Dette er en af de centrale byggesten for konversationelle taleagenter og kernen i dette kursus.
Tre stemmearkitekturer i 2026
Før du åbner en WebSocket, skal du placere Realtime API i kontekst sammen med OpenAI’s andre løsninger. Guiden Voice agents skelner mellem tre tilgange:
| Arkitektur | Bedst til | Hvorfor vælge den |
|---|---|---|
| GPT-Live | Fuld-duplex samtaler med en separat backend | Stemmemodellen lytter, mens den taler, og delegerer ræsonnement og værktøjsbrug til en backend efter dit valg; bevarer din eksisterende tekstagent intakt |
| Realtime API | Tale, ræsonnement og værktøjer i én session | En enkelt model fortolker lyd, beslutter hvad der skal gøres, og taler svaret |
| Behandlingskæde | Granulær kontrol over hvert trin | Transskription, derefter tekstagent, derefter talesyntese: Du inspicerer eller transformerer tekst mellem trinene og udskifter hver komponent uafhængigt |
Til nye applikationer med talekonversationer anbefaler OpenAI’s side Audio and voice nu at starte med GPT-Live. Realtime API forbliver det rigtige udgangspunkt, når agenten skal passe ind i én enkelt session, der understøtter brugerafbrydelser, hurtigt første lydsvar, naturlig turtagning og direkte værktøjskald. Behandlingskæden fungerer bedst, når hvert trin skal forblive synligt: bevarelse af transskripter, håndhævelse af regler før agenten svarer, eller udsendelse af tale først efter validering af svaret.
Dette kursus fokuserer på Realtime API og behandlingskæden, hvis komponenter (transskription, talesyntese) dækkes i efterfølgende afsnit.
WebRTC, WebSocket eller SIP
Dit valg af transport afhænger af, hvor lyden stammer fra. Ifølge dokumentationen: Brug WebRTC til browserlyd med en ephemeral klientnøgle genereret af din server; WebSocket til lyd-pipelines på serversiden; SIP til telefonopkald. En kontrolforbindelse på serversiden tillader også en betroet backend at observere og styre en mediesession. Denne lektion detaljerer WebSocket, som er den enkleste måde at forstå udvekslede begivenheder på; i en browser bør du foretrække WebRTC. En Realtime-session varer højst 60 minutter.
WebSocket kontra REST: Hvorfor dette valg?
I en traditionel REST-arkitektur kræver hver interaktion en komplet HTTP-anmodning: åbning af en TCP-forbindelse, TLS-forhandling, sending af headers, venten på svaret og lukning af forbindelsen. Til lyd i realtid er dette overhead uacceptabelt.
| Kriterium | REST (Responses API) | WebSocket (Realtime API) |
|---|---|---|
| Latency | 200–500 ms pr. anmodning | < 50 ms efter forbindelse |
| Retning | Kun klient → server | Samtidig todvejs |
| Forbindelse | Ny til hver anmodning | Vedvarende (session) |
| Lyd | Hele filen kræves | Streaming blok for blok |
WebSocket-protokollen holder en kanal åbent kontinuerligt. Når den først er etableret, kan klient og server sende beskeder når som helst uden at vente på, at den anden part bliver færdig.
Etablering af en WebSocket-forbindelse
Sådan etablerer du en forbindelse til Realtime API i Python:
import asyncio
import websockets
import json
OPENAI_API_KEY = "sk-..."
URL = "wss://api.openai.com/v1/realtime?model=gpt-realtime-2.1"
async def connect_realtime():
headers = {
"Authorization": f"Bearer {OPENAI_API_KEY}"
}
async with websockets.connect(URL, additional_headers=headers) as ws:
print("Connected to Realtime API")
# Modtag velkomstbegivenheden
response = await ws.recv()
event = json.loads(response)
print(f"Type: {event['type']}")
# → "session.created"
# Hold forbindelsen åben
await asyncio.Future()
asyncio.run(connect_realtime())
Forbindelses-URL’en inkluderer modellen som en query-parameter. Siden API’en nåede general availability, er kun autentificeringsheadern påkrævet – headern OpenAI-Beta: realtime=v1 fra beta-fasen er fjernet.
Grænseflade noteret 5. august 2026 — Realtime API udvikler sig (modeller, begivenhedsnavne, sessionsformat): Når du er i tvivl, så tjek den officielle dokumentation.
Arkitektur for Realtime-applikationer
En applikation, der bruger Realtime API, følger en lagdelt arkitektur:
Lyd-lag (optagelse/afspilning)
Optager mikrofonen, afspiller lydsvar. Bruger PyAudio, sounddevice eller Web Audio API i browseren.
WebSocket-lag (transport)
Håndterer den vedvarende forbindelse, encoder/decoder JSON-begivenheder, håndterer genforbindelser.
Applikations-lag (forretningslogik)
Orkestrerer samtalen, håndterer kontekst, kalder værktøjer, behandler resultater.
Server-lag (valgfri proxy)
I produktion beskytter en mellemliggende server API-nøglen og tilføjer forretningslogik på serversiden.
Proxy-serverens rolle
Under udvikling kan du forbinde din applikation direkte til Realtime API. I produktion er en proxy-server essentiel for at:
- Beskytte din API-nøgle — eksponér den aldrig på klientsiden
- Autentificere dine brugere — verificér tokens før åbning af sessionen
- Kontrollere omkostninger — begræns sessionsvarighed og token-forbrug
- Logge interaktioner — til fejlfinding og overholdelse af regler
# Forenklet eksempel på en WebSocket-proxy med FastAPI
from fastapi import FastAPI, WebSocket
import websockets
app = FastAPI()
@app.websocket("/ws/realtime")
async def proxy_realtime(client_ws: WebSocket):
await client_ws.accept()
headers = {"Authorization": f"Bearer {OPENAI_API_KEY}"}
async with websockets.connect(URL, additional_headers=headers) as openai_ws:
async def forward_to_openai():
async for message in client_ws.iter_text():
await openai_ws.send(message)
async def forward_to_client():
async for message in openai_ws:
await client_ws.send_text(message)
await asyncio.gather(forward_to_openai(), forward_to_client())
Vigtige pointer
- Tre stemmearkitekturer hos OpenAI: GPT-Live (anbefalet til nye konversations-apps), Realtime API (tale, ræsonnement og værktøjer i én session) og kæden transskription → agent → syntese
- WebRTC til browserlyd, WebSocket til server-pipelines, SIP til telefoni; sessioner varer højst 60 minutter
- Realtime API bruger WebSocket til todvejskommunikation med lav latency
- Forbindelsen er vedvarende: én åbning for hele konversationssessionen
- Lagdelt arkitektur adskiller lyd, transport, forretningslogik og server-proxy
- I produktion er en proxy-server essentiel for sikkerhed og omkostningskontrol
- Protokollen er begivenhedsdrevet: hver besked er et JSON-objekt med et
type-felt