gpt-live-1 两种调用方式:OpenAI 官方 Live API 与 Codex Live V3

Posted November 19, 2026 by XAI 技术团队 ‐ 17 min read

OpenAI 实时语音波形与在线助手界面
配图:OpenAI Realtime API

gpt-live-1 是 OpenAI 的全双工语音模型:它能边听边说,用户可以随时插话,需要推理或调用工具时再交给后端模型。在 XAI Router 上,它有两种调用方式:

  • OpenAI 官方 Live API:与 OpenAI 官方文档完全一致,只需把地址换成本站、Key 换成本站 Key。
  • Codex Live V3:Codex 客户端使用的语音协议,请求格式、请求头和事件都与官方 API 不同。

用哪一种,由你购买的套餐决定。 不同套餐在后台对应不同的上游线路,两种方式的请求体和事件不能混用。下单前请先看完第一节。

一、先确认你的套餐

你的套餐应使用的方式适合的客户端
上游为 OpenAI 官方 API 的套餐OpenAI 官方 Live API按 OpenAI 官方文档或官方 SDK 开发的应用、语音客服、电话网关
Codex 专营套餐Codex Live V3Codex 客户端,以及支持 Codex Live 协议的第三方客户端

如果不确定自己的套餐属于哪条线路,请在管理后台查看套餐说明,或联系客服确认后再接入。方式选错时会收到明确的报错,见第五节。

二、两种方式对照

OpenAI 官方 Live APICodex Live V3
模型gpt-live-1gpt-live-1
WebSocketwss://api.xairouter.com/v1/live/sessions,首帧发送 session.start不支持直接用 WebSocket 创建会话
WebRTC 创建会话POST https://api.xairouter.com/v1/live/sessions,JSON:session + transportPOST https://api.xairouter.com/v1/live,multipart 表单:sdp + session
成功响应HTTP 201,JSON:session.id 与 transport.sdpHTTP 201,正文是 answer SDP,Location 中带 call_id
附着同一会话(sideband)wss://api.xairouter.com/v1/live/sessions/{id}/attachwss://api.xairouter.com/v1/live/{call_id}
鉴权Authorization: Bearer <API Key>Authorization: Bearer <API Key>
协议请求头无openai-alpha: quicksilver=v2(必填)
session.type不需要不要设置
主要事件session.started
session.input_transcript.delta
session.output_transcript.delta
session.output_audio.delta
session.closed
session.started
input_transcript.added
output_transcript.added
turn.done
详细说明本文第三节;OpenAI 官方 Live 指南本文第四节

两种方式的通用要求:

  • API Key 只能放在服务端,不要写进浏览器或 App。浏览器端用 WebRTC,由你的后端代为创建会话。
  • /v1/chat/completions 和普通 /v1/responses 不会变成 Live 语音。给客户端添加同名聊天模型,也不能让它支持语音。
  • 收到 HTTP 201 只说明会话已创建。完整的成功标准是:会话开始、用户语音被转写、能听到模型的回复。

三、方式一:OpenAI 官方 Live API

适用于上游为 OpenAI 官方 API 的套餐。接口、请求体和事件与 OpenAI 官方文档一致。

会话配置

字段说明
model必填,gpt-live-1;启动后不能修改
instructions对话指令
audio.output.voice音色,默认 marin
audio.format仅 WebSocket 需要,如 {"type": "audio/pcm", "rate": 24000};WebRTC 由 SDP 协商,不要设置
delegation可选,client 或 responses,用于把推理和工具调用交给后端

WebSocket 音频为 Base64 编码的 PCM:默认 24 kHz、单声道、16 位小端,不带 WAV 文件头。也支持 16 kHz PCM,以及 8 kHz 的 G.711 μ-law(audio/pcmu)和 A-law(audio/pcma)。

WebSocket 示例(Python)

适合服务端、电话网关和测试。准备 Python 3.9 或更新版本,安装依赖:

pip install websockets

下面的脚本读取一个 24 kHz、单声道、16 位的 WAV 文件作为用户语音,打印双方转写,并把模型的语音回复保存为 reply.wav:

import asyncio, base64, json, os, wave
import websockets

URL = "wss://api.xairouter.com/v1/live/sessions"
KEY = os.environ["XAI_API_KEY"]
CHUNK = 4800  # 0.1 秒 @ 24 kHz / 16 位


