OpenAI has shipped GPT-Live-1.1, an update to its full-duplex voice model, and with it a feature that matters for anyone running always-on voice agents: standby. According to the OpenAI API changelog entry for 19 November 2026, GPT-Live-1.1 “improves pronunciation, accent consistency, and transcription in multilingual voice conversations”, and you can now “configure standby for GPT-Live-1 and GPT-Live-1.1 WebRTC sessions to pause inference during inactivity and resume when someone speaks.”

In this tutorial you will switch a Live session to gpt-live-1.1, turn on standby, listen for the pause and resume events, and estimate what standby saves you.

What changed

1. A new model ID. gpt-live-1.1 is a drop-in model for the Live API (POST /v1/live/sessions). OpenAI says you can use it “in an existing Live session configuration”. Changing the model requires a new session.

2. Standby for WebRTC sessions. Standby keeps the WebRTC connection open while nobody is talking, but stops inference. It works with both gpt-live-1 and gpt-live-1.1, and it is only available for WebRTC sessions, not WebSocket ones.

Why standby saves money

GPT-Live is billed by session duration, not by tokens. The pricing page lists the same rates for both models:

Model Active rate Standby rate
gpt-live-1.1 $0.05 / minute $0.02 / minute
gpt-live-1 $0.05 / minute $0.02 / minute

The cost guide explains that sessions accrue charges per second. Active time includes speech, silence before the idle timeout expires, and time spent waiting for backend work while inference is running. Standby time is billed at the lower rate. Muting the microphone does not count as standby; the session stays active.

Backend model and tool calls (for example, a text model your voice agent delegates to) are billed separately, as usual.

The three settings

You configure standby when you create the WebRTC session. The session management guide documents three fields inside session:

  • wake_policy.type: set to "speech" so inference waits for someone to speak before starting.
  • idle_timeout_s: a whole number from 5 to 60. After that many seconds with no input or output transcript, the session returns to standby. If you leave it out, inference stays active after the first wake until the session ends.
  • wake_policy.vad_threshold (optional): a number from 0 to 1, default 0.5. Higher values need stronger evidence of speech before the server’s voice activity detector wakes the session. It applies to the first wake and every wake after a pause.

Step 1: Create a WebRTC session with standby (Node.js)

The browser creates an SDP offer and posts it to your server. Your server, which holds the API key, exchanges it for an SDP answer by calling the Live API. This is the pattern from OpenAI’s WebRTC guide, with standby added:

import express from "express";
import OpenAI from "openai";

const app = express();
const client = new OpenAI({ maxRetries: 0 });
app.use(express.json({ limit: "64kb" }));

app.post("/api/session", async (req, res) => {
  // Add your own authentication before exposing this route.
  const sdp = req.body?.sdp;
  if (typeof sdp !== "string" || !sdp.trim()) {
    return res.status(400).json({ error: "An SDP offer is required" });
  }

  try {
    const result = await client.live.create({
      session: {
        model: "gpt-live-1.1",
        instructions: "You are a friendly support agent. Keep answers short.",
        wake_policy: { type: "speech", vad_threshold: 0.5 },
        idle_timeout_s: 20,
      },
      transport: { type: "webrtc", sdp },
    });
    // Contains result.session.id and result.transport.sdp (the answer)
    res.status(201).json(result);
  } catch (error) {
    if (!(error instanceof OpenAI.APIError)) throw error;
    res.status(error.status ?? 502).json({ error: "Live session creation failed" });
  }
});

app.listen(3000, "127.0.0.1");

Keep the API key and session configuration on the server. Never call /v1/live/sessions directly from the browser with your project key.

Note: you need an SDK version with Live support. Leave audio.format out of WebRTC requests, because WebRTC negotiates the audio format through SDP.

The same request in Python

from openai import OpenAI

client = OpenAI(max_retries=0)

def create_live_session(offer_sdp: str):
    return client.live.create(
        session={
            "model": "gpt-live-1.1",
            "instructions": "You are a friendly support agent. Keep answers short.",
            "wake_policy": {"type": "speech", "vad_threshold": 0.5},
            "idle_timeout_s": 20,
        },
        transport={"type": "webrtc", "sdp": offer_sdp},
    )

Step 2: Handle pause and resume in the browser

