OpenAI WebSocket API: Real-Time Streaming sa 75% Mas Mababang Gastos

Ang WebSocket streaming ang pinakamabilis na paraan para makipag-ugnayan sa AI models. Hindi tulad ng tradisyonal na HTTP requests o kahit Server-Sent Events (SSE), pinananatili ng WebSocket ang isang persistent, bidirectional connection sa pagitan ng iyong application at ng API. Walang connection setup kada request, walang HTTP overhead, walang half-duplex na limitasyon.

Sinusuportahan na ngayon ng Smart AIPI ang protocol na ito sa wss://api.smartaipi.com/v1/realtime — ganap na compatible sa OpenAI WebSocket API, sa 75% na mas mababang halaga.

Bakit WebSocket kaysa SSE?

Ang Server-Sent Events ang naging standard para sa AI streaming, pero may mga trade-off ito na inaalis ng WebSocket:

Para sa mga agent loop na gumagawa ng dose-dosenang magkakasunod na API calls, malaki ang naiipong matitipid sa latency mula sa isang persistent WebSocket connection.

Paano Ito Gumagana

Ang WebSocket API ay sumusunod sa event-driven na protocol. Nagpapadala ka ng JSON events sa server at tumatanggap ng JSON events pabalik — lahat sa iisang persistent connection.

1. Kumonekta at Mag-authenticate

Magbukas ng WebSocket connection gamit ang iyong API key sa headers:

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

2. Magpadala ng Request

Magpadala ng response.create event kasama ang iyong 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. Tanggapin ang Streaming Events

Nagpapadala ang server ng sunod-sunod na events habang ginagawa ang response:

Mga Halimbawa ng Code

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 (Mabilis na Pagsubok)

I-verify na matagumpay ang WebSocket handshake gamit ang isang command lang:

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

Ang matagumpay na connection ay nagbabalik ng HTTP/1.1 101 Switching Protocols.

Kailan Gagamit ng WebSocket vs SSE

Parehong protocol ay gumagana sa pamamagitan ng Smart AIPI. Pumili batay sa iyong use case:

• Gamitin ang SSE para sa mga simpleng integration, one-off requests, at kapag gusto mo ang pinakasimpleng posibleng implementation. Itakda ang stream: true sa anumang standard API call.
• Gamitin ang WebSocket para sa agent loops, interactive applications, high-frequency request patterns, at saanman kailangan mo ang pinakamababang posibleng latency sa pagitan ng magkakasunod na calls.

Pagpepresyo

Ang WebSocket requests ay sinisingil katulad ng standard API requests — ayon sa paggamit ng token. Nalalapat ang 75% na diskwento:

Pagsisimula

1. Kumuha ng API key — Mag-sign up sa smartaipi.com (may kasamang libreng credits, hindi kailangan ng credit card)
2. Kumonekta — Magbukas ng WebSocket sa wss://api.smartaipi.com/v1/realtime
3. Magpadala ng events — Gamitin ang response.create envelope kasama ang iyong model at prompt
4. Mag-stream ng responses — I-process ang response.output_text.delta events habang dumarating ang mga ito

Kung gumagamit ka na ng OpenAI WebSocket API, ang URL lang ang kailangang baguhin. Lahat ng iba pa — authentication, events, payload format — ay pareho.

Mga Madalas Itanong

Sinusuportahan ba ng Smart AIPI ang OpenAI WebSocket API?

Oo. Kumonekta sa wss://api.smartaipi.com/v1/realtime gamit ang iyong API key sa Authorization header. Ganap na compatible ang protocol sa OpenAI WebSocket Responses API.

Mas mabilis ba ang WebSocket kaysa SSE?

Para sa magkakasunod na requests, oo. Pinananatili ng WebSocket ang isang persistent connection, kaya inaalis nito ang TCP at TLS handshake overhead na dinadala ng SSE sa bawat bagong request. Para sa iisang one-off request, halos walang pinagkaiba.

Anong models ang gumagana sa WebSocket?

Lahat ng models na available sa pamamagitan ng Responses API: GPT-5.3 Codex, GPT-5.2, Codex Mini, at iba pa. Tukuyin ang model sa response.create event.

Gumagana ba ang function calling at tool use sa WebSocket?

Oo. Available ang buong Responses API feature set — function calling, tool use, structured outputs, at multi-turn conversations ay lahat gumagana sa WebSocket connection.

May limitasyon ba sa oras ng connection?

Isinasara ang idle connections pagkatapos ng 15 minuto. Magpadala ng pana-panahong messages o muling kumonekta kung kinakailangan. Ang mga active connections na nag-stream ng data ay hindi naaantala.

Maaari ba akong magpadala ng maraming requests sa iisang connection?

Oo. Isa iyon sa mga pangunahing bentahe. Pagkatapos makumpleto ang isang response, magpadala ng panibagong response.create event sa parehong connection nang hindi muling kumokonekta.