async def main(path="question_24k.wav"):
    pcm = wave.open(path).readframes(10**9)
    reply, heard, said = bytearray(), [], []
    started = asyncio.Event()
    async with websockets.connect(
        URL, additional_headers={"Authorization": f"Bearer {KEY}"}
    ) as ws:
        await ws.send(json.dumps({
            "type": "session.start",
            "session": {
                "model": "gpt-live-1",
                "instructions": "你是一个简洁友好的语音助手,用一句话回答。",
                "audio": {
                    "format": {"type": "audio/pcm", "rate": 24000},
                    "output": {"voice": "marin"},
                },
            },
        }))

        async def reader():
            async for raw in ws:
                event = json.loads(raw)
                kind = event["type"]
                if kind == "session.started":
                    started.set()
                elif kind == "session.output_audio.delta":
                    reply.extend(base64.b64decode(event["delta"]))
                elif kind == "session.input_transcript.delta":
                    heard.append(event["delta"])
                elif kind == "session.output_transcript.delta":
                    said.append(event["delta"])
                elif kind == "error":
                    print("错误:", raw)
                elif kind == "session.closed":
                    print("会话结束:", event.get("reason"))
                    return

        task = asyncio.create_task(reader())
        await asyncio.wait_for(started.wait(), 15)
        silence = b"\x00" * CHUNK
        chunks = [pcm[i:i + CHUNK] for i in range(0, len(pcm), CHUNK)]
        # 按真实速度推送:先发问题音频,再发 8 秒静音,留出回答时间
        for chunk in chunks + [silence] * 80:
            await ws.send(json.dumps({
                "type": "session.input_audio.append",
                "audio": base64.b64encode(chunk).decode(),
            }))
            await asyncio.sleep(0.1)
        await ws.send(json.dumps({"type": "session.close"}))
        await asyncio.wait_for(task, 15)

    print("用户:", "".join(heard))
    print("助手:", "".join(said))
    with wave.open("reply.wav", "wb") as out:
        out.setnchannels(1)
        out.setsampwidth(2)
        out.setframerate(24000)
        out.writeframes(bytes(reply))


asyncio.run(main())

运行:

XAI_API_KEY=替换为你的_API_Key python3 live_ws.py

要点:

  • 连接后第一条消息必须是 session.start,收到 session.started 之后再推送音频。
  • 音频要大致按真实时间节奏推送。全双工模型按时间在听,一次性灌入整段音频的效果不可预期。
  • 结束时先发 session.close,等收到 session.closed 再断开,这样才能拿到完整的用量。

WebRTC 示例(浏览器 + Node.js 后端)

适合网页和 App。浏览器生成 SDP offer,交给你的后端;后端带着 Key 调用 POST /v1/live/sessions,再把 answer SDP 返回给浏览器。音频走 WebRTC 媒体轨道,事件走名为 oai-events 的数据通道。

后端 server.mjs(Node.js 22+,npm install express@5):

import express from "express";

const app = express();
app.use(express.text({ type: "application/sdp", limit: "1mb" }));
app.use(express.static("public"));

app.post("/session", async (req, res) => {
  // 生产环境请在这里做用户登录校验、限流和 Origin 检查
  const upstream = await fetch("https://api.xairouter.com/v1/live/sessions", {
    method: "POST",
    headers: {
      Authorization: `Bearer ${process.env.XAI_API_KEY}`,
      "Content-Type": "application/json",
    },
    body: JSON.stringify({
      session: {
        model: "gpt-live-1",
        instructions: "你是一个简洁友好的中文语音助手。",
        audio: { output: { voice: "marin" } },
      },
      transport: { type: "webrtc", sdp: req.body },
    }),
  });
  const data = await upstream.json();
  if (!upstream.ok) return res.status(upstream.status).json(data);
  res.json({ sessionId: data.session.id, sdp: data.transport.sdp });
});

app.listen(3000, "127.0.0.1", () => console.log("打开 http://localhost:3000"));

页面 public/index.html 中的脚本(需 HTTPS 或 localhost,并由用户点击触发):