Two events tell you what the session is doing. Listen for them on the WebRTC data channel (labelled oai-events in OpenAI’s examples), or on a server-side sideband connection:

  • session.resumed: inference is ready. This also fires on the first wake.
  • session.paused: the idle timeout stopped inference and the session is in standby. The connection stays open.
const pc = new RTCPeerConnection();
const mic = await navigator.mediaDevices.getUserMedia({ audio: true });
mic.getAudioTracks().forEach((track) => pc.addTrack(track, mic));

// Create the data channel BEFORE creating the offer.
const events = pc.createDataChannel("oai-events");
const statusEl = document.querySelector("#status");

events.addEventListener("message", ({ data }) => {
  const event = JSON.parse(data);
  switch (event.type) {
    case "session.resumed":
      statusEl.textContent = "Listening";
      break;
    case "session.paused":
      statusEl.textContent = "Standby (say something to wake me)";
      break;
    case "session.usage.updated":
      console.log("Voice seconds so far:", event.usage.seconds);
      break;
  }
});

const offer = await pc.createOffer();
await pc.setLocalDescription(offer);
// ...wait for ICE gathering, POST pc.localDescription.sdp to /api/session,
// then: await pc.setRemoteDescription({ type: "answer", sdp: result.transport.sdp });

Three rules from the docs are easy to get wrong:

  1. Keep the microphone track active during standby. The server needs to hear speech to wake the session. If you stop the track, nothing can wake it.
  2. Do not send session.start on the data channel. For WebRTC, the HTTP request already started the session.
  3. Expect a slower first reply after standby. OpenAI notes that the first response to a short utterance after a pause may take longer. The session ID and conversation history are kept, so the user does not need to repeat themselves.

Step 3: Estimate the savings

The cost guide’s formula is simple: active minutes × active rate + standby minutes × standby rate, plus backend charges. Here is a small helper:

ACTIVE_PER_MIN = 0.05   # USD, gpt-live-1.1 active rate
STANDBY_PER_MIN = 0.02  # USD, standby rate

def voice_cost(active_seconds: float, standby_seconds: float) -> float:
    return (active_seconds / 60) * ACTIVE_PER_MIN + (standby_seconds / 60) * STANDBY_PER_MIN

# A 30-minute "always open" kiosk session where people talk for 6 minutes
# and the session sits idle for the remaining 24 minutes.
without_standby = voice_cost(30 * 60, 0)
with_standby = voice_cost(6 * 60, 24 * 60)
print(f"Without standby: ${without_standby:.2f}")  # $1.50
print(f"With standby:    ${with_standby:.2f}")     # $0.78

The real number will be a little higher with standby, because silence before the idle timeout expires is still billed as active. With idle_timeout_s: 20, each quiet stretch costs up to 20 active seconds before standby kicks in. A shorter timeout saves more but pauses more often, which means more of those slightly slower first replies.

WebRTC start-up charge

Creating a WebRTC session bills 15 seconds of voice duration while it initialises. That amount is credited against duration charges once the session starts running, so it is not an extra 15 seconds. It does matter for reconnects: if you close and recreate sessions frequently, those start-up charges add up. Standby avoids that because the same connection stays open.

Standby or close the session?

Use the docs’ guidance:

  • Standby suits short, unpredictable gaps where the user expects the assistant to be “there”: kiosks, in-app help, a call where the customer goes to fetch an order number.
  • Close the session for long gaps. Save the context and task state, send session.close, wait for session.closed, and start a new session when the user returns, for example via a “Resume conversation” button.

Upgrade checklist

  • Change model to "gpt-live-1.1" in new session requests. Existing sessions keep their original model.
  • Use WebRTC if you want standby; the docs describe it for WebRTC sessions only.
  • Add wake_policy and idle_timeout_s (5–60).
  • Handle session.paused and session.resumed in your UI.
  • Keep the mic track live, and track session.usage.updated to check your cost estimates.
  • GPT-Live-1 and GPT-Live-1.1 have separate concurrent-session limits (see the model page), so check yours before moving all traffic.

Takeaway

GPT-Live-1.1 is mainly a quality update for multilingual voice, but standby is the change that affects your bill. If your voice agent keeps WebRTC sessions open while users are silent, adding a speech wake policy and a sensible idle_timeout_s lets those quiet minutes be billed at $0.02 instead of $0.05, with no change to the conversation history. Start with a 15–30 second timeout, measure usage.seconds, and tune from there.