GPT-Live-1.1 vs GPT-Realtime comes down to architecture. GPT-Live-1.1 is a full-duplex voice frontend that hands reasoning and tools to a separate backend model and bills $0.05 per active minute. GPT-Realtime-2.1 is one speech-to-speech model that hears, reasons, calls tools and speaks, billed per token. Pick GPT-Live-1.1 when you already have a text agent; pick Realtime when you want one model doing everything.
OpenAI put GPT-Live-1.1 in the API on November 20, 2026, so you now have two voice stacks with different endpoints, billing and tool models. Our July GPT-Live vs GPT-Realtime post compared the ChatGPT feature with the API; this one is API against API.
GPT-Live-1.1 vs GPT-Realtime at a glance
Here’s how the two stacks compare, taken from the GPT-Live-1.1 model page, the gpt-realtime-2.1 model page and the OpenAI pricing page on November 20, 2026:
| Aspect | GPT-Live-1.1 | gpt-realtime-2.1 |
|---|---|---|
| Endpoint | v1/live/sessions |
v1/realtime |
| Design | Full-duplex voice plus delegated backend | One speech-to-speech reasoning model |
| Input | Audio, text | Audio, text, image |
| Output | Audio, text | Audio, text |
| Billing | $0.05/min active, $0.02/min standby | $32 in, $64 out per 1M audio tokens |
| Reasoning and tools | Backend model, billed separately | Inside the same model and price |
| Function calling | Through delegation | session.tools |
| Transports | WebRTC, WebSocket, SIP (inbound and outbound) | WebRTC, WebSocket, SIP (inbound) |
| Rate limits | Concurrent sessions | Requests and tokens per minute |
OpenAI’s voice agents guide sums up the split in its architecture table. GPT-Live is for “full-duplex conversations with a separate backend.” The Realtime API is for “speech, reasoning, and tool use in one session.”
Architecture: delegation vs one model
GPT-Live-1.1 separates talking from thinking. The voice model handles the conversation in real time and listens while it speaks. When a request needs reasoning, search or a tool, it delegates the work to a backend model and keeps the conversation going while that runs.
You set delegation once, when you create the session, according to the live conversations guide. It has two modes:
-
responses: OpenAI runs the backend through the Responses API. You choose the model indelegation.responses.modeland addinstructions,tools,tool_choice,reasoningandservice_tier. The docs suggest starting withgpt-6-lunaand moving togpt-6-solfor harder tasks. -
client: your app runs the backend. GPT-Live sends asession.delegation.createdevent, and you return results with events such assession.instructions.append.
The mode can’t change mid-session; switching means a new session. The backend settings inside it can change with session.update.
gpt-realtime-2.1 takes the opposite approach: one reasoning model interprets the audio, calls tools and answers in speech. No second model, no handoff, and all context in one place.
With GPT-Live-1.1 you can swap the backend, or keep your existing text agent, without touching the voice layer. With Realtime, the voice model is the agent.
Pricing: per minute vs per token
GPT-Live-1.1 bills by time, and Realtime bills by tokens. That makes their costs behave very differently once callers pause, ramble or hold the line.
| Cost line | GPT-Live-1.1 | gpt-realtime-2.1 | gpt-realtime-2.1-mini |
|---|---|---|---|
| Audio | $0.05/min active, $0.02/min standby | $32 in, $64 out per 1M tokens | $10 in, $20 out per 1M tokens |
| Text | Billed by session duration | $4 in, $24 out per 1M tokens | $0.60 in, $2.40 out per 1M tokens |
| Cached input | n/a | $0.40 per 1M tokens | $0.30 audio, $0.06 text per 1M |
| Reasoning and tools | Backend model at its own rates | Included in token price | Included in token price |
GPT-Live charges by the second, so a 90-second call costs $0.075 in voice time, not $0.10. A WebRTC session bills 15 seconds while it initializes, credited once it starts running.
Standby is the cost lever Realtime doesn’t have. On WebRTC, set wake_policy.type to "speech" and idle_timeout_s to a whole number from 5 to 60. After that many seconds with no speech, the session drops to $0.02 per minute until someone talks again. Standby is documented for WebRTC only, so WebSocket and SIP sessions bill every connected second at the active rate.
To compare the two for your own traffic, use a break-even number instead of guessing. $0.05 buys about 1,560 audio input tokens or 780 audio output tokens on gpt-realtime-2.1, and about 5,000 input or 2,500 output tokens on 2.1-mini. Pull the audio token counts per minute from your Realtime usage events. If your average active minute uses more than that, GPT-Live’s voice time is cheaper; then add the backend model’s token bill to see the full picture.
Realtime bundles reasoning into the token price; GPT-Live adds a backend bill per delegated task but cuts the cost of silent stretches with standby. For the token side, see our gpt-realtime-2.1-mini guide.
Function calling and tools
Both stacks call your functions, but from different places.
On Realtime, tools live on the session. The Realtime tools guide shows a "type": "function" tool in session.tools, sent with session.update. Your client runs the function and returns a function_call_output item. Remote MCP servers work too: add a tool with "type": "mcp", a server_label and a server_url, and the Realtime API calls the server for you. You can also scope tools to one turn with response.tools.
On GPT-Live-1.1, tools live on the backend. You put function tools, MCP servers and hosted tools such as web search, file search and Code Interpreter in delegation.responses.tools. The backend’s events reach you wrapped in response.event envelopes, and your function results go back as function_call_output items followed by response.create.
The upside: the voice stays responsive while a slow tool runs in the backend. The cost: two models, two event streams and two bills.
Turn-taking, interruptions and transports
This is where the two feel most different to a caller.
Turn-taking. GPT-Live-1.1 is full-duplex: it processes incoming audio while it generates output, so it can listen, backchannel and adjust mid-sentence. Realtime works in turns detected by voice activity. The Realtime VAD guide lists two modes in session.audio.input.turn_detection.type:
-
server_vad, the default, tuned withthreshold,prefix_padding_msandsilence_duration_ms. -
semantic_vad, tuned witheagerness(low,medium,highorauto, which equalsmedium).
Realtime handles barge-in with interrupt_response. GPT-Live doesn’t need that setting, because it’s already listening while it speaks.
Transports. Both support WebRTC in the browser and WebSocket on the server. Phone calling differs. Per the SIP guide, GPT-Live supports inbound and outbound SIP, and outbound calling is “available to all organizations through the Live API, not the Realtime API call-creation endpoint.” A connected GPT-Live SIP call is limited to 2 hours. Realtime’s SIP guide covers inbound calls through the realtime.call.incoming webhook.
Limits and context
| Limit | GPT-Live-1.1 | gpt-realtime-2.1 |
|---|---|---|
| Context | 128,000 tokens per session, managed automatically | 128,000 tokens |
| Max output tokens | Not published | 32,000 |
| Instructions | Up to 16,384 tokens | Not published |
| Rate limits | Concurrent sessions, per model | 400 RPM and 200,000 TPM on Build tier |
GPT-Live counts concurrency, not tokens. The GPT-Live-1 page lists 50 concurrent sessions on Build, 300 on Launch and 500 on Grow, with no Free tier access. GPT-Live-1.1 has its own separate limit, and its page doesn’t publish numbers yet, so check your organization’s limits page before a launch.
Realtime’s limits scale to 10,000 RPM on Launch and 20,000 RPM on Grow.
Which OpenAI voice API should you use?
Use GPT-Live-1.1 when the voice is a layer on top of an agent you already trust, and use Realtime when the voice model should be the agent.
Pick GPT-Live-1.1 for:
- Adding voice to an existing text agent, support bot or workflow without rebuilding it.
- Long sessions with gaps, such as tutoring, coaching or companions, where standby pays off.
- Outbound phone calls, which only the Live API offers.
- Conversations that need natural overlap and backchanneling.
Pick gpt-realtime-2.1 for:
- Self-contained voice agents where one model should reason and act.
- Apps that send images along with speech.
- Teams that want one event stream and one bill.
Pick gpt-realtime-2.1-mini for short, high-volume, low-cost voice tasks where per-token prices beat per-minute ones. Our GPT-Realtime-2 API guide covers the Realtime setup in depth.
Let your coding agent test the tool API with Apidog CLI
Whichever stack wins, both call the same thing: your tool API. A slow lookup is dead air either way, so test its latency and contract before any caller hears it. Let Claude Code, Codex or Cursor do that with Apidog CLI.
Set it up once:
npm install -g apidog-cli@latest
apidog auth login --with-token <YOUR_TOKEN>
apidog skill install
Then give your agent one prompt:
Import ./voice-tools-openapi.yaml into Apidog project <projectId>. Build a test scenario
that calls GET /orders/{order_id} and GET /customers/{id} in sequence, asserts 200 and
the fields my voice agent reads aloud, and fails any request slower than 800 ms.
Run it 20 times against staging and tell me which step is slowest.
The agent imports the spec, checks the payload shape, builds the scenario and runs it:
apidog import --project <projectId> --format openapi --file ./voice-tools-openapi.yaml
apidog cli-schema get test-scenario-create
apidog cli-schema validate test-scenario-create --file scenario.json
apidog test-scenario create --project <projectId> --file scenario.json
apidog test-scenario import-steps <scenarioId> --project <projectId> --source endpoint --ids <endpointIds> --sync manual
apidog run -t <scenarioId> --project <projectId> -e <envId> -n 20 --timeout-request 800 -r cli,json
-n 20 repeats the run so one lucky response doesn’t hide a slow tail, and --timeout-request 800 fails any call slow enough to leave a caller waiting. Swap -r cli,json for -r junit in CI so a regression blocks the deploy, as our Apidog CLI CI/CD guide shows. New to the agent workflow? Start with Apidog CLI in Claude Code. Apidog’s Free plan covers up to 4 users.
FAQ
Which is cheaper, GPT-Live-1.1 or GPT-Realtime? It depends on your audio tokens per minute and your backend. GPT-Live voice costs $0.05 per active minute plus the backend model’s tokens. On gpt-realtime-2.1, $0.05 buys about 1,560 audio input or 780 audio output tokens. Compare against your own usage logs.
Can I use function calling with GPT-Live-1.1? Yes, through delegation. Put function tools in delegation.responses.tools, or run the backend yourself in client delegation mode. The voice model doesn’t take a direct tool list the way Realtime’s session.tools does.
Does GPT-Realtime support standby billing? No. Standby at $0.02 per minute is a GPT-Live feature, and only for WebRTC sessions configured with wake_policy and idle_timeout_s. Realtime bills the tokens each session uses.
Can GPT-Live-1.1 make outbound phone calls? Yes. Create a session with transport.type: "sip" and your SIP trunk details on POST /v1/live/sessions. OpenAI’s docs say outbound SIP runs through the Live API, not the Realtime API call-creation endpoint.
Does GPT-Live-1.1 accept image input? No. The model page lists audio and text in and out. If your voice agent needs to see images, gpt-realtime-2.1 accepts image input at $5 per 1M tokens.


Top comments (0)