Five cents a minute drops to two — but only while you're not talking: OpenAI adds a standby rate to voice sessions, and four traps along with it
The short version
On November 19, OpenAI's API changelog carried two things at once: a new voice model, gpt-live-1.1, and a standby rate for GPT-Live WebRTC sessions. While the user is silent, the voice session now bills at $0.02 a minute instead of $0.05 — a 60% cut. It is the first time anyone in this market has priced "quiet" as its own line item. The discount comes with conditions: it only applies to WebRTC sessions, it has to be triggered by an idle timeout between 5 and 60 seconds, muting the microphone does not count as standby, and creating a session bills 15 seconds of voice time up front.
What this actually is
Split GPT-Live into two halves.
One half is the mouth and ears: it listens and speaks at the same time — OpenAI calls this full duplex — so it does not wait for the caller to finish before it starts forming a reply. The other half is the brain: the model or agent sitting behind it that looks up an order, calls a tool, and makes decisions. OpenAI calls that handoff delegation.
That split defines the bill. The voice session is charged by duration. The backend model and tools are charged separately at their own token rates. Swapping in a more expensive backend does not change the voice line; nor does saving money on voice rescue a backend that burns tokens.
gpt-live-1.1 is the second revision on that line, and the model page is deliberately understated. Three improvements, one sentence each: more accurate pronunciation in multilingual conversations, a more consistent accent and voice across languages, and more accurate transcription. No new endpoint, no new parameter. The migration is a model ID change from gpt-live-1 to gpt-live-1.1. Vercel put it on AI Gateway the same day with the same framing: existing integrations only need the new model ID.
The genuinely new part is not the model. It is the invoice.
Why it matters now
Running a full-duplex voice service used to hide one unavoidable cost: every second the session stayed open was billed, whether or not anyone spoke. A user walking to the kitchen, thinking for three seconds, or setting the phone down was still burning $0.05 a minute.
Rental-car support lines, in-car assistants, and language-tutoring apps feel this most. The session has to stay open waiting for the user, but actual speech may be only a third of it.
OpenAI's answer is to split session state in two:
- Active: $0.05 a minute. Covers speech, silence before the idle timeout fires, and time spent waiting on backend work while inference is running.
- Standby: $0.02 a minute. Applies while inference is paused and the connection stays open.
An hour of entirely silent session used to cost $3.00. It now costs $1.20. That is not a discount so much as a decision to price idling separately from talking.
Against peers, the number is not the cheapest, but the structure is the most granular:
- Microsoft's MAI Realtime 1 is $0.01 a minute, with reasoning billed on top at $1 per million input tokens and $5 per million output tokens. No standby tier.
- Resia Fullplex-1 is $0.025 a minute all-in, also with no tiers.
- phonic-1 runs about $0.07 a minute ($4.20 an hour), likewise untiered.
In other words, OpenAI's per-minute price is the highest of that group. What it introduced is a separate quote for the silent hour. For businesses whose sessions sit open for long stretches, the structure is worth more than the headline rate.
How to use it: four steps to turn standby on
Standby is not a switch. It is the product of several parameters.
- Create a WebRTC session. This is the hard gate: OpenAI states plainly that standby applies to WebRTC sessions. Telephone traffic over WebSocket or SIP sits outside this update.
- Set
session.wake_policy.typetospeech. The session then waits for detected speech before starting inference. This decides whether the period right after connecting counts as active. - Set
session.idle_timeout_sto a whole number of seconds between 5 and 60. Once that many seconds pass without an input or output transcript, inference pauses and the session enters standby. Leave the field out, and the session stays active from the first wake until it ends — an easy place to overspend without noticing. - Listen for
session.pausedandsession.resumed. The first means the timeout fired and the session is in standby, with the connection and sideband still open. The second means inference is ready again.
One optional field: session.wake_policy.vad_threshold, from 0 to 1, defaulting to 0.5. It sets how much evidence of speech the server's voice activity detector needs before waking. Raising it makes background noise less likely to trigger a wake, and a quiet speaker more likely to be missed.
What happens during standby
This is where people misread the feature. Standby is neither a disconnect nor a suspended process:
- Keep the microphone track alive, or nothing can wake the session.
- The connection and the session ID stay the same.
- Conversation history is restored on wake, so the caller does not have to repeat themselves.
- After standby, the first response to a short utterance may take longer. OpenAI says so directly.
That last point matters for product design. If the interface is supposed to speak the instant someone talks, show a listening indicator so the pause does not read as a freeze.
Who it is for: good fit scenarios
- Always-on voice entry points: cars, smart speakers, desktop assistants that sit idle for minutes at a time.
- Support and booking: an agent keeps the session open while the customer checks a document or asks a family member.
- Language tutoring and companionship: users take long pauses, and being cut off feels bad.
- Tasks that push work to a backend agent: the voice side can idle while the backend reasons, instead of making someone listen to ten seconds of dead air.
Not a good fit
- Traffic over the phone network: inbound and outbound SIP, and long-lived WebSocket connections, are outside standby and still bill at the active rate.
- Single-utterance synthesis: text-to-speech endpoints such as
v1/audio/speechare explicitly unsupported bygpt-live-1.1. - Responses or Chat Completions only:
gpt-live-1.1is wired tov1/live/sessionsalone; every other endpoint is listed as not supported. - Replacing a transcription service:
v1/audio/transcriptionsandv1/realtime/transcription_sessionsare unsupported too. Transcription needs a different model.
Pitfalls: four traps worth knowing
One: a muted microphone is not standby. The cost documentation is blunt about it — muting input leaves the session active. Saving money means letting it enter standby, not pressing mute. On the invoice these are two different things.
Two: session creation bills 15 seconds up front. Creating a WebRTC session through POST /v1/live/sessions bills 15 seconds of voice duration during initialization by default. That amount is credited against duration charges once the session runs, so it is not lost — but reconnect loops, or sessions created before the user is ready, keep paying it. A 90-second active session already includes those 15 seconds.
Three: the first utterance after standby is slower. OpenAI's wording: after standby, the first response to a short utterance may take longer. If your product is sensitive to time-to-first-audio, budget for that cold start.
Four: concurrency limits are per model. gpt-live-1 and gpt-live-1.1 have separate concurrent-session limits. Switching model IDs does not carry the old headroom over.
Doing the arithmetic
OpenAI's formula is plain: active minutes × $0.05, plus standby minutes × $0.02, plus backend model and tool token charges.
A concrete case: a ten-minute call where four minutes involve speech or backend work, and six minutes pass with the customer reading something and nobody speaking, long enough to trigger standby.
- Before: 10 × $0.05 = $0.50
- After: 4 × $0.05 + 6 × $0.02 = $0.20 + $0.12 = $0.32
A 36% saving. But if those six minutes were spent with the microphone muted and the session never entered standby, the bill stays at $0.50. The difference lives entirely in configuration, not in the model.
Next step: what to do first
- Check whether your sessions run over WebRTC or over WebSocket/SIP. For the latter two, this update changes nothing about your bill.
- Set
idle_timeout_sexplicitly in the session creation payload, even if you start with 30 seconds. Omitting it means staying active. - Set
wake_policy.typetospeechso the "connected but nobody has spoken yet" window stops billing as active. - Wire
session.pausedandsession.resumedinto the interface state, so nobody talks into a silent microphone icon. - Replay a real recorded call, compare the
usage.secondsdistribution before and after, and then pick youridle_timeout_s. The right value depends on how long your callers pause. There is no universal answer.
Sources
- OpenAI API changelog, entry dated November 19, 2026: https://platform.openai.com/docs/changelog
- OpenAI
gpt-live-1.1model page (pricing and endpoint support): https://platform.openai.com/docs/models/gpt-live-1.1 - OpenAI GPT-Live session docs (standby configuration,
idle_timeout_s, paused/resumed events): https://platform.openai.com/docs/guides/live-conversations - OpenAI voice cost guide (15-second initialization charge, muted microphone still active): https://platform.openai.com/docs/guides/voice-latency-cost
- Vercel AI Gateway changelog (listed the same day): https://vercel.com/changelog/gpt-live-1-1-now-available-on-ai-gateway