GPT-Live-1 Reaches the API: Full-Duplex Voice at $0.05 a Minute, With No Drop-In Path From GPT-Realtime-2.1

GPT-Live-1 is in the API as of September 10, and the number that will actually reshape budgets is not a benchmark — it is the billing unit. OpenAIOpe​nAI's full-duplex voice model now bills at a flat $0.05 per minute of voice, charged by the second, where the model it is being compared against, GPT-Realtime-2.1, was metered in audio tokens at $32 per million in and $64 per million out. The model itself is not new: GPT-Live-1 shipped inside ChatGPT on July 8, 2026, as the replacement for Advanced Voice Mode. What is new is that developers can finally call it — and that calling it looks almost nothing like the Realtime integration most teams already have. OpenAIOpe​nAI's own documentation pairs the voice layer with a separate reasoning backend, and in the published WebRTC example that backend is GPT-5.6 Terra.

What shipped on September 10, and what did not

The API surface is narrow by design. There is exactly one model ID, gpt-live-1, which is also its own default snapshot — no dated variants to pin. There is exactly one endpoint, the Live Sessions endpoint at v1/live/sessions. Everything else on OpenAIOpe​nAI's platform is switched off for this model: no Chat Completions, no Responses, no Realtime (including the translation and transcription variants), no Assistants, no Batch, no fine-tuning, no embeddings, no image or video generation, no audio speech or transcription endpoints, no moderation.

Inputs and outputs are audio and text. Streaming and function calling are supported; structured outputs, fine-tuning and predicted outputs are not. Image and video input are explicitly unsupported — so the "voice with video" surface OpenAIOpe​nAI has teased is not part of this release. The Free tier cannot call it at all, and rate limits are measured in concurrent sessions rather than requests per minute: 25 on Tier 1, rising to 50, 200, 300 and 500 across Tiers 2 through 5.

That concurrency framing is the first clue that this is not a plug-in replacement. Rate limits denominated in simultaneous live conversations tell you what OpenAIOpe​nAI expects the unit of scale to be: a phone line, not a request.

The pricing change is the quieter, bigger story

Flat per-minute billing is a genuine departure. Under token metering you had to model audio burn — how many tokens a second of silence costs, how a caller who keeps talking over the agent changes the output length — before you could forecast a single call. At $0.05 per minute the arithmetic collapses to multiplication:

• A 5-minute support call — $0.25 of voice time

• A 10-minute call — $0.50

• A 4-minute average across 1,000 calls a day — $200 a day, roughly $6,000 a month

• One hour of continuous open line — $3.00

Three details sharpen that. First, duration is not rounded up to the next whole minute, so a 40-second call costs about 3.3 cents rather than a full nickel. Second, session initialization bills 15 seconds of voice duration up front — but that is credited against later duration charges, not stacked on top, so a call shorter than 15 seconds still lands at the 15-second price. Third, voice is only half the bill. The backend reasoning model, its tool calls, and any web search are billed separately at that model's normal rates, which means a "cheap voice model" can still produce an expensive call if you point delegation at a frontier reasoner and let it search on every turn.

That two-meter structure is where routing stops being a nicety. On OrcaRouter the backend half of a GPT-Live-1 session is just another model call — roughly 190 models from eleven upstream providers behind one key, at provider list price passed through with zero markup, and automatic failover if your chosen backend errors or times out. You cannot route the voice layer itself; the Live Sessions endpoint is OpenAIOpe​nAI's alone. You can absolutely route everything the voice layer delegates to, which is the half that scales with how hard your callers think.

WebRTC only — why your Realtime code will not port

This is the practical cost of moving, and most launch coverage skips it. GPT-Live-1 sessions run over WebRTC, not the WebSocket transport that a lot of existing Realtime integrations are built on. Probing the older path with a GPT-Live model ID returns an error telling you in as many words that sessions require WebRTC.

The handshake, per OpenAIOpe​nAI's WebRTC guide: your browser opens an RTCPeerConnection, attaches microphone tracks, opens a data channel and registers listeners before offering, sets the local description, waits for ICE gathering, and posts the offer to your own server. Your server then calls POST /v1/live/sessions with the session config plus transport: { type: "webrtc", sdp: ... }. A success returns HTTP 201 carrying session.id and transport.sdp, which the browser applies as the remote description. Media travels on the negotiated tracks; the data channel — label oai-events — carries transcripts, session updates and delegated work. To hang up you send session.close and keep reading until session.closed arrives.

Two gotchas worth taping to the monitor. The HTTP call itself starts the session, so you must not also send session.start on the data channel. And you should not append input audio or wait for output audio deltas over that channel — leave audio.format out of the config and let SDP handle it. The server examples cap the request body at 64 KB, time out ICE gathering after 10 seconds and session finalization after 15.

