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.
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.1 | ElevenLabs Conversational AI | Google Gemini Live (2.5 Flash Native Audio) | Amazon Nova Sonic | |
|---|---|---|---|---|
| Billing unit | Per-minute, active/standby split | Credit-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 handling | Standby rate on WebRTC sessions | No published idle discount | No published idle discount | No published idle discount |
| Reasoning model | Separate, delegated (Responses/Chat Completions) | Bundled agent orchestration | Combined in the same Gemini call | Combined in the same Bedrock call |
| Best fit | You already delegate to an OpenAI reasoning model and have real silent gaps to exploit | You need voice cloning or deep telephony/SIP integrations out of the box | You're already on Vertex/Gemini and want one bill, one model | You'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.