OpenAI WebSocket API: Real-time streaming tegen 75% lagere kosten

WebSocket streaming is de snelste manier om met AI-modellen te werken. In tegenstelling tot traditionele HTTP-requests of zelfs Server-Sent Events (SSE), houdt WebSocket een persistente, bidirectional verbinding in stand tussen je applicatie en de API. Geen verbindingsopzet per request, geen HTTP-overhead, geen half-duplex beperkingen.

Smart AIPI ondersteunt dit protocol nu op wss://api.smartaipi.com/v1/realtime — volledig compatibel met OpenAI's WebSocket API, tegen 75% lagere kosten.

Waarom WebSocket in plaats van SSE?

Server-Sent Events zijn de standaard geweest voor AI streaming, maar ze hebben nadelen die WebSocket wegneemt:

Voor agent-loops die tientallen API-calls direct achter elkaar doen, zijn de opgetelde latencybesparingen van een persistente WebSocket-verbinding aanzienlijk.

Hoe het werkt

De WebSocket API volgt een event-driven protocol. Je stuurt JSON-events naar de server en ontvangt JSON-events terug — allemaal via één persistente verbinding.

1. Verbinden en authenticeren

Open een WebSocket-verbinding met je API key in de headers:

wss://api.smartaipi.com/v1/realtime
Authorization: Bearer sk-proj-your-smart-aipi-key
OpenAI-Beta: realtime=v1

2. Stuur een request

Stuur een response.create-event met je prompt:

{
  "type": "response.create",
  "response": {
    "model": "gpt-5.3-codex",
    "store": false,
    "instructions": "You are a helpful assistant.",
    "input": [
      {
        "type": "message",
        "role": "user",
        "content": [
          { "type": "input_text", "text": "What is WebSocket?" }
        ]
      }
    ]
  }
}

3. Ontvang streaming-events

De server stuurt een reeks events terug terwijl de response wordt gegenereerd:

Codevoorbeelden

Node.js

import WebSocket from "ws";

const ws = new WebSocket("wss://api.smartaipi.com/v1/realtime", {
  headers: {
    "Authorization": "Bearer sk-proj-your-key",
    "OpenAI-Beta": "realtime=v1",
  },
});

ws.on("open", () => {
  ws.send(JSON.stringify({
    type: "response.create",
    response: {
      model: "gpt-5.3-codex",
      store: false,
      input: [{
        type: "message",
        role: "user",
        content: [{ type: "input_text", text: "Hello!" }],
      }],
    },
  }));
});

ws.on("message", (data) => {
  const event = JSON.parse(data);
  if (event.type === "response.output_text.delta") {
    process.stdout.write(event.delta);
  }
  if (event.type === "response.completed") {
    console.log("\n\nDone. Usage:", event.response.usage);
    ws.close();
  }
});

Python

import asyncio
import json
import websockets

async def main():
    headers = {
        "Authorization": "Bearer sk-proj-your-key",
        "OpenAI-Beta": "realtime=v1",
    }

    async with websockets.connect(
        "wss://api.smartaipi.com/v1/realtime",
        extra_headers=headers,
    ) as ws:
        await ws.send(json.dumps({
            "type": "response.create",
            "response": {
                "model": "gpt-5.3-codex",
                "store": False,
                "input": [{
                    "type": "message",
                    "role": "user",
                    "content": [{"type": "input_text", "text": "Hello!"}],
                }],
            },
        }))

        async for message in ws:
            event = json.loads(message)
            if event["type"] == "response.output_text.delta":
                print(event["delta"], end="", flush=True)
            if event["type"] == "response.completed":
                print(f"\n\nUsage: {event['response']['usage']}")
                break

asyncio.run(main())

cURL (snelle test)

Controleer met één commando of de WebSocket-handshake slaagt:

curl -isN --http1.1 \
  -H "Connection: Upgrade" \
  -H "Upgrade: websocket" \
  -H "Sec-WebSocket-Version: 13" \
  -H "Sec-WebSocket-Key: dGVzdA==" \
  -H "Authorization: Bearer sk-proj-your-key" \
  -H "OpenAI-Beta: realtime=v1" \
  https://api.smartaipi.com/v1/realtime

Een succesvolle verbinding geeft HTTP/1.1 101 Switching Protocols terug.

Wanneer gebruik je WebSocket vs SSE

Beide protocollen werken via Smart AIPI. Kies op basis van je use case:

• Gebruik SSE voor eenvoudige integraties, losse requests en wanneer je de simpelst mogelijke implementatie wilt. Zet stream: true op elke standaard API-call.
• Gebruik WebSocket voor agent-loops, interactieve applicaties, requestpatronen met hoge frequentie en overal waar je de laagst mogelijke latency tussen opeenvolgende calls nodig hebt.

Prijzen

WebSocket-requests worden op dezelfde manier gefactureerd als standaard API-requests — op basis van tokengebruik. De korting van 75% geldt ook hier:

Aan de slag

1. Haal een API key op — Meld je aan op smartaipi.com (inclusief gratis credits, geen creditcard vereist)
2. Verbind — Open een WebSocket naar wss://api.smartaipi.com/v1/realtime
3. Stuur events — Gebruik de response.create-envelope met je model en prompt
4. Stream responses — Verwerk response.output_text.delta-events zodra ze binnenkomen

Als je OpenAI's WebSocket API al gebruikt, is de enige wijziging de URL. Alles daarbuiten — authenticatie, events, payload-formaat — is identiek.

Veelgestelde vragen

Ondersteunt Smart AIPI de OpenAI WebSocket API?

Ja. Maak verbinding met wss://api.smartaipi.com/v1/realtime met je API key in de Authorization-header. Het protocol is volledig compatibel met OpenAI's WebSocket Responses API.

Is WebSocket sneller dan SSE?

Voor opeenvolgende requests wel. WebSocket houdt een persistente verbinding in stand en elimineert daarmee de overhead van de TCP- en TLS-handshake die SSE bij elk nieuw request heeft. Voor losse eenmalige requests is het verschil verwaarloosbaar.

Welke modellen werken via WebSocket?

Alle modellen die beschikbaar zijn via de Responses API: GPT-5.3 Codex, GPT-5.2, Codex Mini en andere. Geef het model op in het response.create-event.

Werken function calling en tool use via WebSocket?

Ja. De volledige feature set van de Responses API is beschikbaar — function calling, tool use, structured outputs en multi-turn gesprekken werken allemaal via de WebSocket-verbinding.

Is er een tijdslimiet voor verbindingen?

Inactieve verbindingen worden na 15 minuten gesloten. Stuur periodiek berichten of maak opnieuw verbinding wanneer nodig. Actieve verbindingen die data streamen worden niet onderbroken.

Kan ik meerdere requests via één verbinding versturen?

Ja. Dat is een van de belangrijkste voordelen. Nadat een response is voltooid, stuur je nog een response.create-event via dezelfde verbinding zonder opnieuw te verbinden.