OpenAI's Realtime API is the one developers actually call when they need live voice in an app — not GPT-Live, which is a ChatGPT feature with no developer API yet. The headline price, $32 per million audio input tokens, looks brutal, but most people's mental math is wrong: with voice-activity detection and prompt caching, real speech-to-speech traffic runs closer to $0.04 a minute, and the new mini tier cuts that again. This guide breaks down the July 2026 pricing across all four Realtime models, shows how audio tokens actually convert to minutes, and gives concrete cost examples so you can budget without the guesswork.
What the Realtime API is (and why it isn't GPT-Live)
GPT-Live, launched July 8, 2026, is OpenAI's full-duplex voice model — it can listen and speak at the same time — and it powers the new ChatGPT Voice experience. It is not yet available as a developer API; OpenAI says it's "coming soon" and is taking sign-ups. If you want to build a voice product today, the thing you wire up is the Realtime API: a separate family of models (gpt-realtime-2.1, the cheaper gpt-realtime-2.1-mini, plus dedicated translate and whisper models). GPT-Live is widely understood to be the production release of the model OpenAI was testing in 2025 under the GPT-Bidi-1 name — for the full architecture story, see our earlier breakdown. For pricing, stay on this page: from here on, "Realtime" means the API models.
Current Realtime API pricing (July 2026)
These are the live rates on OpenAI's pricing page, verified July 9, 2026. Audio and text bill per million tokens; the two specialized models bill per minute.
Model | Modality | Input | Cached input | Output |
|---|---|---|---|---|
gpt-realtime-2.1 | Audio | $32.00 | $0.40 | $64.00 |
gpt-realtime-2.1 | Text | $4.00 | $0.40 | $24.00 |
gpt-realtime-2.1 | Image | $5.00 | $0.50 | — |
gpt-realtime-2.1-mini | Audio | $10.00 | $0.30 | $20.00 |
gpt-realtime-2.1-mini | Text | $0.60 | $0.06 | $2.40 |
gpt-realtime-2.1-mini | Image | $0.80 | $0.08 | — |
gpt-realtime-translate | Audio (per min) | — | — | $0.034/min |
gpt-realtime-whisper | Audio (per min) | — | — | $0.017/min |
Three things are worth noticing before the $32 figure panics you. First, the mini tier (gpt-realtime-2.1-mini) is roughly a third of the flagship — $10/$20 audio versus $32/$64 — and for many voice apps it handles the conversation well. Second, cached audio input drops to $0.30–$0.40 per million, which matters because most sessions resend the same system prompt and tool definitions every turn. Third, the audio per-token rate ($32/$64) has actually been stable since the 2025 gpt-realtime-2 release, having fallen from $40/$80 and $100/$200 in 2024 — so the 2026 story is less "they cut the price" and more "they added a cheap mini tier and reasoning controls."
Token vs minute: why your estimate is probably wrong
The same question fills the OpenAI developer forum over and over: "$100 per million tokens, or $0.06 per minute — which is it?" Both numbers have appeared in OpenAI's own docs at different times, for the same model. The reason people get sticker shock — one developer wrote that they "can't even test this without burning my wallet" — is that raw token math ignores three things that dominate the real bill.
You don't pay for silence. OpenAI's server-side voice activity detection (VAD) is designed to filter out non-speech, so silence, pauses, and hold time usually contribute little to the bill — confirm it in your own usage logs.
Most of your input is cached. A system prompt plus tool schemas is sent on each turn; with prompt caching that prefix bills at $0.30–$0.40/M instead of $32/M — close to 80× cheaper.
Talk-time ratio varies enormously. A 10-minute "call" might contain two minutes of actual speech in each direction. The bill tracks speech, not wall-clock time.
Stack those together and the per-minute figure swings wildly depending on who's measuring. A few anecdotal reports from developers who posted their bills:
@kwindla (Aug 2025): ~$0.04 per minute of speech-to-speech, factoring in implicit token caching, plus about $0.20/hour just to stay connected.
@kevintpayne (May 2026): ~$18/hour (≈ $0.30/min) in a heavier talk-time workload.
@leonardsaros (Jul 2026): an estimate of ~$1/minute — likely using different assumptions about VAD, caching, or talk-time, the same trap as above.
That's a 25× spread on the "same" price. The takeaway: don't estimate from the token rate alone. Run a real session, log input/output tokens and speech minutes, then divide. As a planning range, expect $0.04–$0.10/minute for gpt-realtime-2.1 in a typical assistant with caching and VAD enabled, and roughly a third of that on the mini tier.
What a real conversation costs
Estimating from the verified per-minute range is more reliable than multiplying token rates. Take two reference workloads.
Customer support — 1,000 calls/day, ~4 minutes caller + 1 minute agent speech each. At ~5 minutes of billed speech per call and a blended $0.08/minute on gpt-realtime-2.1 (mid-range, with caching and VAD), that's about $0.40/call, or roughly $12,000/month at 1,000 calls/day. The same load on gpt-realtime-2.1-mini drops to around $0.13/call (~$4,000/month) — provided the mini model handles your tool calls and reasoning, which for straightforward IVR and FAQ flows it usually does.
Voice assistant — 100 daily active users, 3 short sessions each. Say ~1.5 minutes of speech per user per day. At $0.08/min on 2.1, that's ~$0.12/user/day, or about $360/month; on mini, closer to $120/month.
These are planning figures, not quotes — your real number depends on talk-time ratio, reasoning effort, and how cacheable your prompts are. The order of magnitude is the point: with caching and VAD, live voice is no longer the "only worth it if you have an existing business" luxury it was back in 2024. For a broader look at budgeting OpenAI API costs across model families, see our GPT-4o reasoning API cost guide.
Reasoning effort and the mini tier: where the money goes
gpt-realtime-2.1 exposes five reasoning levels — minimal, low (default), medium, high, xhigh (OpenAI docs). Higher effort means more thinking tokens, more latency, and a bigger bill on the text-output meter. The default low is right for most conversational apps; reserve high/xhigh for turns that need multi-step reasoning or complex tool use, then drop back down.
The mini tier is the bigger lever. gpt-realtime-2.1-mini is roughly 3× cheaper on audio and text and still does function calling, interruptions, and natural turn-taking. A practical rule of thumb: mini for the bulk of turns that are retrieval or confirmation, 2.1 for the turns that need real reasoning. Routing by complexity that way can cut a session's cost substantially when most of your traffic is simple.
Translate and Whisper: the per-minute bargains
Two Realtime models don't use token pricing at all, and they're the cheapest options for their jobs:
gpt-realtime-translate — $0.034/minute, translating speech from 70+ input languages into 13 output languages in real time. For multilingual support lines or live interpretation, this is cheaper than running the full 2.1 model and is tuned specifically for translation.
gpt-realtime-whisper — $0.017/minute, streaming speech-to-text. Cheaper still, and useful when you need live captions or a transcript feed without a full voice conversation.
If your job is translation or transcription rather than open-ended voice chat, reaching for these instead of gpt-realtime-2.1 is the single biggest cost saving available.
How to pay less
Beyond model and reasoning-tier choice, the standard Realtime cost levers:
Keep VAD on. Non-speech shouldn't bill, but only if silence is actually filtered — verify your session isn't streaming dead air.
Trim audio output first. Generated speech (the $64/M side) is the steepest meter. Concise replies, summaries, or dropping to text after the first voice turn compounds fast.
Make prompts cacheable. Keep your system prompt and tool schema static and at the front of the context so they hit the cached rate; rotating them each turn throws away the 80× discount.
Compress long sessions. Summarize conversation state every few turns instead of replaying the full transcript, which re-bills input tokens.
Route by complexity. Mini by default, escalate to 2.1 only when a turn needs it.
Relay endpoints that resell the same OpenAI Realtime models at a lower per-token rate are one more option — the API surface is identical, so integration is unchanged; AIReiter is one example.
FAQ
Does GPT-Live use the Realtime API?
Not directly. GPT-Live is a ChatGPT voice feature that isn't exposed as a developer API yet. The Realtime API models (gpt-realtime-2.1 and friends) are the developer-facing equivalent you can call today.
Is the OpenAI Realtime API expensive?
Less than the token rate suggests — with VAD and caching it's roughly $0.04–$0.10/minute on 2.1 and far less on mini. The token-vs-minute section above explains why estimates vary so widely.
How much does the Realtime API cost per minute?
There's no single number — it depends on talk-time ratio, reasoning effort, and caching. A well-tuned 2.1 session runs about $0.04–$0.10/min; the mini tier roughly a third of that; translate and whisper are flat at $0.034 and $0.017/min.
How do audio tokens convert to minutes?
Don't trust a token-to-minute rule of thumb — work it out from your own usage logs. For a gpt-realtime-2.1 session, sum the billed tokens across every meter: uncached audio input × $32/1M + cached audio input × $0.40/1M + audio output × $64/1M + text input × $4/1M + text output × $24/1M (add image input × $5/1M if you send images), then divide by the minutes of actual speech. That real blended figure, with VAD and caching in play, lands far below naive token math.
Realtime API vs ElevenLabs or Grok Voice?
ElevenLabs excels at TTS quality and is competitive for narration-only flows; the Realtime API wins on integrated reasoning and tool use. xAI's Grok Voice Agent has reportedly launched at a flat $0.05/minute (source), roughly half a typical 2.1 setup — cheaper for pure voice, with fewer multimodal features. Google's Gemini omni models are another realtime option worth pricing out.
What is cached audio input, and how much does it save?
Cached input bills at $0.30–$0.40/M instead of $10–$32/M for repeated prefixes like your system prompt and tools. On a session that reuses a large prompt each turn, it's the difference between a reasonable bill and a shocking one.
Bottom line
For most voice apps in 2026, start on gpt-realtime-2.1-mini for the bulk of turns, escalate to gpt-realtime-2.1 only when a turn needs real reasoning, and use translate or whisper if your job is specifically multilingual or transcription. Keep VAD on, design prompts to cache, and trim generated speech. Do that and Realtime usage budgets in the low cents per speech-minute for most apps — far below the $1/minute figure floating around, and closer to the $0.04 the well-optimized setups actually see.