DEV Community

Cover image for GPT-Live-1.1 vs GPT-Realtime: Which OpenAI Voice API to Use
Hassann
Hassann

Posted on Originally published at apidog.com

GPT-Live-1.1 vs GPT-Realtime: Which OpenAI Voice API to Use

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.

Try Apidog today

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.

Side-by-side architecture: on the left, a caller connects to GPT-Live-1.1 voice, which delegates to a backend Responses model that calls hosted tools, your functions and MCP; on the right, a caller connects to gpt-realtime-2.1, which calls your functions and MCP itself

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 in delegation.responses.model and add instructions, tools, tool_choice, reasoning and service_tier. The docs suggest starting with gpt-6-luna and moving to gpt-6-sol for harder tasks.
  • client: your app runs the backend. GPT-Live sends a session.delegation.created event, and you return results with events such as session.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:

  1. server_vad, the default, tuned with threshold, prefix_padding_ms and silence_duration_ms.
  2. semantic_vad, tuned with eagerness (low, medium, high or auto, which equals medium).

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.

Decision flowchart: if you already have a text agent or backend to keep, use GPT-Live-1.1; otherwise, if you need image input or one model doing everything, use gpt-realtime-2.1; otherwise, for long sessions with lots of silence use GPT-Live-1.1 with standby, else gpt-realtime-2.1-mini

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
Enter fullscreen mode Exit fullscreen mode

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.
Enter fullscreen mode Exit fullscreen mode

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
Enter fullscreen mode Exit fullscreen mode

-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)