OpenAI WebSocket API: streaming แบบเรียลไทม์ในต้นทุนที่ถูกลง 75%

WebSocket streaming คือวิธีที่เร็วที่สุดในการโต้ตอบกับโมเดล AI ต่างจากคำขอ HTTP แบบดั้งเดิม หรือแม้แต่ Server-Sent Events (SSE) โดย WebSocket จะคงการเชื่อมต่อแบบสองทิศทางไว้ระหว่างแอปพลิเคชันของคุณกับ API ไม่ต้องตั้งค่าการเชื่อมต่อใหม่ทุก request ไม่มี HTTP overhead และไม่มีข้อจำกัดแบบ half-duplex

ตอนนี้ Smart AIPI รองรับ protocol นี้ที่ wss://api.smartaipi.com/v1/realtime — เข้ากันได้เต็มรูปแบบกับ OpenAI WebSocket API โดยมีต้นทุนต่ำกว่าถึง 75%

ทำไมต้องใช้ WebSocket แทน SSE?

Server-Sent Events เป็นมาตรฐานสำหรับ AI streaming มาระยะหนึ่งแล้ว แต่มีข้อแลกเปลี่ยนที่ WebSocket สามารถตัดออกไปได้:

สำหรับ agent loop ที่เรียก API ต่อเนื่องหลายสิบครั้ง latency ที่ประหยัดได้สะสมจากการใช้การเชื่อมต่อ WebSocket แบบคงอยู่นั้นมีนัยสำคัญมาก

การทำงาน

WebSocket API ใช้ protocol แบบขับเคลื่อนด้วย event คุณส่ง JSON event ไปยัง server และรับ JSON event กลับมา — ทั้งหมดผ่านการเชื่อมต่อแบบคงอยู่เพียงเส้นเดียว

1. เชื่อมต่อและยืนยันตัวตน

เปิดการเชื่อมต่อ WebSocket พร้อม API key ของคุณใน headers:

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

2. ส่ง request

ส่ง event response.create พร้อม 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

server จะส่งลำดับของ event กลับมาเมื่อกำลังสร้างคำตอบ:

ตัวอย่างโค้ด

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 (ทดสอบด่วน)

ตรวจสอบว่า 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

หากเชื่อมต่อสำเร็จจะได้ HTTP/1.1 101 Switching Protocols

ควรใช้ WebSocket หรือ SSE เมื่อไร

ทั้งสอง protocol ใช้งานได้ผ่าน Smart AIPI เลือกตามลักษณะการใช้งานของคุณ:

• ใช้ SSE สำหรับ integration แบบง่าย request แบบครั้งเดียว และกรณีที่ต้องการ implementation ที่ง่ายที่สุด เพียงตั้งค่า stream: true ใน API call มาตรฐานใดก็ได้
• ใช้ WebSocket สำหรับ agent loop, แอปพลิเคชันแบบ interactive, รูปแบบ request ความถี่สูง และทุกที่ที่คุณต้องการ latency ต่ำที่สุดระหว่างการเรียกต่อเนื่อง

ราคา

คำขอ WebSocket คิดค่าบริการแบบเดียวกับคำขอ API มาตรฐาน — ตามการใช้ token โดยส่วนลด 75% ใช้ดังนี้:

เริ่มต้นใช้งาน

1. รับ API key — สมัครที่ smartaipi.com (มีเครดิตฟรีให้ ไม่ต้องใช้บัตรเครดิต)
2. เชื่อมต่อ — เปิด WebSocket ไปที่ wss://api.smartaipi.com/v1/realtime
3. ส่ง events — ใช้ envelope response.create พร้อม model และ prompt ของคุณ
4. ทำ streaming responses — ประมวลผล event response.output_text.delta ทันทีที่เข้ามา

หากคุณใช้ OpenAI WebSocket API อยู่แล้ว การเปลี่ยนแปลงมีเพียง URL เท่านั้น ที่เหลือทั้งหมด — authentication, events, รูปแบบ payload — เหมือนเดิม

คำถามที่พบบ่อย

Smart AIPI รองรับ OpenAI WebSocket API หรือไม่?

รองรับ เชื่อมต่อไปที่ wss://api.smartaipi.com/v1/realtime พร้อม API key ของคุณใน header Authorization โดย protocol เข้ากันได้เต็มรูปแบบกับ OpenAI WebSocket Responses API

WebSocket เร็วกว่า SSE หรือไม่?

สำหรับ request ต่อเนื่อง เร็วกว่า WebSocket คงการเชื่อมต่อแบบคงอยู่ไว้ จึงตัด overhead จาก TCP และ TLS handshake ที่ SSE ต้องทำใหม่ในทุก request ออกไป สำหรับ request เดี่ยวแบบครั้งเดียว ความแตกต่างแทบไม่มีนัยสำคัญ

มี model ใดบ้างที่ใช้ผ่าน WebSocket ได้?

ทุก model ที่มีผ่าน Responses API: GPT-5.3 Codex, GPT-5.2, Codex Mini และอื่นๆ โดยระบุ model ใน event response.create

function calling และการใช้ tools ใช้งานผ่าน WebSocket ได้หรือไม่?

ได้ รองรับความสามารถทั้งหมดของ Responses API — function calling, การใช้ tools, structured outputs และบทสนทนาแบบ multi-turn ทั้งหมดทำงานผ่านการเชื่อมต่อ WebSocket ได้

มีการจำกัดเวลาการเชื่อมต่อหรือไม่?

การเชื่อมต่อที่ไม่มีการใช้งานจะถูกปิดหลังจาก 15 นาที ให้ส่งข้อความเป็นระยะหรือเชื่อมต่อใหม่ตามต้องการ การเชื่อมต่อที่กำลัง stream ข้อมูลอยู่จะไม่ถูกตัด

ฉันส่งหลาย request บนการเชื่อมต่อเดียวได้หรือไม่?

ได้ นี่คือหนึ่งในข้อได้เปรียบหลัก หลังจาก response หนึ่งเสร็จแล้ว คุณสามารถส่ง event response.create ถัดไปบนการเชื่อมต่อเดิมได้โดยไม่ต้องเชื่อมต่อใหม่