OpenAI WebSocket API: 75% తక్కువ ఖర్చుతో రియల్-టైమ్ Streaming

AI models తో ఇంటరాక్ట్ అవ్వడానికి WebSocket streaming అత్యంత వేగవంతమైన మార్గం. సాంప్రదాయ HTTP requests లేదా Server-Sent Events (SSE) కంటే భిన్నంగా, WebSocket మీ application మరియు API మధ్య persistent, bidirectional connection ను కొనసాగిస్తుంది. ప్రతి request కు connection setup అవసరం లేదు, HTTP overhead లేదు, half-duplex పరిమితులు లేవు.

Smart AIPI ఇప్పుడు ఈ protocol ను wss://api.smartaipi.com/v1/realtime వద్ద సపోర్ట్ చేస్తుంది — OpenAI యొక్క WebSocket API తో పూర్తిగా compatible గా, 75% తక్కువ ఖర్చుతో.

SSE కంటే WebSocket ఎందుకు?

AI streaming కోసం Server-Sent Events ప్రామాణికంగా ఉపయోగంలో ఉన్నాయి, కానీ వాటికి WebSocket తొలగించే కొన్ని trade-offs ఉన్నాయి:

వరుసగా డజన్ల కొద్దీ API calls చేసే agent loops కోసం, persistent WebSocket connection వల్ల కలిగే cumulative latency savings గణనీయంగా ఉంటాయి.

ఇది ఎలా పనిచేస్తుంది

WebSocket API ఒక event-driven protocol ను అనుసరిస్తుంది. మీరు server కు JSON events పంపుతారు, మరియు తిరిగి JSON events పొందుతారు — ఇవన్నీ ఒకే persistent connection పై జరుగుతాయి.

1. కనెక్ట్ అవ్వండి మరియు Authenticate చేయండి

headers లో మీ API key తో ఒక WebSocket connection ఓపెన్ చేయండి:

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

2. ఒక Request పంపండి

మీ prompt తో ఒక response.create event పంపండి:

{
  "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 స్వీకరించండి

response రూపొందుతున్నప్పుడు server వరుసగా events ను తిరిగి పంపుతుంది:

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 (త్వరిత పరీక్ష)

ఒకే command తో WebSocket handshake విజయవంతమైందో లేదో ధృవీకరించండి:

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

విజయవంతమైన connection కు HTTP/1.1 101 Switching Protocols వస్తుంది.

WebSocket ని ఎప్పుడు ఉపయోగించాలి, SSE ని ఎప్పుడు ఉపయోగించాలి

రెండు protocols కూడా Smart AIPI ద్వారా పని చేస్తాయి. మీ use case ఆధారంగా ఎంచుకోండి:

• SSE ఉపయోగించండి సాధారణ integrations, one-off requests, మరియు వీలైనంత సరళమైన implementation కావాలనుకున్నప్పుడు. ఏదైనా standard API call పై stream: true సెట్ చేయండి.
• WebSocket ఉపయోగించండి agent loops, interactive applications, high-frequency request patterns, మరియు వరుస calls మధ్య కనిష్ట latency అవసరమైన ఏ సందర్భంలోనైనా.

ధరలు

WebSocket requests కు billing, standard API requests మాదిరిగానే — token usage ఆధారంగా ఉంటుంది. 75% discount ఇక్కడ వర్తిస్తుంది:

ప్రారంభించడం ఎలా

1. ఒక API key పొందండి — smartaipi.com లో sign up చేయండి (free credits ఉన్నాయి, credit card అవసరం లేదు)
2. కనెక్ట్ అవ్వండి — wss://api.smartaipi.com/v1/realtime కు ఒక WebSocket ఓపెన్ చేయండి
3. events పంపండి — మీ model మరియు prompt తో response.create envelope ను ఉపయోగించండి
4. responses ను stream చేయండి — వచ్చిన వెంటనే response.output_text.delta events ను process చేయండి

మీరు ఇప్పటికే OpenAI యొక్క WebSocket API ను ఉపయోగిస్తున్నట్లయితే, మార్పు చేయాల్సింది URL మాత్రమే. మిగతావన్నీ — authentication, events, payload format — పూర్తిగా ఒకే విధంగా ఉంటాయి.

తరచుగా అడిగే ప్రశ్నలు

Smart AIPI, OpenAI WebSocket API ని సపోర్ట్ చేస్తుందా?

అవును. Authorization header లో మీ API key తో wss://api.smartaipi.com/v1/realtime కు కనెక్ట్ అవ్వండి. ఈ protocol, OpenAI యొక్క WebSocket Responses API తో పూర్తిగా compatible గా ఉంటుంది.

WebSocket, SSE కంటే వేగంగా ఉంటుందా?

వరుస requests కోసం అవును. WebSocket ఒక persistent connection ను కొనసాగిస్తుంది, దీంతో SSE ప్రతి కొత్త request పై ఎదుర్కొనే TCP మరియు TLS handshake overhead తొలగిపోతుంది. ఒకే one-off request కోసం అయితే తేడా చాలా తక్కువగా ఉంటుంది.

WebSocket పై ఏ models పని చేస్తాయి?

Responses API ద్వారా అందుబాటులో ఉన్న అన్ని models: GPT-5.3 Codex, GPT-5.2, Codex Mini, మరియు ఇతరాలు. response.create event లో model ని పేర్కొనండి.

function calling మరియు tool use, WebSocket పై పని చేస్తాయా?

అవును. పూర్తి Responses API feature set అందుబాటులో ఉంటుంది — function calling, tool use, structured outputs, మరియు multi-turn conversations అన్నీ WebSocket connection పై పని చేస్తాయి.

connection time limit ఏదైనా ఉందా?

Idle connections ను 15 నిమిషాల తర్వాత మూసివేస్తారు. అవసరమైతే periodic messages పంపండి లేదా మళ్లీ reconnect అవ్వండి. data ను stream చేస్తున్న active connections కు అంతరాయం ఉండదు.

ఒకే connection పై అనేక requests పంపవచ్చా?

అవును. ఇది ప్రధాన ప్రయోజనాల్లో ఒకటి. ఒక response పూర్తైన తర్వాత, reconnect కాకుండా అదే connection పై మరో response.create event పంపండి.