Skip to content
GPT-Live-1.1 bills idle time at a lower standby rate once the caller goes quiet A waveform call bubble on the left is labeled Active at five cents a minute. An arrow crosses a dashed threshold line to a flat, quiet bubble on the right labeled Standby at two cents a minute, with a small caption noting the session stays open and resumes when the caller speaks again. GPT-Live-1.1 Standby Mode Silence stops costing the active rate. OCT 15, 2026 Active $0.05/min idle_timeout_s (5-60) caller goes quiet Standby $0.02/min Connection and session ID stay open. Speech resumes inference at the active rate.
Guideintermediate

OpenAI GPT-Live Guide: Setup, Standby Pricing, and When to Use It

The short version

GPT-Live-1.1 shipped October 15, 2026 with a standby mode that drops the idle billing rate from $0.05 to $0.02 a minute. Here is the exact config, the pricing math, and when ElevenLabs, Gemini Live, or Nova Sonic fit better.

Published November 20, 2026by
Table of Contents

OpenAI GPT-Live Guide: Setup, Standby Pricing, and When to Use It

A voice agent that holds a call open spends most of that call listening to nothing. OpenAI's realtime voice model used to bill every one of those quiet seconds at the same $0.05-a-minute active rate as an actual conversation. GPT-Live-1.1, published October 15, 2026 per its system card, adds a standby mode that drops the idle rate to $0.02 a minute, and the model also transcribes speech more accurately and holds a steadier accent across languages than GPT-Live-1 (per OpenAI's model page).

This guide covers the one decision that actually matters if you're building on it: whether standby is worth wiring up for your call pattern, what it costs you in response latency when it works, and the three places a competing voice model still wins.

What GPT-Live actually is

GPT-Live is OpenAI's full-duplex voice model line: it listens while it speaks, so a caller can interrupt mid-sentence instead of waiting for a turn to end. GPT-Live-1 reached general availability on September 10, 2026 at $0.05 per minute, billed per second, with backend model and tool usage charged separately (per the API changelog). That split is the whole architecture: GPT-Live handles the voice session, and a second model you choose, say gpt-5.6-terra via Responses delegation, does the actual reasoning and tool calls while the call stays open.

GPT-Live-1.1 replaces GPT-Live-1 as the current model in that same architecture. It is live today through the Live, Realtime, Chat Completions, and Responses endpoints, so nothing about how you connect changes (per the model page).

What changed in 1.1

Two things, neither of them a new endpoint. First, accent and pronunciation: OpenAI's own comparison says GPT-Live-1.1 "transcribes speech more accurately and maintains a more consistent accent and voice across languages" than its predecessor. Second, standby: a per-session billing state that didn't exist on GPT-Live-1's original pricing.

Structured outputs, fine-tuning, and predicted outputs are still unsupported on this model, same as 1.0. Streaming and function calling both work. If your app already runs on GPT-Live-1, the upgrade is a model-name swap in your session config, not a migration.

Turning on standby mode

