Hoppa till huvudinnehåll
Svenska— Välj ett språk
Meny

WebSocket-arkitekturen för Realtime API

Lektion 1 av 18 Uppdaterad 3 november 2026 Utvecklare
På denna sida
  1. WebSocket-arkitekturen för Realtime API
  2. Tre röstarkitekturer år 2026
  3. WebRTC, WebSocket eller SIP
  4. WebSocket kontra REST: Varför detta val?
  5. Upprätta en WebSocket-anslutning
  6. Arkitektur för Realtime-applikationer
  7. Viktiga punkter

Uppdaterat 2 november 2026 — Ljudmodeller. Flera modeller i denna kurs är avvecklade: tts-1, tts-1-hd och gpt-4o-mini-tts slutar fungera den 6 januari 2027 (ersättning: gpt-realtime-2.1-mini, vilket OpenAI:s TTS-guide anger inte stöds av /v1/audio/speech: migreringen av talgenerering flyttas till Realtime API); gpt-realtime, gpt-4o-realtime och äldre ljudmodeller den 20 januari 2027 (gpt-realtime-2.1, gpt-realtime-2.1-mini, gpt-audio-1.5); whisper-1, gpt-4o-transcribe och /v1/audio/translations den 26 februari 2027 (gpt-transcribe, gpt-live-transcribe, v1/realtime/translations). För full-duplex-röst har GPT-Live 1 funnits tillgängligt i API:t sedan den 10 september 2026. Tillägg 3 november 2026: avsnitt om OpenAI:s tre röstarkitekturer (GPT-Live, Realtime API, bearbetningskedja) och val av transport (WebRTC, WebSocket, SIP), baserat på guiderna Voice agents, Audio and voice och Getting started with the Realtime API; maximal sessionslängd: 60 minuter (Realtime conversations).

WebSocket-arkitekturen för Realtime API

OpenAI:s Realtime API representerar ett fundamentalt paradigmskifte i hur du interagerar med språkmodeller. Till skillnad från traditionella REST-API:er som arbetar i en cykel av förfrågan och svar, använder Realtime API:et WebSocket-protokollet för att upprätta en beständig, dubbelriktad anslutning mellan din applikation och modellen.

Denna arkitektur möjliggör ljudutbyte i realtid: du skickar ljud, modellen bearbetar det och svarar verbalt med låg latens, vilket hoppar över mellanliggande steg för transkribering eller text-till-tal. Detta är en av de grundläggande byggstenarna för konversationsbaserade röstagenter och kärnan i denna kurs.

Tre röstarkitekturer år 2026

Innan du öppnar en WebSocket måste du placera Realtime API:et i sitt sammanhang tillsammans med OpenAI:s andra lösningar. Guiden Voice agents skiljer på tre tillvägagångssätt:

ArkitekturBäst förVarför välja den
GPT-LiveFull-duplex-konversationer med en separat backendRöstmodellen lyssnar medan den talar och delegerar resonemang och verktygsanvändning till en backend du väljer; behåller din befintliga textagent intakt
Realtime APITal, resonemang och verktyg i en enda sessionEn enda modell tolkar ljud, beslutar vad som ska göras och talar svaret
BearbetningskedjaGranulär kontroll över varje stegTranskribering, sedan textagent, sedan talgenerering: du inspekterar eller transformerar text mellan stegen och byter ut varje komponent oberoende

För nya applikationer för röstkonversationer rekommenderar OpenAI:s sida Audio and voice nu att du börjar med GPT-Live. Realtime API:et förblir rätt startpunkt när agenten måste rymmas inom en enda session, vilket stöder användaravbrott, snabba första ljudsvar, naturligt turtagande och direkta verktygsanrop. Bearbetningskedjan fungerar bäst när varje steg måste förbli synligt: att behålla transkript, tillämpa regler innan agenten svarar, eller endast generera röst efter att ha validerat svaret.

Denna kurs fokuserar på Realtime API:et och bearbetningskedjan, vars komponenter (transkribering, talgenerering) behandlas i efterföljande avsnitt.

WebRTC, WebSocket eller SIP