async function startCall() {
  const pc = new RTCPeerConnection();
  const player = new Audio();
  player.autoplay = true;
  pc.ontrack = (event) => { player.srcObject = event.streams[0]; };

  const mic = await navigator.mediaDevices.getUserMedia({ audio: true });
  mic.getTracks().forEach((track) => pc.addTrack(track, mic));

  // 数据通道必须在 createOffer 之前创建
  const events = pc.createDataChannel("oai-events");
  events.onmessage = ({ data }) => {
    const event = JSON.parse(data);
    if (event.type === "session.input_transcript.delta") console.log("我:", event.delta);
    if (event.type === "session.output_transcript.delta") console.log("助手:", event.delta);
    if (event.type === "session.closed") {
      pc.close();
      mic.getTracks().forEach((track) => track.stop());
    }
  };

  await pc.setLocalDescription(await pc.createOffer());
  await new Promise((resolve) => {
    if (pc.iceGatheringState === "complete") return resolve();
    pc.addEventListener("icegatheringstatechange", () => {
      if (pc.iceGatheringState === "complete") resolve();
    });
    setTimeout(resolve, 3000);
  });

  const response = await fetch("/session", {
    method: "POST",
    headers: { "Content-Type": "application/sdp" },
    body: pc.localDescription.sdp,
  });
  const { sdp } = await response.json();
  await pc.setRemoteDescription({ type: "answer", sdp });

  // 挂断:发送 session.close,收到 session.closed 后再释放连接和麦克风
  return () => events.send(JSON.stringify({ type: "session.close" }));
}

WebRTC 下不要在数据通道上发送 session.start 或 session.input_audio.append:HTTP 请求本身就会启动会话,音频全部走媒体轨道。

本站验证结果

2026 年 11 月 20 日,我们通过 api.xairouter.com,用一段合成的英文提问语音分别验证了 WebSocket 和 WebRTC:

WebSocketWebRTC
建立会话收到 session.startedHTTP 201,WebRTC 连通,数据通道收到 session.started
用户语音转写正确识别提问正确识别提问
模型回复转写与语音输出正常转写与远端音轨正常
结束session.closed,原因 close_requested同左

WebSocket 验证使用的就是上面的 Python 脚本;WebRTC 验证使用 Python 的 aiortc 客户端,上面的 Node.js 与浏览器代码按相同流程编写,部署前请在自己的浏览器中再验证一次。委派后端、中文语音和打断未在本次验证范围内。

四、方式二:Codex Live V3

适用于 Codex 专营套餐。它使用 Codex 客户端的 Live V3 协议,只支持 WebRTC 会话加连接同一会话的 sideband WebSocket。这一通道已于 2026 年 9 月 11 日完成真实语音输入、用户转写、模型回复和音频接收验证;这不代表所有第三方客户端都已逐一测试。

客户端要求

只填写 API 地址、Key 和模型名称,不足以让普通聊天客户端支持这套协议:

客户端能力能否按本节方式使用
支持自定义 Live 地址、WebRTC SDP、同一 call_id 的 sideband,以及 Live V3 事件可以,仍需确认 Key 有模型访问权限
只有 Base URL、API Key、聊天模型设置需要客户端增加 Live 语音协议支持
只支持直接连接 WebSocket 创建新语音会话不可用,Codex 通道只支持 WebRTC+sideband
只支持 OpenAI 官方 Live API 或 Realtime 协议不能直接混用请求体和事件;如需官方协议,请选择方式一对应的套餐
只有录音转文字或文字转语音功能属于独立的 ASR/TTS 接口,不等于 Live 实时对话

接入参数

参数本站取值
创建会话POST https://api.xairouter.com/v1/live,multipart 表单:sdp + session
加入同一会话的 sidebandwss://api.xairouter.com/v1/live/{call_id}
鉴权请求头Authorization: Bearer <你的 API Key>
协议请求头openai-alpha: quicksilver=v2(创建会话和 sideband 都要带)
模型session.model 明确填写 gpt-live-1
session.type不要设置
示例音色cove

客户端如果会自动追加 /v1/live,应填写 API 根地址 https://api.xairouter.com,避免拼成 /v1/v1/live。call_id 必须来自刚创建的会话,不能手填或复用旧值。

调用流程

  1. 浏览器或原生客户端获取麦克风,创建带音轨和 oai-events 数据通道的 WebRTC offer SDP。
  2. 应用后端携带 Key 和协议请求头,以 multipart 表单向 /v1/live 提交 sdp 与 session。
  3. 成功响应为 HTTP 201,正文是 answer SDP,Location 中包含新建会话的 call_id。
  4. 应用后端通过 /v1/live/{call_id} 建立 sideband,等待 session.started;浏览器应用 answer SDP,完成 WebRTC 连接。
  5. 音频走 WebRTC;转写和轮次通过 input_transcript.added、output_transcript.added、turn.done 等事件返回。结束时发送 session.close,关闭连接并停止麦克风。