None of that is hard. All of it is new code. If your product is a turn-based realtime agent, migrating to GPT-Live-1 is a transport rewrite plus a delegation rewrite, not a model ID swap — worth budgeting as a sprint rather than an afternoon.

The benchmarks, and who ran every one of them

Every figure below is OpenAIOpe​nAI's own, published with the API release and not independently reproduced by anyone at the time of writing. That caveat matters more than usual here, because the deltas are large enough that they invite being quoted as settled fact.

• Full-duplex interactivity — GPT-Live-1 80.1% vs 45.4% for GPT-Realtime-2.1

• Turn-taking latency — 0.8s vs 1.4s

• Tool-calling accuracy — 87% vs 60%

• Banking voice-support benchmark, pass rate — 32% vs 12.4%

Read the last line twice. A 32% pass rate is a large improvement over 12.4% and still means the system failed roughly two-thirds of the tasks in that evaluation. The interactivity and tool-calling jumps are the ones that describe a genuinely different product; the banking number is the honest one about how far voice agents still are from handling a regulated workflow unsupervised.

The customer evidence is thinner than the benchmark table and points the same direction. Yelp is using GPT-Live-1 for phone-based reservations, with CTO Alex Levy cited on improved call handling. Language-learning platform Speak reported close to 80% fewer interruptions than its previous turn-based system — a self-reported figure from a company with a stake in the result, and still the most concrete deployment number available.

The voice layer is a front end; you choose the brain

The architectural bet is delegation, and it is the part of this release that a routing layer slots into naturally. GPT-Live-1 does not do the deep thinking. When a caller asks something that needs reasoning, retrieval or a tool, the model hands the task across an asynchronous boundary to a separate backend that keeps working while the spoken conversation continues, then folds the answer back in when it is ready.

The configuration is explicit, and it is worth reading the docs example closely. Alongside model: "gpt-live-1" and the instructions, the session carries a delegation object of type responses, whose inner responses block names the backend model, its own instructions, its tools — the example uses web_search — and a tool_choice. In OpenAIOpe​nAI's published WebRTC example, that backend model is GPT-5.6 Terra.

That is the design's real claim: swap the backend and the voice experience gets smarter without retraining the speech model. It also means the delegation backend is portable in a way the voice layer is not. OrcaRouter does not carry gpt-live-1 — the Live Sessions endpoint is OpenAI-only, and we route none of it. But the delegation half speaks the Responses API, and that half is entirely yours to choose. GPT-5.6 Terra is live on OrcaRouter at OpenAIOpe​nAI's list price — $2.00 per million input tokens and $12.00 per million output, with the Responses endpoint exposed — so the exact model in OpenAIOpe​nAI's own example is one call away without a second contract or SDK.

Practically, that turns backend choice into configuration. You can A/B a cheap reasoner against a frontier one on live call traffic by editing one line and watching the per-call bill, or hold the delegation model behind automatic failover so a bad afternoon upstream does not take your phone line down with it. The voice layer you pay $0.05 a minute for stays where it is; everything it delegates runs through one key across roughly 190 models from eleven upstream providers, at provider list price with zero markup.

What is still missing

• No image or video input — stills and screen sharing are not in this release, so the multimodal voice surface older ChatGPT modes still hold remains unaddressed

• No structured outputs — if your agent needs schema-validated tool arguments, that validation has to live in your backend model, not the voice layer

• No Free-tier access and no fine-tuning — cost and customisation both start at the paid tiers

• No independent evaluation of any headline number — every figure above is vendor-run

• A concurrency ceiling of 25 simultaneous sessions on Tier 1 — generous for a pilot, tight for a call centre on day one

Who should move, and who should wait

Move now if you are building telephony — reservation lines, appointment booking, first-line support — and your current stack is the classic ASR-to-LLM-to-TTS cascade. The latency and interruption handling are exactly what that pipeline loses, the per-minute price is forecastable enough to put in a spreadsheet, and OpenAIOpe​nAI's own docs now include a Twilio-shaped server example to copy from. Move now too if you are already on a Realtime model and your product is genuinely conversational rather than turn-based, because the interruption handling is the part GPT-Realtime-2.1 was worst at.

Wait if your integration is turn-based and working. The transport rewrite is real work, the endpoint supports nothing else, and there is no migration path that preserves your existing WebSocket code. Wait as well if your use case depends on structured tool outputs or video input, both of which are absent here.

What to watch over the next few weeks: the first independent reproduction of the 80.1% interactivity figure, whether the $0.05 rate is introductory, whether a smaller GPT-Live-1 mini reaches the API the way it did on the consumer side, and whether image and screen input close the gap. Until an outside lab runs that evaluation, the honest summary is that this is the most capable voice model anyone has shipped to developers, with the receipt for that claim written by the people selling it.