Standby only applies to WebRTC sessions, not WebSocket connections, and you configure it when you create the session, not through any dashboard toggle. Two fields do the work: wake_policy.type set to "speech" tells the session to wait for voice activity before it starts inference, and idle_timeout_s (a whole number from 5 to 60) sends an active session back to standby after that many seconds pass with no transcript on either side (per OpenAI's guide to managing idle sessions).

// Adapted from OpenAI's WebRTC quickstart (live.sessions), which creates the
// session server-side after exchanging the browser's SDP offer.
const result = await client.live.create({
  session: {
    model: "gpt-live-1.1",
    wake_policy: { type: "speech", vad_threshold: 0.6 },
    idle_timeout_s: 30,
    instructions: "Wait for the caller to speak before you respond.",
  },
  transport: {
    type: "webrtc",
    sdp: request.body.sdp,
  },
});

vad_threshold is optional, runs from 0 to 1, and defaults to 0.5; raise it if background noise keeps waking the session early. Once the session is live, listen on the data channel for session.paused (standby started) and session.resumed (inference restarted) so your UI can show the right state.

The microphone track has to stay open during standby, since the idle timer measures silence rather than a muted mic, and the first reply after a wake can take longer than a normal turn because inference is cold-starting again. If your app needs an instant response on every single utterance, test that latency tax against your use case before you ship it.

The standby state machine for a GPT-Live-1.1 WebRTC session: active billed at $0.05/min, idle_timeout_s elapses into standby billed at $0.02/min with the mic track and session ID held open, then a VAD speech trigger resumes the session to active.
Rates per OpenAI's GPT-Live-1.1 model page.

What standby actually saves you

Run OpenAI's published rate card against a real call shape instead of a round number. Take an in-car assistant connected for a 10-minute drive where the driver actually talks for 90 seconds total, scattered across short bursts, with a 15-second idle_timeout_s. Without standby, that whole call bills at the active rate: 10 minutes times $0.05 is $0.50. With standby catching the gaps between bursts, you're closer to 2 minutes at the active rate and 8 minutes at standby: (2 x $0.05) + (8 x $0.02) = $0.26, a 48% cut on the voice-session line alone. That math applies OpenAI's own published per-minute rates; it isn't a benchmark, and your real split depends on how chatty your callers actually are.

Two billing details that change the number in practice. Creating a WebRTC session bills 15 seconds of voice duration up front at session creation, credited against the running session once it starts, so don't double-count it when you reconcile usage. And backend costs, the model doing the reasoning behind GPT-Live, are metered separately and don't get the standby discount; only the voice-session line does (per OpenAI's cost-optimization guide).

Where it still falls short

Standby is an API-level setting, not a feature you can see or flip from a consumer app. If you're building a ChatGPT Voice-style product, there's no end-user toggle; you ship the config, your users never know it exists. The accent-consistency improvement is also scoped to GPT-Live-1.1 itself: OpenAI's comparison language covers the model's own speech, not every downstream voice persona built on top of it.

And the whole feature only pays off on calls with real dead air. A dense back-and-forth, like a live support escalation where someone is always talking, never crosses idle_timeout_s and bills at the active rate the entire time regardless of whether standby is configured.

GPT-Live-1.1 vs the alternatives

OpenAI GPT-Live-1.1ElevenLabs Conversational AIGoogle Gemini Live (2.5 Flash Native Audio)Amazon Nova Sonic
Billing unitPer-minute, active/standby splitCredit-based plans, per-minute TTS from 5c on the Business tier (per ElevenLabs pricing)Per-token: $3.00/1M input, $12.00/1M output for audio (per Google's pricing page)Bedrock on-demand, priced by AWS region
Idle-cost handlingStandby rate on WebRTC sessionsNo published idle discountNo published idle discountNo published idle discount
Reasoning modelSeparate, delegated (Responses/Chat Completions)Bundled agent orchestrationCombined in the same Gemini callCombined in the same Bedrock call
Best fitYou already delegate to an OpenAI reasoning model and have real silent gaps to exploitYou need voice cloning or deep telephony/SIP integrations out of the boxYou're already on Vertex/Gemini and want one bill, one modelYou're building inside Bedrock and want it on AWS's own compliance boundary

Gemini's token-based pricing and GPT-Live's per-minute pricing aren't directly comparable without knowing your audio length and token density; the real variable is which platform you're already billed through for the reasoning half of the stack.

Who should build on this now

If you're already running a voice app on GPT-Live-1 and have calls with meaningful dead air (drive-time assistants, field-service check-ins, anything with a hold or a think-out-loud pause), swap the model name, add wake_policy and idle_timeout_s, and keep the 15-second init billing in mind when you audit usage. If your calls are dense, continuous conversation with almost no silence, standby won't move your bill and isn't worth the added complexity of handling session.paused and the wake-up latency in your UI. And if you're not on OpenAI's stack already, compare the billing unit before the feature list: a per-token voice model and a per-minute one will rank differently depending on how long your calls actually run.