语音对话

建立 WebSocket 连接用于语音对话。

注意：这是一个 WebSocket 端点，需要使用 wss:// 协议连接。

连接 URL 示例：

wss://api-platform.ope.ai/v1/realtime?model=AudioLLM/Voice2.0

Try It

GET/v1/realtimewss://api-platform.ope.ai/v1/realtime

认证

使用 Bearer Token 认证。

• Header：Authorization: Bearer <token>
• 示例：Authorization: Bearer sk-xxxxxx

浏览器原生 WebSocket API 无法自定义请求头；如果你的服务端只支持 Header 鉴权，请使用服务端/Node 客户端（或让网关支持 query 传 token）。

Query 参数

参数	类型	必填	说明
model	string	否	要使用的模型（示例：AudioLLM/Voice2.0）

请求示例

JavaScript (Node)

// npm i ws
import WebSocket from "ws";

const url = "wss://api-platform.ope.ai/v1/realtime?model=AudioLLM/Voice2.0";
const apiKey = process.env.OPEAI_API_KEY;

const ws = new WebSocket(url, {
  headers: {
    Authorization: `Bearer ${apiKey}`,
  },
});

ws.on("open", () => {
  console.log("connected");
  // 根据你服务端协议发送首包/事件
  // ws.send(JSON.stringify({ type: "input_text", text: "hello" }));
});

ws.on("message", (data) => {
  console.log("message:", data.toString());
});

ws.on("close", () => console.log("closed"));
ws.on("error", (e) => console.error("error:", e));

Python

import os
import asyncio
import websockets

URL = "wss://api-platform.ope.ai/v1/realtime?model=AudioLLM/Voice2.0"
API_KEY = os.environ.get("OPEAI_API_KEY")

async def main():
  async with websockets.connect(URL, extra_headers={"Authorization": f"Bearer {API_KEY}"}) as ws:
    print("connected")
    # await ws.send('{"type":"input_text","text":"hello"}')
    async for msg in ws:
      print("message:", msg)

asyncio.run(main())

Go

package main

import (
  "log"
  "net/http"
  "os"

  "github.com/gorilla/websocket"
)

func main() {
  url := "wss://api-platform.ope.ai/v1/realtime?model=AudioLLM/Voice2.0"
  header := http.Header{}
  header.Set("Authorization", "Bearer "+os.Getenv("OPEAI_API_KEY"))

  c, _, err := websocket.DefaultDialer.Dial(url, header)
  if err != nil {
    log.Fatal(err)
  }
  defer c.Close()

  for {
    _, msg, err := c.ReadMessage()
    if err != nil {
      log.Fatal(err)
    }
    log.Println(string(msg))
  }
}

Java

// 需要 OkHttp（WebSocket 支持自定义 Header）
// implementation("com.squareup.okhttp3:okhttp:4.12.0")

import okhttp3.*;
import okio.ByteString;

public class Main {
  public static void main(String[] args) {
    String url = "wss://api-platform.ope.ai/v1/realtime?model=AudioLLM/Voice2.0";
    String apiKey = System.getenv("OPEAI_API_KEY");

    OkHttpClient client = new OkHttpClient();
    Request request = new Request.Builder()
      .url(url)
      .addHeader("Authorization", "Bearer " + apiKey)
      .build();

    client.newWebSocket(request, new WebSocketListener() {
      @Override public void onOpen(WebSocket webSocket, Response response) {
        System.out.println("connected");
      }

      @Override public void onMessage(WebSocket webSocket, String text) {
        System.out.println("message: " + text);
      }

      @Override public void onMessage(WebSocket webSocket, ByteString bytes) {
        System.out.println("bytes: " + bytes.size());
      }

      @Override public void onFailure(WebSocket webSocket, Throwable t, Response response) {
        t.printStackTrace();
      }
    });
  }
}

C#

using System;
using System.Net.WebSockets;
using System.Text;
using System.Threading;
using System.Threading.Tasks;

public class Program
{
  public static async Task Main()
  {
    var url = new Uri("wss://api-platform.ope.ai/v1/realtime?model=AudioLLM/Voice2.0");
    var apiKey = Environment.GetEnvironmentVariable("OPEAI_API_KEY");

    using var ws = new ClientWebSocket();
    ws.Options.SetRequestHeader("Authorization", $"Bearer {apiKey}");

    await ws.ConnectAsync(url, CancellationToken.None);
    Console.WriteLine("connected");

    var buffer = new byte[8192];
    while (ws.State == WebSocketState.Open)
    {
      var result = await ws.ReceiveAsync(buffer, CancellationToken.None);
      if (result.MessageType == WebSocketMessageType.Close) break;
      var text = Encoding.UTF8.GetString(buffer, 0, result.Count);
      Console.WriteLine(text);
    }
  }
}

响应示例

• 101：Switching Protocols（WebSocket 握手成功）
• 400：参数/鉴权错误（返回 JSON 错误对象）