浏览器原生 WebSocket 不能设置 Authorization 请求头,所以 sideband 应由应用后端建立,长期 Key 只保存在后端。

命令行快速检查(offer.sdp 必须是客户端生成的真实 WebRTC offer):

curl -X POST https://api.xairouter.com/v1/live \
  -H "Authorization: Bearer $XAI_API_KEY" \
  -H "openai-alpha: quicksilver=v2" \
  -F "sdp=<offer.sdp;type=application/sdp" \
  -F 'session={"model":"gpt-live-1","instructions":"请用中文简洁回答。","audio":{"output":{"voice":"cove"}},"delegation":{"type":"client"}};type=application/json'

本地体验:浏览器麦克风+Node 后端

这是一个最小的第三方语音客户端示例,适合先验证账号和协议。准备 Node.js 22 或更新版本,在本机创建目录:

mkdir live-voice-demo
cd live-voice-demo
npm init -y
npm install express@5 ws@8

在该目录新建 .env,填写本站 API 地址和你自己的 Key;将 .env 加入 .gitignore,不要放进前端代码:

ROUTER_API_BASE=https://api.xairouter.com
ROUTER_API_KEY=替换为你的_API_Key

1. 创建后端 server.mjs

后端负责提交 SDP、保留 session.model、连接同一会话的 sideband,并等到 session.started 才返回成功。示例每个会话最多保留 3 分钟,便于体验后自动清理;这只是示例设置,不是平台时长上限。

import express from "express";
import WebSocket from "ws";
import { randomUUID } from "node:crypto";
import { fileURLToPath } from "node:url";

const api = new URL(process.env.ROUTER_API_BASE);
const key = process.env.ROUTER_API_KEY;
if (!key) throw new Error("请在 .env 中设置 ROUTER_API_KEY");
const headers = {
  Authorization: `Bearer ${key}`,
  "openai-alpha": "quicksilver=v2",
};
const app = express();
const sessions = new Map();
app.use(express.text({ type: "application/sdp", limit: "1mb" }));
app.get("/", (_req, res) => {
  res.sendFile(fileURLToPath(new URL("./index.html", import.meta.url)));
});

function closeSocket(ws) {
  if (!ws) return;
  if (ws.readyState === WebSocket.OPEN) {
    ws.send(JSON.stringify({ type: "session.close" }));
    ws.close();
  } else if (ws.readyState !== WebSocket.CLOSED) {
    ws.terminate();
  }
}

app.post("/session", async (req, res) => {
  if (typeof req.body !== "string" || !req.body.startsWith("v=0")) {
    return res.status(400).json({ error: "需要真实的 WebRTC offer SDP" });
  }
  let ws;
  try {
    const form = new FormData();
    form.set("sdp", new Blob([req.body], { type: "application/sdp" }));
    form.set("session", new Blob([JSON.stringify({
      model: "gpt-live-1",
      instructions: "请用中文直接回答用户,保持简洁。不要委派给工具。",
      audio: { output: { voice: "cove" } },
      delegation: { type: "client" },
    })], { type: "application/json" }));
    const upstream = await fetch(new URL("/v1/live", api), {
      method: "POST", headers, body: form,
      signal: AbortSignal.timeout(30000), redirect: "error",
    });
    const sdp = await upstream.text();
    if (upstream.status !== 201 || !sdp.startsWith("v=0")) {
      throw new Error(`创建失败:HTTP ${upstream.status} ${sdp.slice(0, 300)}`);
    }
    const location = upstream.headers.get("location");
    if (!location) throw new Error("创建响应缺少 Location");
    const callId = new URL(location, api).pathname.split("/").filter(Boolean).at(-1);
    if (!callId) throw new Error("Location 中缺少 call_id");
    // 只取 call_id,始终向配置的 API 域名发送 Key。
    const sideband = new URL(`/v1/live/${encodeURIComponent(callId)}`, api);
    sideband.protocol = api.protocol === "https:" ? "wss:" : "ws:";
    ws = new WebSocket(sideband, { headers, handshakeTimeout: 15000 });

    let timer;
    try {
      await new Promise((resolve, reject) => {
        timer = setTimeout(() => reject(new Error("等待 session.started 超时")), 15000);
        ws.on("error", reject);
        ws.on("close", () => reject(new Error("sideband 已关闭")));
        ws.on("message", raw => {
          let event;
          try { event = JSON.parse(raw.toString()); } catch { return; }
          if (event.type === "session.started") resolve();
          if (event.type === "error") {
            reject(new Error(event.error?.message || "Live 会话错误"));
          }
        });
      });
    } finally {
      clearTimeout(timer);
    }
    console.log("sideband: session.started");
    const id = randomUUID();
    const expiry = setTimeout(() => closeSocket(ws), 3 * 60 * 1000);
    sessions.set(id, ws);
    ws.once("close", () => {
      clearTimeout(expiry);
      sessions.delete(id);
    });
    res.json({ id, sdp });
  } catch (error) {
    closeSocket(ws);
    res.status(502).json({ error: error.message });
  }
});