Ditt val av transport beror på var ljudet har sitt ursprung. Enligt dokumentationen: använd WebRTC för ljud i webbläsaren, med en tillfällig klienthemlighet som genereras av din server; WebSocket för ljudpipelines på serversidan; SIP för telefonsamtal. En kontrollanslutning på serversidan låter också en betrodd backend observera och styra en mediasession. Denna lektion detaljerar WebSocket, det enklaste sättet att förstå utbytta händelser; i en webbläsare bör du föredra WebRTC. En Realtime-session varar som mest 60 minuter.

WebSocket kontra REST: Varför detta val?

I en traditionell REST-arkitektur kräver varje interaktion en komplett HTTP-förfrågan: öppna en TCP-anslutning, TLS-förhandling, skicka headers, vänta på svaret och stänga anslutningen. För ljud i realtid är detta överhead förbjudande högt.

Kriterium REST (Responses API) WebSocket (Realtime API)
Latens 200–500 ms per förfrågan < 50 ms efter anslutning
Riktning Endast klient → server Samtidig dubbelriktad
Anslutning Ny för varje förfrågan Beständig (session)
Ljud Hela filen krävs Strömmande bit för bit

WebSocket-protokollet håller en kanal öppen kontinuerligt. När den väl är upprättad kan klient och server skicka meddelanden när som helst utan att vänta på att den andra ska bli klar.

Upprätta en WebSocket-anslutning

Så här upprättar du en anslutning till Realtime API:et 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")

        # Receive the welcome event
        response = await ws.recv()
        event = json.loads(response)
        print(f"Type: {event['type']}")
        # → "session.created"

        # Keep the connection open
        await asyncio.Future()

asyncio.run(connect_realtime())

Anslutnings-URL:en inkluderar modellen som en frågeparameter. Sedan API:et nådde allmän tillgänglighet krävs endast autentiseringsheadern; headern OpenAI-Beta: realtime=v1 från betafasen finns inte längre.

Gränssnitt noterat 5 augusti 2026 — Realtime API:et utvecklas (modeller, händelsenamn, sessionsformat): vid tveksamhet, kontrollera den officiella dokumentationen.

Arkitektur för Realtime-applikationer

En applikation som använder Realtime API:et följer en lagerbaserad arkitektur:

1

Ljudlager (inspelning/uppspelning)

Fångar mikrofonen, spelar upp ljudsvar. Använder PyAudio, sounddevice eller Web Audio API i webbläsaren.

2

WebSocket-lager (transport)

Hanterar den beständiga anslutningen, kodar/avkodar JSON-händelser, hanterar återanslutningar.

3

Applikationslager (affärslogik)

Orkestrerar konversationen, hanterar kontext, anropar verktyg, bearbetar resultat.

4

Serverlager (valfri proxy)

I produktion skyddar en mellanliggande server API-nyckeln och lägger till affärslogik på serversidan.

Proxyserverns roll

Under utveckling kan du ansluta din applikation direkt till Realtime API:et. I produktion är en proxyserver avgörande för att:

  • Skydda din API-nyckel — exponera den aldrig på klientsidan
  • Autentisera dina användare — verifiera token innan sessionen öppnas
  • Kontrollera kostnader — begränsa sessionslängd och tokenanvändning
  • Logga interaktioner — för felsökning och regelefterlevnad
# Simplified example of a WebSocket proxy with 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())

Viktiga punkter

  • Tre röstarkitekturer hos OpenAI: GPT-Live (rekommenderas för nya konversationsappar), Realtime API (tal, resonemang och verktyg i en session) samt kedjan transkribering → agent → syntes
  • WebRTC för ljud i webbläsare, WebSocket för serverpipelines, SIP för telefoni; sessioner varar som mest 60 minuter
  • Realtime API använder WebSocket för dubbelriktad kommunikation med låg latens
  • Anslutningen är beständig: en öppning för hela konversationssessionen
  • Lagerbaserad arkitektur separerar ljud, transport, affärslogik och serverproxy
  • I produktion är en proxyserver avgörande för säkerhet och kostnadskontroll
  • Protokollet är händelsestyrt: varje meddelande är ett JSON-objekt med ett fält type