OpenAI WebSocket API: streaming w czasie rzeczywistym przy koszcie niższym o 75%

WebSocket streaming to najszybszy sposób interakcji z modelami AI. W przeciwieństwie do tradycyjnych żądań HTTP, a nawet Server-Sent Events (SSE), WebSocket utrzymuje trwałe, dwukierunkowe połączenie między Twoją aplikacją a API. Bez zestawiania połączenia dla każdego żądania, bez narzutu HTTP, bez ograniczeń half-duplex.

Smart AIPI obsługuje teraz ten protokół pod adresem wss://api.smartaipi.com/v1/realtime — w pełni zgodny z OpenAI WebSocket API i tańszy o 75%.

Dlaczego WebSocket zamiast SSE?

Server-Sent Events były standardem dla AI streaming, ale wiążą się z kompromisami, które WebSocket eliminuje:

Dla pętli agentów wykonujących dziesiątki kolejnych wywołań API oszczędności opóźnień wynikające z trwałego połączenia WebSocket są znaczące.

Jak to działa

WebSocket API używa protokołu sterowanego zdarzeniami. Wysyłasz zdarzenia JSON do serwera i odbierasz zdarzenia JSON w odpowiedzi — wszystko przez jedno trwałe połączenie.

1. Połącz się i uwierzytelnij

Otwórz połączenie WebSocket z API key w nagłówkach:

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

2. Wyślij żądanie

Wyślij zdarzenie response.create ze swoim 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. Odbieraj zdarzenia streaming

Serwer odsyła sekwencję zdarzeń podczas generowania odpowiedzi:

Przykłady kodu

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 (szybki test)

Sprawdź, czy handshake WebSocket kończy się powodzeniem, jednym poleceniem:

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

Pomyślne połączenie zwraca HTTP/1.1 101 Switching Protocols.

Kiedy używać WebSocket, a kiedy SSE

Oba protokoły działają przez Smart AIPI. Wybór zależy od Twojego przypadku użycia:

• Użyj SSE dla prostych integracji, jednorazowych żądań i wtedy, gdy chcesz najprostszą możliwą implementację. Ustaw stream: true w dowolnym standardowym wywołaniu API.
• Użyj WebSocket dla pętli agentów, aplikacji interaktywnych, wzorców żądań o wysokiej częstotliwości i wszędzie tam, gdzie potrzebujesz możliwie najniższego opóźnienia między kolejnymi wywołaniami.

Cennik

Żądania WebSocket są rozliczane tak samo jak standardowe żądania API — według zużycia token. Obniżka 75% dotyczy:

Pierwsze kroki

1. Zdobądź API key — Zarejestruj się na smartaipi.com (darmowe kredyty w zestawie, karta kredytowa nie jest wymagana)
2. Połącz się — Otwórz WebSocket do wss://api.smartaipi.com/v1/realtime
3. Wysyłaj zdarzenia — Użyj obiektu response.create z modelem i prompt
4. Streamuj odpowiedzi — Przetwarzaj zdarzenia response.output_text.delta w momencie ich nadejścia

Jeśli już używasz OpenAI WebSocket API, jedyną zmianą jest URL. Wszystko inne — uwierzytelnianie, zdarzenia, format payload — pozostaje identyczne.

Najczęściej zadawane pytania

Czy Smart AIPI obsługuje OpenAI WebSocket API?

Tak. Połącz się z wss://api.smartaipi.com/v1/realtime, używając swojego API key w nagłówku Authorization. Protokół jest w pełni zgodny z OpenAI WebSocket Responses API.

Czy WebSocket jest szybszy niż SSE?

Dla kolejnych żądań tak. WebSocket utrzymuje trwałe połączenie, eliminując narzut handshake TCP i TLS, który SSE ponosi przy każdym nowym żądaniu. Dla pojedynczych, jednorazowych żądań różnica jest pomijalna.

Jakie modele działają przez WebSocket?

Wszystkie modele dostępne przez Responses API: GPT-5.3 Codex, GPT-5.2, Codex Mini i inne. Określ model w zdarzeniu response.create.

Czy function calling i użycie narzędzi działają przez WebSocket?

Tak. Dostępny jest pełny zestaw funkcji Responses API — function calling, użycie narzędzi, structured outputs i wieloturowe rozmowy działają przez połączenie WebSocket.

Czy istnieje limit czasu połączenia?

Bezczynne połączenia są zamykane po 15 minutach. Wysyłaj okresowe wiadomości lub łącz się ponownie w razie potrzeby. Aktywne połączenia streamujące dane nie są przerywane.

Czy mogę wysłać wiele żądań przez jedno połączenie?

Tak. To jedna z kluczowych zalet. Po zakończeniu odpowiedzi wyślij kolejne zdarzenie response.create w tym samym połączeniu, bez ponownego łączenia.