OpenAI WebSocket API: Echtzeit-Streaming zu 75 % geringeren Kosten

WebSocket streaming ist der schnellste Weg, mit AI-Modellen zu interagieren. Im Gegensatz zu klassischen HTTP-Anfragen oder sogar Server-Sent Events (SSE) hält WebSocket eine persistente, bidirektionale Verbindung zwischen deiner Anwendung und der API aufrecht. Kein Verbindungsaufbau pro Anfrage, kein HTTP-Overhead, keine Half-Duplex-Einschränkungen.

Smart AIPI unterstützt dieses Protokoll jetzt unter wss://api.smartaipi.com/v1/realtime — vollständig kompatibel mit OpenAI's WebSocket API, bei 75 % geringeren Kosten.

Warum WebSocket statt SSE?

Server-Sent Events waren der Standard für AI-streaming, bringen aber Kompromisse mit sich, die WebSocket eliminiert:

Für Agent-Loops mit Dutzenden direkt aufeinanderfolgenden API-Aufrufen sind die kumulierten Latenzeinsparungen durch eine persistente WebSocket-Verbindung erheblich.

So funktioniert es

Die WebSocket API folgt einem eventgesteuerten Protokoll. Du sendest JSON-Events an den Server und erhältst JSON-Events zurück — alles über eine einzige persistente Verbindung.

1. Verbinden und authentifizieren

Öffne eine WebSocket-Verbindung mit deinem API key in den Headern:

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

2. Eine Anfrage senden

Sende ein response.create-Event mit deinem 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. streaming-Events empfangen

Der Server sendet eine Sequenz von Events zurück, während die Antwort generiert wird:

Code-Beispiele

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 (Schnelltest)

Prüfe mit einem einzelnen Befehl, ob der WebSocket-Handshake erfolgreich ist:

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

Eine erfolgreiche Verbindung gibt HTTP/1.1 101 Switching Protocols zurück.

Wann WebSocket statt SSE verwenden

Beide Protokolle funktionieren über Smart AIPI. Wähle je nach Anwendungsfall:

• SSE verwenden für einfache Integrationen, einmalige Anfragen und wenn du die einfachstmögliche Implementierung willst. Setze stream: true bei jedem standardmäßigen API-Aufruf.
• WebSocket verwenden für Agent-Loops, interaktive Anwendungen, hochfrequente Anfrage-Muster und überall dort, wo du die geringstmögliche Latenz zwischen aufeinanderfolgenden Aufrufen brauchst.

Preise

WebSocket-Anfragen werden wie standardmäßige API-Anfragen abgerechnet — nach token-Verbrauch. Der 75%-Rabatt gilt:

Erste Schritte

1. API key holen — Registriere dich auf smartaipi.com (inklusive kostenloser Credits, keine Kreditkarte erforderlich)
2. Verbinden — Öffne einen WebSocket zu wss://api.smartaipi.com/v1/realtime
3. Events senden — Nutze das response.create-Envelope mit deinem Modell und prompt
4. Antworten streamen — Verarbeite response.output_text.delta-Events, sobald sie eintreffen

Wenn du OpenAI's WebSocket API bereits nutzt, ist die einzige Änderung die URL. Alles andere — Authentifizierung, Events, Payload-Format — ist identisch.

Häufig gestellte Fragen

Unterstützt Smart AIPI die OpenAI WebSocket API?

Ja. Verbinde dich mit wss://api.smartaipi.com/v1/realtime und übergib deinen API key im Authorization-Header. Das Protokoll ist vollständig kompatibel mit OpenAI's WebSocket Responses API.

Ist WebSocket schneller als SSE?

Für aufeinanderfolgende Anfragen: ja. WebSocket hält eine persistente Verbindung aufrecht und eliminiert den TCP- und TLS-Handshake-Overhead, der bei SSE bei jeder neuen Anfrage anfällt. Bei einzelnen einmaligen Anfragen ist der Unterschied vernachlässigbar.

Welche Modelle funktionieren über WebSocket?

Alle Modelle, die über die Responses API verfügbar sind: GPT-5.3 Codex, GPT-5.2, Codex Mini und weitere. Gib das Modell im response.create-Event an.

Funktionieren function calling und tool use über WebSocket?

Ja. Der vollständige Funktionsumfang der Responses API ist verfügbar — function calling, tool use, strukturierte Outputs und Multi-Turn-Konversationen funktionieren alle über die WebSocket-Verbindung.

Gibt es ein Zeitlimit für die Verbindung?

Inaktive Verbindungen werden nach 15 Minuten geschlossen. Sende bei Bedarf regelmäßig Nachrichten oder verbinde dich neu. Aktive Verbindungen, die Daten streamen, werden nicht unterbrochen.

Kann ich mehrere Anfragen über eine Verbindung senden?

Ja. Das ist einer der wichtigsten Vorteile. Nachdem eine Antwort abgeschlossen ist, sende einfach ein weiteres response.create-Event über dieselbe Verbindung, ohne dich neu zu verbinden.