app.delete("/session/:id", (req, res) => {
  closeSocket(sessions.get(req.params.id));
  sessions.delete(req.params.id);
  res.sendStatus(204);
});
app.listen(3000, "127.0.0.1", () => console.log("打开 http://localhost:3000"));

2. 创建页面 index.html

页面通过同源 /session 与后端交换 SDP;麦克风和回复音频交给 WebRTC,字幕读取 Live V3 的 turn.done 事件。

<!doctype html>
<html lang="zh-CN">
<meta charset="utf-8">
<title>Live 语音体验</title>
<button id="start">开始语音</button>
<button id="stop" disabled>结束语音</button>
<audio id="audio" autoplay controls></audio>
<pre id="log" aria-live="polite"></pre>
<script type="module">
const startButton = document.querySelector("#start");
const stopButton = document.querySelector("#stop");
const audio = document.querySelector("#audio");
const output = document.querySelector("#log");
const log = text => { output.textContent += `${text}\n`; };
let pc, mic, sessionId;

async function stop() {
  mic?.getTracks().forEach(track => track.stop());
  pc?.close();
  audio.srcObject = null;
  const id = sessionId;
  pc = mic = sessionId = undefined;
  startButton.disabled = false;
  stopButton.disabled = true;
  if (id) {
    await fetch(`/session/${encodeURIComponent(id)}`, {
      method: "DELETE", keepalive: true,
    }).catch(() => log("关闭请求失败,服务端将在示例的 3 分钟上限内清理"));
  }
}

startButton.onclick = async () => {
  startButton.disabled = true;
  try {
    mic = await navigator.mediaDevices.getUserMedia({ audio: true });
    const connection = pc = new RTCPeerConnection();
    connection.ontrack = event => {
      audio.srcObject = event.streams[0] || new MediaStream([event.track]);
      audio.play().catch(() => log("请点击音频控件的播放按钮"));
    };
    connection.onconnectionstatechange = () => {
      log(`WebRTC: ${connection.connectionState}`);
    };
    const events = connection.createDataChannel("oai-events");
    events.onmessage = ({ data }) => {
      let event;
      try { event = JSON.parse(data); } catch { return; }
      if (event.type === "session.started") log("语音会话已开始");
      if (event.type === "turn.done" && event.turn?.transcript) {
        log(`${event.turn.role}: ${event.turn.transcript}`);
      }
      if (event.type === "error") log(`错误:${event.error?.message || data}`);
    };
    mic.getTracks().forEach(track => connection.addTrack(track, mic));
    await connection.setLocalDescription(await connection.createOffer());
    if (connection.iceGatheringState !== "complete") {
      await new Promise((resolve, reject) => {
        const timer = setTimeout(() => reject(new Error("ICE 收集超时")), 10000);
        connection.onicegatheringstatechange = () => {
          if (connection.iceGatheringState === "complete") {
            clearTimeout(timer);
            resolve();
          }
        };
      });
    }
    const response = await fetch("/session", {
      method: "POST",
      headers: { "Content-Type": "application/sdp" },
      body: connection.localDescription.sdp,
    });
    const result = await response.json();
    if (!response.ok) throw new Error(result.error);
    sessionId = result.id;
    await connection.setRemoteDescription({ type: "answer", sdp: result.sdp });
    stopButton.disabled = false;
    log("等待 WebRTC: connected 后,对麦克风说话");
  } catch (error) {
    log(error.message);
    await stop();
  }
};
stopButton.onclick = stop;
window.addEventListener("pagehide", () => { void stop(); });
</script>
</html>

