GPT-Live-1.1: OpenAI's Full-Duplex Voice Model, Pricing, and How to Build With It
GPT-Live-1.1 is OpenAI's full-duplex voice model, available in the API since November 20, 2026. It listens while it speaks, hands reasoning and tool calls to a backend model you choose, and bills by the minute: $0.05 per active minute and $0.02 per standby minute. You reach it through one endpoint, v1/live/sessions, not the Realtime API.
Our earlier post on what GPT-Live is covered the ChatGPT voice feature before developers could call it. This guide covers the API model: what's new, what it costs, how a session works and how it compares with GPT-Realtime.
What is GPT-Live-1.1?
GPT-Live-1.1 is a voice model that holds a spoken conversation in real time while a separate backend model does the thinking. It accepts audio and text, returns audio and text, and keeps listening while it talks, so callers can interrupt or add details mid-sentence. Its model ID is gpt-live-1.1, and it supports streaming and function calling.
The GPT-Live-1.1 model page calls it a "Full-duplex voice model for multilingual conversations." Full duplex means audio flows both ways at once, like a phone call, instead of a walkie-talkie where one side waits.
The other half of the design is delegation. GPT-Live decides when a request needs real work, sends it to a backend (an OpenAI Responses model or your own agent), keeps talking while the backend runs, then explains the result out loud.
What changed from GPT-Live-1
GPT-Live-1.1 keeps the same endpoint, pricing and feature set as GPT-Live-1. The changes are in voice quality and task handling. Here's what OpenAI lists in the model docs and in its announcement on X:
| Area | GPT-Live-1 | GPT-Live-1.1 |
|---|---|---|
| Speech transcription | Baseline | More accurate, per the model page |
| Accent and voice across languages | Baseline | More consistent, per the model page |
| Idle sessions | Standby rate listed on its page | Standby announced as a new option, $0.02/min |
| Task completion | Baseline | "Completes tasks even more reliably," per OpenAI's announcement |
| Endpoint | v1/live/sessions |
v1/live/sessions |
| Price (active) | $0.05/min | $0.05/min |
| Rate limits | Concurrent sessions | Separate concurrent-session limit |
OpenAI hasn't published benchmark numbers for the transcription or reliability gains, so treat them as vendor claims until you measure them. Also, OpenAI's announcement calls standby new with this release, while the GPT-Live-1 page now lists the same $0.02 standby rate.
Both models share the endpoint and pricing, so switching starts with setting the session model to gpt-live-1.1. Rerun your own voice evals afterward to confirm the gains on your traffic.
GPT-Live-1.1 pricing
GPT-Live-1.1 bills voice sessions by duration, not by tokens. These are the rates on the OpenAI pricing page, checked on November 20, 2026:
| Metric | Price |
|---|---|
| Active session time | $0.05 per minute |
| Standby session time | $0.02 per minute |
| Backend model and tools | Billed separately at that model's normal rates |
A few billing details matter when you estimate costs:
- Per-second billing. Duration isn't rounded up to the next whole minute.
- Standby is WebRTC-only. The lower rate applies to WebRTC sessions while inference is paused.
- Initialization charge. Creating a WebRTC session bills 15 seconds during setup, credited against duration charges once the session runs.
- The backend is a second bill. Delegated Responses tokens and tool calls are charged too.
Worked example from the timeline above: a 30-minute support session spends 20 minutes active and 10 minutes on standby while the caller looks something up. Voice cost: 20 x $0.05 + 10 x $0.02 = $1.20. Without standby, the same session costs 30 x $0.05 = $1.50. Add whatever the backend model spends on its delegated tasks.
How GPT-Live-1.1 works: voice plus delegation
A GPT-Live application has two parts. The getting started guide splits them like this:
- GPT-Live handles conversation. It listens, speaks and decides when to ask the backend for help. You give it a short prompt about speaking style and when to delegate.
- The backend handles delegated tasks. It reasons, calls tools and returns results for GPT-Live to say out loud. Detailed instructions, business rules and tool workflows live here.
- Your application owns the risky parts. It checks permissions, collects confirmations, runs functions that touch your systems and saves task progress.
You pick one of two delegation modes when you create the session, and you can't switch modes mid-session:
| Mode | Who runs the backend | Pick it when |
|---|---|---|
| Responses delegation | OpenAI calls the Responses model you configure and passes context and results | You want GPT-Live to manage backend requests for you |
| Client delegation | Your application runs any model, agent or service and sends results back | You need to validate, redact or combine results, or use a non-OpenAI backend |
The delegation guide recommends starting with Responses delegation. Client delegation fits teams putting a voice in front of an existing text agent.
Create your first GPT-Live-1.1 session
GPT-Live has its own endpoint. The model page lists v1/live/sessions as supported and marks Chat Completions, Responses and v1/realtime as not supported. OpenAI recommends WebRTC for audio, with WebSockets and SIP as alternatives.
The WebRTC flow from the quickstart runs in five steps:
- The browser requests microphone access and adds its tracks to a peer connection.
- It creates a data channel, then creates an SDP offer.
- The browser sends the offer to your server.
- Your server posts
sessionandtransport: { type: "webrtc", sdp }toPOST /v1/live/sessionswith your API key. - The browser applies the returned SDP answer and waits for
session.started.
Here's the server call from OpenAI's TypeScript example, trimmed to the session config:
const result = await client.live.create({
session: {
model: "gpt-live-1.1",
instructions:
"Be concise. Delegate requests needing current information to the backend, which can search the web.",
delegation: {
type: "responses",
responses: {
model: "gpt-5.6-terra",
instructions:
"Use web search when current facts are needed. Return concise, grounded results for a spoken conversation.",
tools: [{ type: "web_search" }],
tool_choice: "auto",
},
},
},
transport: { type: "webrtc", sdp: request.body.sdp },
});
Keep the API key on the server, and don't send session.start on the data channel: the HTTP request already starts the session. OpenAI also ships the OpenAI Live Console, a local sample app for watching conversations, delegation and backend tool activity.
Standby mode: cut idle costs
Standby keeps a WebRTC connection open while nobody is talking, then resumes inference when someone speaks. The connection and session ID stay the same, and conversation history comes back when the session resumes.
You turn it on with two session fields:
{
"session": {
"model": "gpt-live-1.1",
"wake_policy": { "type": "speech", "vad_threshold": 0.5 },
"idle_timeout_s": 20
}
}
-
wake_policy.type: "speech"waits for speech before starting inference. -
idle_timeout_stakes a whole number from 5 to 60. After that many seconds without an input or output transcript, the session drops to standby. -
vad_thresholdruns from 0 to 1 and defaults to 0.5. Higher values need stronger evidence of speech to wake.
Listen for session.paused and session.resumed to track state, and keep the microphone track active. One trade-off from the session management guide: the first reply to a short utterance after standby may take longer. For long gaps, closing the session and starting a new one can cost less than standby.
GPT-Live-1.1 vs GPT-Realtime
OpenAI's voice agents guide frames the choice by architecture. GPT-Live fits full-duplex conversations with a separate backend. The Realtime API fits one model that hears, reasons, calls tools and speaks in a single session.
| GPT-Live-1.1 | GPT-Realtime-2.1 | |
|---|---|---|
| Endpoint | v1/live/sessions |
v1/realtime |
| Design | Voice frontend plus delegated backend | One speech-to-speech model |
| Input | Audio, text | Text, audio, image |
| Billing | $0.05/min active, $0.02/min standby | Per token: $32 in, $64 out per 1M audio tokens |
| Backend cost | Billed separately | Included in the token price |
| Best for | Adding voice to an existing text agent | Self-contained voice agents |
Per-minute billing makes GPT-Live voice costs simple to forecast for long calls. Token billing on Realtime tracks how much audio and text flows, and it bundles reasoning into one price. For a deeper look at the earlier comparison, see GPT-Live vs GPT-Realtime and our GPT-Realtime-2 API guide.
Rate limits and access
GPT-Live limits count concurrent sessions, not tokens. GPT-Live-1.1 and GPT-Live-1 have separate limits that apply across inference regions. The GPT-Live-1 page lists 50 concurrent sessions on the Build tier, 300 on Launch and 500 on Grow, and marks the Free tier as unsupported. The GPT-Live-1.1 page doesn't publish its own table yet, so check your organization's limits page before you plan load.
Test your session server with Apidog CLI
Your GPT-Live integration has an HTTP surface you own: the /api/session endpoint that exchanges SDP offers. OpenAI's example returns 403 for an unexpected origin and 400 for a missing SDP offer. Those paths never reach OpenAI, so you can test them on every commit at zero voice cost. Let your coding agent write and run the tests with Apidog CLI.
Install the CLI, log in and add the Apidog skill to your agent:
npm install -g apidog-cli@latest
apidog login --with-token <YOUR_TOKEN>
npx -y skills add https://apidog.com # pick your agent when prompted
Then give your agent one prompt:
In Apidog project <projectId>, add POST /api/session for my GPT-Live-1.1 server.
Create test cases that assert: a request with a wrong Origin header returns 403,
a request with no sdp field returns 400. Run them against the local environment
and summarize any failures.
The agent reads the schemas, validates its payloads, creates the endpoint and cases, then runs them:
apidog cli-schema get endpoint-create
apidog endpoint create --project <projectId> --file ./endpoint.json
apidog cli-schema get test-case-create
apidog cli-schema validate test-case-create --file ./case.json
apidog test-case create --project <projectId> --file ./case.json
apidog run --test-case <caseId> --project <projectId> -e <envId> -r cli,json
The same apidog run with -r junit drops into CI; see running Apidog CLI in a CI/CD pipeline. If you use Claude Code, the Apidog CLI in Claude Code guide walks through the setup. Apidog's Free plan covers teams of up to 4 users.
FAQ
Is GPT-Live-1.1 available in the API? Yes. OpenAI made GPT-Live-1.1 available in the API on November 20, 2026, with the model ID gpt-live-1.1 on the v1/live/sessions endpoint. Our earlier GPT-Live API post predates that release.
How much does GPT-Live-1.1 cost? $0.05 per active minute and $0.02 per standby minute, billed per second. Backend model and tool usage are billed separately at their normal rates.
What's the difference between GPT-Live-1 and GPT-Live-1.1? GPT-Live-1.1 transcribes speech more accurately, keeps a more consistent accent and voice across languages, and adds a standby option for idle sessions. Pricing and the endpoint are the same.
Can GPT-Live-1.1 see images? Not directly. Send images to a vision-capable backend model, which returns text for GPT-Live to use.
Does GPT-Live-1.1 support function calling? Yes. The model page lists streaming and function calling. In practice, your backend handles tool calls through delegation, and your application runs any custom functions.


Top comments (0)