Speech Models

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

November 22, 20260 views阅读中文原文
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.

  1. 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.
  2. Set session.wake_policy.type to speech. The session then waits for detected speech before starting inference. This decides whether the period right after connecting counts as active.
  3. Set session.idle_timeout_s to 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.
  4. Listen for session.paused and session.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/speech are explicitly unsupported by gpt-live-1.1.
  • Responses or Chat Completions only: gpt-live-1.1 is wired to v1/live/sessions alone; every other endpoint is listed as not supported.
  • Replacing a transcription service: v1/audio/transcriptions and v1/realtime/transcription_sessions are 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

  1. Check whether your sessions run over WebRTC or over WebSocket/SIP. For the latter two, this update changes nothing about your bill.
  2. Set idle_timeout_s explicitly in the session creation payload, even if you start with 30 seconds. Omitting it means staying active.
  3. Set wake_policy.type to speech so the "connected but nobody has spoken yet" window stops billing as active.
  4. Wire session.paused and session.resumed into the interface state, so nobody talks into a silent microphone icon.
  5. Replay a real recorded call, compare the usage.seconds distribution before and after, and then pick your idle_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.1 model 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

Sources

Comments

0 published
Log inorsign up to leave a comment.

Loading comments...