The $0.05 Voice Agent: What GPT-Live-1 Changes for Agencies Reselling AI Receptionists
GPT-Live-1 arrived in the API on September 10, 2026, and the number everybody repeated was the sticker: $0.05 per minute for full-duplex voice, billed per second, no round-up. [OpenAI-published] If you resell AI receptionists, that number is one of two meters on your invoice — and the second meter is the one that decides whether a client is profitable in month three.
OpenAI's own cost guide states the rule plainly: “Total cost = (billable voice seconds ÷ 60 × voice rate per minute) + backend costs.” Backend calls “are billed separately from the voice session, just as they are in applications without voice” — including model input and output tokens, images, tool calls and web search. [OpenAI-published]
That distinction is not academic for an agency. A $0.05-per-minute voice layer under a $0.25-per-minute retail rate looks like an 80% gross margin. Delegate reasoning to the wrong backend model and the same call can land above 60%, or, in a web-searching stress case, cost almost five times the voice bill. This piece is the operator's version: what the two meters do to your margin, what the concurrency ceiling does to your capacity commitments, and what a migration actually costs in engineering days.
The two meters: what $0.05 actually buys
Meter one is the voice session: $0.05 per minute of session duration, billed per second, and duration is not rounded up. [OpenAI-published] Two details matter more than the headline rate.
Per-second billing is real, so short calls are cheap. A 40-second call is $0.0333, not $0.05. [Our arithmetic from OpenAI's rate] A 4-minute call is $0.20. One thousand 4-minute calls a day is $200.00 a day of voice — $6,000.00 in a 30-day month, $6,200 over 31 days, or $6,083.33 on a calendar-average month (365 ÷ 12). [Our arithmetic; the month convention is ours, OpenAI publishes a rate, not a month]
The session initialization charge is a floor, not a surcharge, and it is scoped to WebRTC. Creating a WebRTC session bills 15 seconds while it initializes, and that amount “is credited against duration charges once the session starts running.” [OpenAI-published] OpenAI's own worked example bills a 90-second session as 90 seconds, “not … 105 seconds.” The net effect is max(session seconds, 15), so the minimum billable session is $0.0125 and a 5-second hanger-upper costs the same as a 15-second one. The WebSocket guide documents no equivalent initialization charge — do not assume the floor on that path. Nor should you repeat the claim that GPT-Live sessions run on one transport only: OpenAI documents both, including wss://api.openai.com/v1/live/sessions. [OpenAI-published]
Meter two is the backend. Delegated reasoning and tool calls bill at the backend model's normal token rates, and our 4-minute, 6-turn worked example (1,500 input and 300 output tokens per turn) shows how wide the swing is:
| Backend model | Backend per 4-min call | Backend as % of the $0.20 voice bill | Total per call | Blended per minute |
|---|---|---|---|---|
| gpt-5.6-luna | $0.0040 | +2.0% | $0.2040 | $0.051 |
| gpt-5.6-terra (OpenAI's published default) | $0.0396 | +19.8% | $0.2396 | $0.0599 |
| gpt-5.6-sol | $0.0720 | +36.0% | $0.2720 | $0.068 |
| gpt-6-astra | $0.1800 | +90.0% | $0.3800 | $0.095 |
Backend rates from OpenAI's published price list [OpenAI-published]; token counts, turn count and every derived figure in this table are our arithmetic and assumptions. Editable versions are on our GPT-Live-1 cost calculator (linked at the end).
The default configuration is $0.2396 per call, which is $239.60 a day at 1,000 calls — 19.8% more than the voice-only number everyone quoted. That is the entire point of the two-meter framing: at 1,000 calls a day the difference between a Luna and an Astra backend is $176 a day on the same call volume. [Our arithmetic]
And the tail is longer than the averages suggest. In a 12-turn stress case with 4,000 input and 500 output tokens per turn plus search, the Astra-delegated call totals $0.98 — 4.9× the voice-only bill — against $0.368 for Terra (1.84×) and $0.2168 for Luna (1.08×). [Our arithmetic] If your platform lets a client turn on a frontier reasoner with web search on every turn, you have handed them a 5× cost override.
Margin math for an agency reselling AI receptionists
Resellers price per minute, per call or per seat; OpenAI bills per second plus tokens. Put a $0.25-per-minute retail rate against the four backends above and the gross margin on a 4-minute call looks like this. [Our arithmetic; the retail rate is an assumption, not a market rate]
| Backend | Cost to you (4-min call) | Retail at $0.25/min | Gross margin |
|---|---|---|---|
| gpt-5.6-luna | $0.2040 | $1.00 | 79.6% |
| gpt-5.6-terra | $0.2396 | $1.00 | 76.0% |
| gpt-5.6-sol | $0.2720 | $1.00 | 72.8% |
| gpt-6-astra | $0.3800 | $1.00 | 62.0% |
Three things about that table are true and uncomfortable.
1. The margin leaks through delegation, not through the voice rate. The voice leg is fixed and predictable. The backend leg is a design decision that a client, a product manager or a support ticket can change. Per-minute retail pricing with per-turn backend cost is a structurally mismatched contract: your revenue is linear in call minutes, your cost is linear in turns, and the two move independently. Every reseller of GPT-Live-1 needs a cap: which backend model, whether web search is enabled, and how many delegated turns a call may take before the agent stops delegating and hands off to a human.
2. Idle time is billable time. Active session time includes the user speaking, the assistant speaking, both silent, and the backend working — and muting the microphone does not close the session. [OpenAI-published] A receptionist that parks a caller while it checks a calendar is billing during the check. Closing the session saves $0.05 per idle minute. [OpenAI-published]
3. Backend spend can outlive the call. With client-side delegation, the backend worker can keep running after the voice session closes, and OpenAI's session-creation warning is explicitly about reconnects and apps that create sessions before the caller is ready to speak. [OpenAI-published] Your cost telemetry has to be joined across two meters and two lifetimes, or your invoices and your bill will disagree.
Also missing from all of this: telephony. A phone number, a SIP trunk or a carrier leg, speech-to-text and text-to-speech if your stack uses them, and your own labour are not in OpenAI's meter and are not in the $0.05. OpenAI publishes no telephony rate because it does not sell that leg. Model your own.
Capacity is a concurrent-session problem, not a requests-per-minute problem
This is the part of the launch that most cost write-ups skipped entirely, and it is the part that pages you at 12:10pm on a Tuesday. GPT-Live-1's rate limits are measured in concurrent sessions, not RPM and not tokens. [OpenAI-published]
| Tier | Concurrent sessions | Qualification | Absolute ceiling, 4-min calls in a 10h window |
|---|---|---|---|
| Tier 1 | 25 | $5 paid / $100 per month | ~3,750 calls/day |
| Tier 2 | 50 | $50 / $500 | ~7,500 calls/day |
| Tier 3 | 200 | $100 / $1,000 | ~30,000 calls/day |
| Tier 4 | 300 | $250 / $5,000 | ~45,000 calls/day |
| Tier 5 | 500 | $1,000 / $200,000 | ~75,000 calls/day |
| Free | Not supported | — | — |
Concurrent session limits and tier qualification thresholds [OpenAI-published]. The call ceilings are our arithmetic (concurrent sessions × 36,000 s ÷ 240 s) and assume zero peak headroom — they are upper bounds, not planning numbers.
The scheduling arithmetic is Little's Law with a peak factor:
concurrent = (calls per day × average call seconds) ÷ open-hours seconds × peak factor
A 1,000 calls-a-day client with a 4-minute average over an 8-hour window averages 8.33 concurrent sessions, and 20.83 on a 2.5× busy-hour peak — inside Tier 1's 25. Stretch the window to 12 hours and it is 5.56 average, 13.9 at peak. [Our arithmetic; the 2.5× peak factor and the 8/10/12-hour windows are our planning assumptions, because OpenAI publishes no diurnal profile]
When does a client outgrow Tier 1? At a 4-minute average, a 10-hour window and a 2.5× peak: about 1,500 calls a day. That is the practical ceiling — the 3,750-call absolute ceiling divided by the 2.5× peak headroom you need to not drop calls at noon. 2,500 calls a day needs Tier 2; 5,000 needs Tier 3. [Our arithmetic; session limits OpenAI-published]
Two operating consequences. First, your capacity plan is now an account-tier plan: a tier is a procurement lead time, so if a client's busy season adds 800 calls a day, you need the tier raised before the peak, not during the incident. Second, because the limit is concurrency and not spend, an account can be capacity-limited while it is nowhere near budget-limited — and the failure mode is a refused session on a live phone line, which is a client-visible outage rather than a bigger invoice. Budget alarms will not warn you. Concurrency headroom monitoring will.
The migration sprint warning: this is not a model-ID swap
If you have a GPT-Realtime integration in production, the tempting read is that GPT-Live-1 is a one-line change. It is not, and the reason is worth stating precisely, because the wrong reason is circulating. Both transports are supported: WebRTC for browser voice and WebSockets at wss://api.openai.com/v1/live/sessions for server-side audio. [OpenAI-published] What changed is everything above the transport:
- The event protocol changed. input_audio_buffer.append becomes session.input_audio.append; response.output_audio.delta becomes session.output_audio.delta. [OpenAI-published]
- There is no end-of-spoken-response event. GPT-Live decides when to speak, and OpenAI tells you to remove manual audio commits and voice-turn triggers. Any state machine built on “the assistant finished talking, now do X” has to be redesigned. [OpenAI-published]
- Delegation is new. The voice frontend delegates work to a backend model rather than issuing ordinary structured function calls. [OpenAI-published] Your tool-call plumbing sits on the wrong side of the boundary.
- A delegated backend does not automatically receive the waveform. If your backend needs audio, you have to pass it. [OpenAI-published] This is the gotcha that shows up in QA, not in the docs skim.
- It is one endpoint, not the whole platform. The Live sessions endpoint is supported; Chat Completions, Responses, Realtime, Assistants, Batch, fine-tuning, embeddings, image generation, video, speech generation, transcription and moderation are not supported for this model. Whether that refactor is good or bad for you depends on how much of your stack hangs off v1/responses. [OpenAI-published]
Budget it as an audio-loop and backend-contract rewrite with a QA cycle for turn-taking, barge-in and silence handling — not a config change with a regression test. If you resell a white-label receptionist, the same sprint exists on your vendor's roadmap, and it is worth asking them whether their GPT-Live-1 support is a new integration or a re-plumb of the existing one.
The regulated-workflow caveat: Tau Banking at 32.0%
The capability numbers are genuinely large, and they should be read with their configuration attached, because four of OpenAI's charts were measured with a backend model attached rather than the voice model alone. These are OpenAI-reported evaluations; no independent reproduction exists as of 2026-09-10.
| Benchmark (OpenAI chart) | GPT-Live-1 | GPT-Realtime-2.1 | Backend config |
|---|---|---|---|
| Tau Banking (Voice) — knowledge, pass@1 | 32.0% | 12.4% | Astra (medium) |
| Tau3 (Voice) — intelligence | 86.2% | 45.7% | Astra (medium) |
| Full Duplex Bench v3 — tool calling | 87.0% | 60.0% | Terra (low) |
| Full Duplex Bench v3 — response quality | 90.0% | 88.0% | Terra (low) |
| Full Duplex Bench v1.5 — interactivity | 80.10% | 45.4% | — |
| Artificial Analysis — conversational dynamics | 97.3% | 95.7% | — |
All figures OpenAI-published (extracted from the announcement's own chart data), reported here as OpenAI-reported and not independently reproduced. The Artificial Analysis row is an Artificial Analysis evaluation reported by OpenAI on OpenAI's page, not an independent verification.
Two things an operator should take from that table. The interactivity jump is the real story for receptionist work — 80.10% against 45.4% on Full Duplex Bench v1.5 is the difference between an agent that interrupts callers and one that does not, and interaction quality is what receptionist deployments are actually graded on. Note also that OpenAI's announcement prose describes its interactivity gain as “30 percentage points” while its own chart shows 80.10% minus 45.4%, or 34.70 points; we are reporting the discrepancy rather than picking one. Both are OpenAI's. [OpenAI-published, internally inconsistent]
The caveat is Tau Banking: 32.0% pass@1 on 97 banking-knowledge tasks, against 12.4% for GPT-Realtime-2.1. That is a 2.6× improvement and still roughly two-thirds of regulated banking tasks failing. [Our arithmetic from an OpenAI-published figure] If you are pitching an AI receptionist into a regulated workflow — loan intake, claims, anything where a wrong answer is a compliance event — the honest positioning is triage and capture, with a hard handoff to a human for anything that touches a regulated decision. Never invoice a regulated client for autonomy the benchmark does not support, and put the handoff threshold in writing.
The vendor-lock question: who owns the backend model choice?
GPT-Live-1's headline architecture is that voice and reasoning are separate: the voice layer runs $0.05 a minute, and reasoning and tool calls are delegated to a backend text model that OpenAI says can be a third-party model. [OpenAI-published] That is genuinely good news for portability of the reasoning layer. It also creates a new question that belongs in a contract, because whoever picks the backend picks your cost basis.
Three concrete facts to design around:
- OpenAI's published WebRTC example delegates to gpt-5.6-terra with hosted web search. [OpenAI-published] If your platform ships the example unchanged, its cost basis is the +19.8% column above, before any tool spend — and Terra is the default, not a decision anyone made on your behalf.
- Delegation is changeable at runtime: session.update can change the backend model without starting a new session, and there are service tiers (auto, default, flex, priority) plus a 10% uplift on regional or data-residency endpoints for eligible models. [OpenAI-published] Whoever holds that lever holds your unit economics.
- OpenAI's own framing offers Luna “for cost-sensitive workloads” and Astra “for complex customer issues that require reasoning.” [OpenAI-published] That is a routing decision, and routing decisions need an owner.
Put four lines in the client agreement and in your vendor agreement: which backend model is the default; whether web search and other tools are enabled per turn; whether the backend can be changed without your written approval (and whether it is logged when it is); and who absorbs the cost of a delegation change. Without them, a platform upgrade can move you from the 79.6% margin row to the 62.0% row overnight, and nothing in the $0.05-per-minute price sheet will have changed. A vendor-risk review that treats voice pricing as the whole exposure will miss this.
Tailwind worth noting for pitch decks: Yelp (Host and Hatch, for reservations, per CTO Alex Levy), Fin, and Cognition/Devin are named in the announcement, and Speak reports “almost 80%” fewer interruptions during thinking pauses in its own early evaluations — a vendor self-report carried on OpenAI's page, so label it that way when you quote it. [OpenAI-published quote; vendor self-reported metric] Custom voices are sales-gated with 12 voices available and marin as the default session voice, and no published price — do not put custom voice pricing in a client model. [OpenAI-published]
Honest limitations: what we could not verify
- No independent reproduction of any benchmark above exists as of 2026-09-10. They are OpenAI-reported figures, including the four charts that carry a backend configuration.
- The 15-second initialization charge is WebRTC-scoped in both places OpenAI states it. Whether WebSocket-created sessions carry the same floor is not stated anywhere we could find. Treat the $0.0125 minimum as a WebRTC number.
- OpenAI does not define whether “session duration” is measured from the session-creation POST or from the session-started event. Under the credit rule the two readings converge for any session of 15 seconds or more, so it only matters for very short calls.
- OpenAI does not state whether $0.05 per minute is introductory. We publish an as-of date (2026-09-10), not a permanence claim.
- The token-per-minute conversion behind the flat-versus-token comparison is ours. OpenAI publishes no fixed audio-tokens-per-minute figure; neither does anyone else with authority. The 600-input / 1,200-output planning assumption and the ~481-output-token break-even are tools for reasoning, not vendor numbers.
- The 2.5× peak factor and the 8/10/12-hour windows are our planning assumptions. OpenAI publishes no call-arrival profile; substitute your client's own histogram before you commit to a tier.
- Telephony, STT/TTS alternatives and labour are outside every number here. OpenAI's meter covers the voice layer and the backend model only.
Frequently asked questions
What does GPT-Live-1 cost per minute?
$0.05 per minute of voice session, billed per second and not rounded up to a whole minute, with the backend model, its tool calls and any web search billed separately at that model's normal rates. [OpenAI-published] The $0.05 is the front-end voice layer only; it is not an all-in per-minute price for a receptionist.
Is the backend model included in the $0.05 per minute?
No. Backend calls are billed separately at the configured backend model's rates, including tool calls and web search. [OpenAI-published rule; our arithmetic for the amounts] On a 4-minute call with 6 turns of 1,500 input and 300 output tokens, the backend adds $0.0040 with Luna (+2.0%), $0.0396 with Terra (+19.8%), $0.0720 with Sol (+36.0%) or $0.1800 with Astra (+90.0%) on top of the $0.20 voice bill.
What is the minimum charge for a GPT-Live-1 session?
$0.0125. Creating a WebRTC session bills 15 seconds of voice duration during initialization, and that amount is credited against duration charges rather than added on top, so the effective rule is max(session seconds, 15). [OpenAI-published, WebRTC-scoped] OpenAI's own worked example bills a 90-second session as 90 seconds, not 105. The WebSocket guide documents no equivalent initialization charge, so do not assume the floor on that path.
What does an AI receptionist cost per call in 2026?
At a 4-minute average on GPT-Live-1: $0.20 of voice, plus backend tokens that range from $0.0040 (Luna) to $0.1800 (Astra) per call on our 6-turn assumption. [Our arithmetic from OpenAI-published rates] Blended, that is $0.051 to $0.095 per minute with a default Terra backend at $0.0599 per minute — before telephony, the phone number, or your own labour, none of which OpenAI's meter includes.
How many concurrent calls can GPT-Live-1 handle?
GPT-Live-1 rate limits are measured in concurrent sessions, not requests per minute: 25 on Tier 1, then 50, 200, 300 and 500 on Tiers 2 to 5. The Free tier cannot call the model at all. [OpenAI-published] For phone lines this is the binding constraint, because every open call holds a session for its whole duration.
When does a client outgrow Tier 1?
Around 1,500 calls a day at a 4-minute average, a 10-hour window and a 2.5× busy-hour peak. [Our arithmetic; the peak factor and window are our planning assumptions] Tier 1's absolute ceiling in that window is about 3,750 four-minute calls a day with no peak headroom, which the 2.5× factor divides down to 1,500. 2,500 calls a day needs Tier 2, and 5,000 needs Tier 3.
Is GPT-Live-1 cheaper than GPT-Realtime-2.1?
For typical call lengths, yes on the voice leg. GPT-Realtime-2.1 audio is $32 per million input and $64 per million output tokens, which is about $0.096 per minute at 600 input and 1,200 output audio tokens per minute, against $0.05 flat. [Rates OpenAI-published; the token-per-minute conversion is our planning assumption] Token metering only wins below roughly 481 output audio tokens per minute at 600 input tokens per minute. The comparison is also a floor: Realtime-2.1 has separate text and image rates, so a real session can bill more than audio alone.
Can I migrate a Realtime integration by swapping the model ID?
No. GPT-Live-1 supports both WebRTC and WebSockets, so the transport is not the blocker, but the event protocol changed (input_audio_buffer.append becomes session.input_audio.append; response.output_audio.delta becomes session.output_audio.delta), there is no event marking the end of each spoken response, manual turn commits and voice-turn triggers are removed, and delegation to a backend model is new. [OpenAI-published] Budget a rewrite of the audio loop and the backend contract, not a config change.
Can I use a non-OpenAI backend model, and who controls that choice?
Yes. OpenAI's announcement says the backend that receives delegated reasoning and tool calls can be a third-party model, and session.update can change the backend model mid-session without starting a new Live session. [OpenAI-published] That is also the lever that moves the second meter, so the delegation default belongs in the client contract: a platform that silently points delegation at a frontier model with web search can multiply the per-call bill without changing the $0.05 sticker.
Does muting the microphone stop the meter?
No. Active session time includes time when the user speaks, the assistant speaks, both are silent, or the backend is working, and muting microphone input does not close the session. [OpenAI-published] Closing the session is what saves $0.05 per idle minute, and a delegated backend can keep working after the voice session closes, so backend spend can accrue with zero voice spend running.
Sources
- OpenAI, “Introducing GPT-Live-1 in the API,” September 10, 2026 (announcement; benchmark chart data read from the page's embedded chart JSON) — https://openai.com/index/introducing-gpt-live-1-in-the-api/
- OpenAI, “GPT-Live-1 model card” (endpoints, snapshots, pricing line, concurrent-session rate limits, Free tier not supported) — https://developers.openai.com/api/docs/models/gpt-live-1
- OpenAI, “Pricing” (GPT-Live session rate; backend model rates; GPT-Realtime-2.1 audio, text and image rows) — https://developers.openai.com/api/docs/pricing
- OpenAI, “Voice latency and cost” (the two-meter total-cost formula, WebRTC initialization charges, the 90-second worked example, billable active-session time) — https://developers.openai.com/api/docs/guides/voice-latency-cost
- OpenAI, “Live sessions” getting-started guide (both transports; billing by duration) — https://developers.openai.com/api/docs/guides/live
- OpenAI, “Migrating to GPT-Live” (event adaptation table, end-of-speech removal, manual commits, delegated backends and the waveform) — https://developers.openai.com/api/docs/guides/live-migration
- OpenAI, “Live conversations” (session lifecycle, usage events, forks, stored-session recording) — https://developers.openai.com/api/docs/guides/live-conversations
- OpenAI, “Delegation” (delegation defaults, service tiers, session.update and mid-session backend changes) — https://developers.openai.com/api/docs/guides/live-delegation
- OpenAI, “WebRTC” and “WebSockets” voice guides (the two documented transports; the WebSocket path with no initialization charge) — https://developers.openai.com/api/docs/guides/voice-websockets
- OpenAI, “Rate limits” (tier qualification thresholds) — https://developers.openai.com/api/docs/guides/rate-limits