3. 启动并说一句话

node --env-file=.env server.mjs

用浏览器打开 http://localhost:3000,点击“开始语音”并允许麦克风,然后按下面的顺序检查:

  1. 后端出现 sideband: session.started。
  2. 页面出现 WebRTC: connected。
  3. 对麦克风说“你好,请回答语音连接成功”,检查页面是否出现用户和助手的转写,并听到实际回复。
  4. 体验结束后点击“结束语音”,释放会话和麦克风。

仅收到 HTTP 201 或 WebSocket 101 Switching Protocols,都不能单独证明语音可用。完整成功标准是:会话开始、WebRTC 连通、用户语音被识别、回复音频能够播放。 如果浏览器拦截自动播放,请手动点击音频控件。

示例仅监听本机 127.0.0.1。部署为多人使用的网站时,浏览器页面应使用 HTTPS,后端还需为自己的用户添加登录校验、会话归属检查和用量限制。这里的示例只做直接语音对话;让语音助手执行工具或接入编程代理,需要另行实现客户端委派流程。

官方桌面客户端的 Voice

官方当前明确说明桌面 Voice 不支持通过 API Key 使用,参见 ChatGPT Voice in Desktop 说明。因此,仅用 API Key 登录官方桌面客户端,不能启用 Voice;本站管理页的默认 Codex API Key 配置也不附带语音开关。需要语音的用户,应在支持本节协议的第三方客户端或自己的应用中接入。

五、报错对照

下面这些报错,多数是方式与套餐不匹配,或请求格式不符合所选方式:

报错原因处理
503 No OpenAI Live project key at the configured model level套餐上游不是 OpenAI 官方 API,却调用了 /v1/live/sessionsCodex 专营套餐请改用方式二 /v1/live
Your account does not have access to Quicksilver v2 sessions.套餐上游是 OpenAI 官方 API,却调用了 /v1/live改用方式一 /v1/live/sessions
AVAS requires OpenAI-Alpha: quicksilver=v2.方式二缺少协议请求头,或值不是 quicksilver=v2加上 openai-alpha: quicksilver=v2
Field session.type must be quicksilver when intent=quicksilver is requested,或 architecture="avas" is only supported for quicksilver Realtime WebRTC sessions.方式二的 session 中设置了 type删除 session.type
400 Public Live sessions require gpt-live-1方式一的 session.model 不是 gpt-live-1把模型设为 gpt-live-1
400 Live sessions do not accept query parameters; put the model in session.start方式一的 WebSocket 地址带了查询参数去掉查询参数,模型写在 session.start 中
HTTP 401Key 无效,或 Key 与 API 站点不匹配检查 Authorization 请求头与 Key
模型不存在、无可用渠道或无模型权限套餐未启用 gpt-live-1,或 Key 的模型范围不包含它检查套餐与 Key 的模型范围
方式二的 sideband 返回 404call_id 不是本次创建响应返回的,或会话已失效从本次创建响应的 Location 获取 call_id,使用相同 API 入口和 Key
已连接但没有收音或回复麦克风权限、设备或输入音量问题,或浏览器拦截了自动播放检查麦克风、WebRTC/ICE 连接状态,手动点击播放

更多状态码见《错误码》,接口规则见《WebSocket 与实时接口》。

六、计费

  • OpenAI 官方 Live API:按会话时长计费。WebRTC 会话在建会成功后起计 15 秒,之后按累计时长抵扣;WebSocket 按上游上报的秒数计费。委派给后端模型的 Token 和工具费用另计。单价见模型页。
  • Codex Live V3:按 Codex 专营套餐的规则计费,以管理后台显示为准。

七、选购提醒

gpt-live-1 在本站的两种调用方式都可用,但一个套餐只对应其中一种:

  • 想按 OpenAI 官方文档、官方 SDK 开发自己的语音应用,或接入电话、客服系统:选择上游为 OpenAI 官方 API 的套餐,按方式一调用。
  • 主要在 Codex 或支持 Codex Live 协议的客户端里使用语音:选择 Codex 专营套餐,按方式二调用。

购买前请在管理后台确认套餐对应的线路;不确定时请先联系客服。已经购买、但调用方式和套餐不一致时,按第五节的报错对照调整即可。

参考资料