GPT-Live-1 Voice Agent Cost per Minute: $0.05 Plus the Backend Bill
The two-meter problem in one line: GPT-Live-1 bills voice at a flat $0.05 per minute, charged by the second, while the backend half of the same call bills by the token at whatever reasoner you delegate to — so the bill scales with how hard callers make the agent think, not with how long they talk, and a 4-minute call is $0.2000 of voice plus anywhere from $0.0040 to $0.78 of backend reasoning on the call shapes below.
The two meters are what separates GPT-Live-1 from every earlier voice API. The voice layer is priced like a phone line and meters like a stopwatch; the reasoning layer is priced like text and meters like an API. You can budget the first one from a call log and you cannot budget the second one without knowing your turn count, token shape and tool-call share. This page prices both meters on the same call, sizes the concurrent-session ceiling that actually constrains a phone line, and is deliberately explicit about which numbers are OpenAI-published and which are our modelling assumptions. The interactive GPT-Live-1 cost calculator holds the full parameter set; the worked examples below are produced by the same model code it runs.
The billing model, exactly as OpenAI publishes it
| Rule | What it says | Where it is published |
|---|---|---|
| Voice rate | $0.05 per minute of voice session, per model | Model card, pricing page, cost guide OpenAI-published |
| Meter | Billed per second, with no round-up to the next whole minute | Model card: "Session duration is not rounded up to the next whole minute" OpenAI-published |
| Billable basis | Active session time: caller speaking, assistant speaking, mutual silence, or the backend working. Muting the mic does not close the session. | Voice latency & cost guide OpenAI-published |
| WebRTC init | A POST /v1/live/sessions WebRTC session bills 15 seconds at creation, credited against duration once it runs — a floor, not an adder | Voice latency & cost guide, WebRTC guide OpenAI-published |
| Backend | Backend Responses calls, tool calls and web search bill separately at the configured model's normal rates | Pricing page, cost guide, delegation guide OpenAI-published |
| Month length | OpenAI defines no month; every monthly figure here states its day count | Our convention |
Per-second billing in practice
The rate is per minute and the meter is per second, which is why the arithmetic an agency quotes is not "minutes × $0.05". On the published rate table:
| Session length | Billed seconds | Voice cost | Note |
|---|---|---|---|
| 0:40 | 40 s | $0.0333 (3.33¢) | No round-up: a 40-second call is not a $0.05 minute |
| 0:05 (WebRTC) | 15 s | $0.0125 | The 15-second init floor governs: the shortest possible WebRTC session |
| 0:05 (WebSocket) | 5 s | $0.0042 | No init charge is documented on the WebSocket path |
| 1:30 | 90 s | $0.0750 | OpenAI's own worked example: billed as 90 s, "not ... 105 seconds" |
| 4:00 | 240 s | $0.2000 | The default call shape used throughout this page |
| 10:00 | 600 s | $0.50 | Flat across the hour: no volume discount, no peak tariff |
The init rule, stated as a formula: billed_seconds = max(session_seconds, 15) for WebRTC; session_seconds for WebSocket, where no init charge is documented. The 15 seconds is credited rather than stacked — the reason OpenAI's 90-second example bills as 90 seconds and not 105. Two consequences worth quoting to a client: the cheapest possible WebRTC session is $0.0125, and an application that creates sessions before the caller is ready to speak pays for the privilege. Reconnects are billed the same way, so a flaky transport is a line item rather than a rounding error.
What the $0.05 does not include
- The backend model. Delegated Responses calls bill at that model's published token rates, including cached input where supported.
- Tool calls and web search. Hosted tools such as web search bill at model rates on top of the turns that triggered them.
- Telephony and your own infrastructure. GPT-Live-1 is the voice layer; the carrier, number and any media path are separate vendors.
- Idle voice time. Silence and backend-waiting time are billable at $0.05 a minute; at a 30% idle share on the default shape that is $0.0600 per call and $60.00 a day across 1,000 calls. Closing the session is what stops that meter.
GPT-Live-1 (flat per minute) vs GPT-Realtime-2.1 (audio tokens)
The comparison that matters for procurement is not interactivity — it is whether a flat per-minute rate beats token-metered audio on your call shape. GPT-Realtime-2.1 meters audio at $32 per 1M input and $64 per 1M output audio tokens (OpenAI-published, Standard tier). Converted to a per-minute rate:
| Token shape per voice minute | Realtime-2.1 audio rate | Realtime 4-min call | GPT-Live-1 flat 4-min call | Cheaper |
|---|---|---|---|---|
| 600 in / 600 out planning assumption | $0.0576/min | $0.2304 | $0.2000 | Flat rate, by $0.0304 |
| 600 in / 1,200 out planning assumption | $0.0960/min | $0.3840 | $0.2000 | Flat rate, by $0.1840 |
| 300 in / 600 out planning assumption | $0.0480/min | $0.1920 | $0.2000 | Token metering, by $0.0080 |
| 600 in / 0 out (listen-only) | $0.0192/min | $0.0768 | $0.2000 | Token metering, by $0.1232 |
Where the flat rate wins: any conversational call that talks as much as it listens. At 600 input and 600 output audio tokens per minute the flat rate is $0.05 against $0.0576; at 600 in / 1,200 out it is $0.05 against $0.0960, and the 4-minute gap widens to $0.1840 per call — $184.00 a day at 1,000 calls. Where token metering would have been cheaper: output-light sessions. The break-even is the output-token rate at which Realtime audio equals $0.05 a minute — about 481 output audio tokens per minute at 600 input, 631 at 300 input, or 781 if there is no input audio at all (the Realtime calculator prints the combined break-even for your own in:out mix: 1,042 tokens a minute at 1:1).
Model the floor, not the total, when you compare: $32/$64 are GPT-Realtime-2.1's audio rows. The same model also publishes text ($4/$24 per 1M) and image ($5 per 1M) rows, so a real Realtime session can bill more than audio tokens alone — the comparison above is a floor for the token-metered side, which makes the flat rate's advantage, not its cost, the conservative reading. The tokens-per-minute conversion itself is our planning assumption; OpenAI publishes no fixed audio-token-per-minute figure.
Normalize "$0.05 a minute" before you compare vendors. The same number buys three different things: at OpenAI it is the voice layer only (backend, tools and search on top); Telnyx publishes $0.05 per minute as an all-in voice-engine rate with the LLM and telephony stacked on it (its own material puts a realistic all-in figure near $0.056 a minute); xAI's Grok Voice Agent API publishes a flat $0.05 a minute on its own terms. Ranking sticker prices across those three is comparing a component to a system. The safe quote for a client is always the two-meter total on this page: voice seconds plus backend tokens, with the backend model named.
Worked examples: what a phone line actually bills
Every figure in this section is produced by the same cost model the GPT-Live-1 cost calculator runs, and the comparison table at the end of the section was re-checked against the calculator's rendered output. The call shape is the calculator's default: 6 reasoning turns of 1,500 input / 300 output tokens per call, a 35% tool-call share (with no separate tool fee, so the share only changes turn shapes), a 30% idle share, WebRTC transport, and a 30-day month.
Two-meter estimator (same model as the calculator)
Change any field to re-price the call. Voice is OpenAI's published $0.05/min per second with the 15-second WebRTC floor; the backend line uses each model's published token rates. Volume, turn, token and tool inputs are modelling assumptions you own.
Tier 1 (ceiling 25): the peak of 8.33 sessions fits, with headroom for 16.67 more. Budget is the binding constraint at this volume, not capacity.
Realtime-2.1 audio at 600 in / 600 out per minute would bill $0.0576/min, i.e. $0.2304 for this call — the flat rate wins. Sources and provenance: full calculator (JSON export included).
Example 1 — the default: 4:00 calls at 1,000 a day
| Line | Per call | Per day (1,000 calls) | Per month (30 days) |
|---|---|---|---|
| Voice meter — 240 s × $0.05/min | $0.2000 | $200.00 | $6,000.00 |
| Backend meter — GPT-5.6 Terra, 6 turns × 1,500 in / 300 out | $0.0396 | $39.60 | $1,188.00 |
| Two-meter total | $0.2396 | $239.60 | $7,188.00 |
The voice half is the number an agency can quote from a call log: $200.00 a day, $6,000.00 in a 30-day month ($6,200.00 over 31 days, $6,083.33 as a calendar-average month) — before a single backend token. The backend half is small on this shape ($19.8% of the voice bill) precisely because Terra is mid-priced and the turns are short. Change either and it stops being small.
Example 2 — the same 4-minute call under every published backend
| Backend (6 turns × 1,500 in / 300 out) | Backend $/call | Backend as % of voice | Total $/call | Total $/day (1,000 calls) |
|---|---|---|---|---|
| GPT-5.6 Luna ($0.20 / $1.20 per 1M) — cost-sensitive | $0.0040 | 2.0% | $0.2040 | $203.96 |
| GPT-5.6 Terra ($2.00 / $12.00) — OpenAI's published example | $0.0396 | 19.8% | $0.2396 | $239.60 |
| GPT-5.6 Sol ($4.00 / $20.00, promo through Nov 21, 2026) | $0.0720 | 36.0% | $0.2720 | $272.00 |
| GPT-6 Astra ($10.00 / $50.00) — complex issues | $0.1800 | 90.0% | $0.3800 | $380.00 |
| GPT-6 Astra, long context + 10% data-residency uplift | $0.3465 | 173.2% | $0.5465 | $546.50 |
The delegation choice is a bigger lever than the voice price. The voice meter is fixed at $0.2000 for this call under every row; the backend meter ranges from $0.0040 to $0.1800 — a 45× spread on the same conversation, set entirely by which model the voice layer hands work to. At a $0.25-a-minute retail rate ($1.00 for a 4-minute call), the gross margin on the call is 80.0% with no backend at all, 79.6% on Luna, 76.0% on Terra and 62.0% on Astra.
Example 3 — cheap voice, expensive reasoner: the backend blowout
The failure mode to price before you sell it: keep the voice layer as the cheapest thing on the invoice and point delegation at a frontier model with a high tool-call share. The calculator's "Backend blowout" preset (GPT-6 Astra, 10 turns of 3,000 in / 800 out, 80% of turns calling a $0.01 tool with 1,200 extra input tokens) produces:
| Meter | Per call | Per day (1,000 calls) | Per month (30 days) |
|---|---|---|---|
| Voice — unchanged 4:00 session | $0.2000 | $200.00 | $6,000.00 |
| Backend model tokens | $0.7960 | $796.00 | $23,880.00 |
| Tool invocations | $0.0800 | $80.00 | $2,400.00 |
| Total | $1.0760 | $1,076.00 | $32,280.00 |
Voice is 18.6% of that bill; the backend is 81.4% — a backend bill of $0.8760 against $0.20 of voice, or 438% of the voice cost on a call whose voice price never moved. A second, tool-free stress case (12 turns of 4,000 in / 500 out on Astra) lands at $0.78 of backend on a $0.20 voice bill: $0.98 a call, 4.9× the voice-only figure and $29,400.00 a month at 1,000 calls a day. Neither case is exotic — both are the natural result of a long, tool-using support call.
Price your own call shape, both meters, in the full calculator
Open the GPT-Live-1 cost calculator →Editable backend rates, cached-input share, tool fees, long-context and data-residency uplifts, a concurrency planner against every tier, a Realtime break-even and a JSON export you can hand to a client.
Capacity planning: GPT-Live-1 limits are concurrent sessions, not requests per minute
This is the second citable fact on the page, and the one that breaks launch-week calculations. Rate limits for GPT-Live are measured in concurrent sessions, and the Free tier cannot call the model at all. A phone line is therefore sized with Little's Law, not with a tokens-per-minute budget:
required_concurrent = (calls per day ÷ open hours) × average call seconds ÷ 3600 × peak factor
| Tier | Concurrent sessions | Qualification (OpenAI-published) | 4-min calls/day at the ceiling (10 h window, average) |
|---|---|---|---|
| Tier 1 | 25 | $5 paid and $100 a month of API spend | 3,750 |
| Tier 2 | 50 | $50 and $500 a month | 7,500 |
| Tier 3 | 200 | $100 and $1,000 a month | 30,000 |
| Tier 4 | 300 | $250 and $5,000 a month | 45,000 |
| Tier 5 | 500 | $1,000 and $200,000 a month | 75,000 |
| Free | not supported | GPT-Live sessions are unavailable on the Free tier | — |
The right-hand column is our arithmetic on OpenAI's ceilings: a tier's concurrency limit covers its ceiling × the minutes in your window ÷ your average call length. The practical version of the same table is the volume ladder, at a 4-minute average call, a 10- or 12-hour window and a 2.5× busy-hour peak:
| Calls/day | Window | Average concurrent | Peak at 2.5× | Voice cost/day | Tier required |
|---|---|---|---|---|---|
| 1,000 | 8 h | 8.33 | 20.83 | $200.00 | Tier 1 (25) — 83% of the ceiling |
| 1,000 | 12 h | 5.56 | 13.89 | $200.00 | Tier 1 (25) |
| 1,500 | 10 h | 10.00 | 25.00 | $300.00 | Tier 1 — exactly at the ceiling |
| 1,600 | 10 h | 10.67 | 26.67 | $320.00 | Tier 2 (50) — the break point |
| 2,500 | 10 h | 16.67 | 41.67 | $500.00 | Tier 2 (50) |
| 5,000 | 10 h | 33.33 | 83.33 | $1,000.00 | Tier 3 (200) |
| 10,000 | 12 h | 55.56 | 138.89 | $2,000.00 | Tier 3 (200) |
Where Tier 1 actually breaks: on average concurrency, Tier 1's 25 sessions cover about 3,750 four-minute calls a day in a 10-hour window. Price the same line against a realistic 2.5× noon peak and the ceiling arrives at ~1,500 calls a day — 1,600 calls a day already needs Tier 2 (peak 26.67 sessions) even though the average is only 10.67. At 5,000 calls a day in a 10-hour window the peak requirement is 83.33 sessions, which is why the answer to "how many concurrent calls can GPT-Live-1 handle?" is a tier question with a peak-factor clause, not a single number. Two operational corollaries: the WebRTC 15-second init floor makes reconnect storms expensive, and the same concurrency budget is what your carrier's trunk sizing has to match — a Tier-1 account cannot absorb an unlimited-retry client.
Migration reality check: a protocol and delegation rewrite, not a model-ID swap
GPT-Live-1 is not the Realtime API with a new model string. It documents two transports — WebRTC for browser voice applications and WebSockets for server-side audio (wss://api.openai.com/v1/live/sessions) — but the event contract differs from Realtime, and delegation is new:
- 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. Logic that waited for a response boundary has to be rebuilt around session-level events.
- Manual turn control is gone. The migration guide is explicit: stream audio continuously, GPT-Live decides when to speak, and manual audio commits and voice-turn triggers are removed.
- Delegation is the new layer. The voice frontend delegates work to a backend model instead of issuing ordinary structured function calls, which is also why a delegated backend does not automatically receive the waveform — and why backend cost can accrue after the voice session closes ("backend work may outlive the voice session").
- One model ID, one snapshot. gpt-live-1 is its own default snapshot; there is no dated variant to pin for reproducibility.
- A deliberately narrow endpoint surface. Live Sessions (v1/live/sessions) is the supported endpoint; Chat Completions, Responses, Realtime, Assistants, Batch, fine-tuning, embeddings, image generation and edits, video, speech/transcribe and translation endpoints, and moderation are all documented as not supported for this model. Structured outputs, fine-tuning and predicted outputs are unsupported features; streaming and function calling are supported; the knowledge cutoff is July 31, 2025.
- Voices are fixed and custom voices are sales-gated. Twelve voices ship with the model (Quartz, Ripple, Vesper, Willow, Stone, Gleam, Meridian, Bossa, Tempo, Beacon, Delta, Cinder), the default session voice is marin, and custom voice access is a contact-sales request. Do not model a custom-voice line item against a public rate — none is published.
Budget the migration as engineering, not configuration: a transport and event-mapping rewrite, a replacement for every turn-control assumption, and a new delegation path with its own tool and token budget. The voice price does not change during that work; the schedule does.
What the benchmarks do and do not say
Every figure below is OpenAI-published and not independently reproduced — OpenAI's announcement renders them as charts, and four of them were measured with a specific backend attached, which is why the configuration column is part of the number rather than a footnote:
| Evaluation (OpenAI-published) | GPT-Live-1 | GPT-Realtime-2.1 | GPT-Realtime-2 | Backend configuration |
|---|---|---|---|---|
| Full Duplex Bench v1.5 Interactivity | 80.10% | 45.4% | 47.8% | — |
| Full Duplex Bench v1 Turn-taking latency | 0.798 s | 1.41 s | 1.63 s | — (lower is better) |
| Tau3 (Voice) pass@1 | 86.2% | 45.7% | 42.4% | GPT-Live-1 backend: Astra, medium reasoning effort |
| Tau Banking (Voice) pass@1 | 32.0% | 12.4% | 10.3% | GPT-Live-1 backend: Astra, medium reasoning effort |
| Full Duplex Bench v3 Tool calling | 87.0% | 60.0% | 58.0% | GPT-Live-1 backend: Terra, low reasoning effort |
| Full Duplex Bench v3 Response quality | 90.0% | 88.0% | 81.0% | GPT-Live-1 backend: Terra, low reasoning effort |
| Artificial Analysis Conversational Dynamics | 97.3% | 95.7% | 95.3% | Reported by OpenAI on OpenAI's page |
- Read the banking row before you sell a regulated workflow. Tau Banking (Voice) at 32.0% pass@1 means roughly two-thirds of the 97 published banking_knowledge tasks still fail with an Astra-medium backend — a large improvement over 12.4%, and still not a number to put in front of a compliance team as "solved".
- One internal inconsistency, flagged rather than reconciled. OpenAI's announcement prose describes Full Duplex Bench performance as ahead "by 30 percentage points"; its own chart for the same benchmark shows 80.10% against 45.4%, a 34.70-point gap. We quote the chart figures and attribute the prose as prose — we do not silently average the two.
- Latency is a meter, too. A 0.798-second turn-taking figure is a product claim about pacing; whether 0.8 s of dead air is acceptable in your vertical is a design decision, not a benchmark.
- Named deployments are vendor statements. OpenAI's page attributes Yelp Host and Hatch (reservations and food orders) to Alex Levy, Yelp's CTO; a ~80% reduction in interruptions during thinking pauses to Speak's co-founder and CTO Andrew Hsu as that vendor's own early evaluation; and quotes from Fin (Jordan Neil, COO) and Cognition's Devin (Walden Yan, co-founder and CPO). Picsart, Heygen and OpenAI's own Presence product are also named, with Presence gated behind an account director. None of these is an independent measurement, and none includes a cost figure.
- $0.05 is an as-of price, not a permanent one. OpenAI states no expiry or permanence. Date every quote: rate and tiers here are as of 2026-09-10.
How to model your own voice-agent bill
- Log the voice meter first. Session seconds and the billed-seconds figure from the API (not your audio playback time) give the irreducibly simple half: seconds ÷ 60 × $0.05.
- Log turns and tokens per call type. Backend cost is turn count × (input and output tokens at the backend model's rates) — a 35% tool-call share with no extra tokens changes nothing, but 1,200 extra input tokens on 80% of turns changes everything.
- Choose the backend deliberately. Luna, Terra, Sol and Astra differ by up to 45× on an identical conversation. OpenAI suggests Terra as the starting point, Luna for cost-sensitive volume and Astra for complex issues; a third-party model is allowed.
- Size concurrency from the peak, not the average. Apply the formula above with your own busy-hour factor, then check it against the tier ceiling — a capacity-limited line fails even when the budget is fine.
- Re-check quarterly. Backend token rates move (Sol's promo runs through Nov 21, 2026), and no independent reproduction of the benchmark figures exists yet.
Frequently asked questions
What does GPT-Live-1 cost per minute?
A GPT-Live-1 voice session costs $0.05 per minute, billed per second and not rounded up to the whole minute, with the backend model, its tool calls and any web search billed separately at that model's normal rates. [OpenAI-published]
Is GPT-Live-1 billed per second or per minute?
Both: the rate is per minute ($0.05) and the meter is per second. A 40-second call bills $0.0333, not $0.05, and a 4-minute call bills $0.2000. [OpenAI-published]
Is the backend model included in the $0.05 per minute?
No. The $0.05 buys only the voice layer. Backend Responses calls, tool calls and web search bill separately at the configured backend model's rates, so on our default call shape a 4-minute call is $0.2000 of voice alone, $0.2040 with a GPT-5.6 Luna backend, $0.2396 with GPT-5.6 Terra, $0.2720 with GPT-5.6 Sol and $0.3800 with GPT-6 Astra. [OpenAI-published rule; our arithmetic]
What is the minimum charge for a GPT-Live-1 session?
$0.0125. Creating a WebRTC session bills 15 seconds of voice duration up front, credited against the running session rather than stacked on top, so the effective rule is max(session seconds, 15). OpenAI's own example bills a 90-second session as 90 seconds, not 105. The WebSocket guide documents no equivalent init charge. [OpenAI-published, WebRTC-scoped]
What does 1,000 GPT-Live-1 calls a day cost?
At a 4-minute average, 1,000 calls a day is 4,000 voice minutes, or $200.00 a day of voice — $6,000 in a 30-day month ($6,200 over 31 days and $6,083 as a calendar-average month) before a single backend token. Add a GPT-5.6 Terra backend at 6 turns of 1,500 input / 300 output tokens and the two-meter total is $239.60 a day and $7,188.00 a month. [Our arithmetic from OpenAI rates]
How many concurrent sessions does GPT-Live-1 allow?
Rate limits are measured in concurrent sessions, not requests per minute: 25 on Tier 1, then 50, 200, 300 and 500 on Tiers 2 through 5. The Free tier cannot call the model. [OpenAI-published]
How do I size concurrency for 1,000 calls a day?
Use concurrent = calls per day × average call seconds ÷ open-hours seconds, then apply a peak factor. 1,000 × 240 seconds over an 8-hour window is 8.33 sessions on average, or 20.83 at a 2.5× noon peak, which still fits inside Tier 1's 25. Over a 12-hour window it is 5.56 on average and 13.89 at peak. [Our formula; tier numbers OpenAI-published]
At what call volume do I outgrow Tier 1?
About 1,500 calls a day at a 4-minute average, a 10-hour window and a 2.5× peak: 1,500 calls lands exactly on the 25-session ceiling and 1,600 needs Tier 2. Measured on average concurrency instead of peak, Tier 1's ceiling is roughly 3,750 four-minute calls a day in a 10-hour window. [Our arithmetic; tier limits OpenAI-published]
Is GPT-Live-1 cheaper than GPT-Realtime-2.1?
For typical call lengths, yes: $0.05 per minute flat against GPT-Realtime-2.1 audio at $32 per 1M input and $64 per 1M output audio tokens. At a planning assumption of 600 input and 600 output audio tokens per minute, Realtime audio is $0.0576 a minute and a 4-minute call $0.2304 versus $0.2000 flat; at 600 in / 1,200 out it is $0.0960 a minute and $0.3840 a call. Token metering only wins below roughly 481 output audio tokens per minute at 600 input (631 at 300 input, 781 with no input audio). The tokens-per-minute conversion is our assumption, not an OpenAI figure. [Rates OpenAI-published; conversion and break-even ours]
Can I use a non-OpenAI backend model with GPT-Live-1?
Yes. GPT-Live-1 delegates reasoning and tool calls to a backend text model, and OpenAI's announcement states that backend can be a third-party model — which is also the lever that moves the backend half of the bill. [OpenAI-published]
Why is migrating my Realtime integration to GPT-Live-1 not a model-ID swap?
Because the integration changes, not just the model name. The event protocol is different (input_audio_buffer.append becomes session.input_audio.append; response.output_audio.delta becomes session.output_audio.delta), GPT-Live has no event marking the end of each spoken response, manual audio commits and voice-turn triggers are removed, and delegation to a backend model is new. GPT-Live does document both transports: WebRTC for browser apps and WebSockets for server-side audio. [OpenAI-published]
Does muting the microphone stop the GPT-Live-1 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. Closing the session is what saves $0.05 per idle minute. [OpenAI-published]
Sources
- OpenAI, "Introducing GPT-Live-1 in the API" (Sept 10, 2026) — primary announcement, pricing and availability, telephony support, named deployments, benchmark charts: openai.com/index/introducing-gpt-live-1-in-the-api
- OpenAI developer docs — GPT-Live-1 model card (rate, endpoints, concurrent-session rate limits, snapshots): developers.openai.com/api/docs/models/gpt-live-1
- OpenAI API pricing (GPT-Live session rate; backend and Realtime-2.1 audio token rates): developers.openai.com/api/docs/pricing
- OpenAI, voice latency & cost guide (per-second billing, the 15-second WebRTC init charge and its credit, "total cost = voice + backend"): developers.openai.com/api/docs/guides/voice-latency-cost
- OpenAI guides — Live Sessions getting started, migration, conversations, delegation, WebRTC and WebSockets transports, rate limits: /guides/live · /guides/live-migration · /guides/live-delegation · /guides/voice-websockets · /guides/rate-limits
- Mirrors read for corroboration (launch coverage; not the source of any rate): unite.ai · the-decoder.com · tbreak.com · testingcatalog.com
- Competitor coverage the page does not rely on: gptlives.com's calculator (ranked for `gpt-live-1 cost calculator`, contains no occurrence of the published $0.05 rate) and aireiter.com's pricing-status page (argues the price is unpublished; contradicted by OpenAI's model card and pricing page as of 2026-09-10). Transport claims from vendor blogs are not used — OpenAI's WebSocket guide documents the server-side path.
- Cross-vendor $0.05 context (third-party vendor pages, read for comparison only): Telnyx voice-AI-agent pricing (all-in engine rate, LLM and telephony on top) — telnyx.com/pricing/voice-ai-agents; xAI Grok Voice Agent API — x.ai/news/grok-voice-agent-api.
Accuracy note: the $0.05 per minute session rate, the per-second billing rule with no round-up, the 15-second WebRTC initialization charge and its credit rule, the backend-billed-separately rule, the concurrent-session tier ceilings (25/50/200/300/500, Free tier unsupported), the GPT-Realtime-2.1 audio token rates ($32 per 1M input, $64 per 1M output) and the benchmark figures are OpenAI-published as of September 10, 2026 and are reproduced from the pages listed above — none of them has been independently reproduced by us, and no part of this page is a quote or estimate from OpenAI. AI voice agents in regulated workflows should be scoped against the published Tau Banking (Voice) pass rate of 32.0%, not against general-purpose benchmarks. The per-call totals, per-day and per-month figures, concurrency requirements, break-even token rates and margin percentages are our arithmetic on those published rates using the modelling inputs printed next to each table (call length, volume, open hours, peak factor, reasoning turns, token shape, tool share, idle share, cache share, month length). The 600 in / 1,200 out and 600 in / 600 out audio-tokens- per-minute conversions are planning assumptions; OpenAI publishes no fixed conversion. Model and rate changes after September 10, 2026 are not reflected. Interactive figures can be reproduced by hand or with the GPT-Live-1 cost calculator, which shares the same published cost model and exports the full parameter set as JSON.
Transport note: GPT-Live-1 documents two transports — WebRTC for browser applications and WebSockets for server-side integrations (wss://api.openai.com/v1/live/sessions) — and the 15-second initialization charge is stated as WebRTC-scoped. Third-party posts that describe the model as WebRTC-exclusive, or that report the server-side path erroring out for a GPT-Live model ID, are contradicted by OpenAI's own WebSocket guide; the migration warning on this page rests on the event-protocol and delegation changes instead.