GPT-Live-1 in the API: Pricing, Full-Duplex Voice, and the Configuration Behind Every Benchmark

OpenAI released GPT-Live-1 in the API on September 10, 2026, bringing its full-duplex voice model to applications that developers build themselves. The model can listen while it is speaking, and it hands complex work to a separate backend model rather than doing everything itself. The voice session costs $0.05 per minute, billed per second.

That split is the whole story, and it shapes how the release should be read. Every performance number OpenAI published describes a pair: the voice model plus whichever backend model ran behind it, at whichever reasoning effort. Change the pairing and the number changes. Here is what the release actually contains, what it costs once backend work is counted, how to read the benchmark table, and what your application still has to do itself.

What OpenAI Released

This is an API launch, not GPT-Live’s first appearance. OpenAI introduced GPT-Live inside ChatGPT on July 8, and that consumer feature is a different product with different limits, which our guide to ChatGPT voice mode covers. A review describing ChatGPT Voice does not describe the developer product now available.

The knowledge cutoff is worth pausing on. A voice model whose own training stops in July 2025 is not the component that should be answering factual questions, which is precisely why the backend exists.

GPT-Live-1 vs Realtime: A Different Division of Work

The distinction is not simply a newer model replacing an older one. Realtime combined speech, reasoning and tool selection in a single model. GPT-Live separates the voice conversation from the delegated work: GPT-Live-1 handles speech and decides when to involve a backend, and the backend looks up information, reasons through the task and calls tools. The conversation keeps running while that happens.

Picture a caller asking a booking assistant about Friday availability, then correcting themselves to Saturday mid-sentence. The product has to do more than hear the correction. It has to pass the updated request to the booking system, stop the outdated action from completing, and then report accurately on what happened. Full-duplex speech improves the interaction. It does not take over those responsibilities.

For a team that already runs a text-based AI agent, that framing makes GPT-Live worth evaluating as a voice interface onto the agent you already have. For a team with a working Realtime application, it is a migration decision, and the conversational gain has to justify the integration work.

Two ways to connect the backend

In both modes the application keeps the responsibilities that matter: task state, permission enforcement, required confirmations, and validating or redacting backend results before they reach the conversation. Client delegation adds one more, because the application has to assemble context itself from the input and output transcript delta events.

There is a specific trap documented here. The session.delegation.created event carries metadata, not task text. An application cannot treat that event as a complete user request; it has to reconstruct intent from accumulated transcripts and its own state.

What migrating from Realtime actually involves

OpenAI’s migration guidance is unusually concrete, and it makes clear this is not a model-name swap. Business logic, authorization checks, tool handlers and durable state stay in your application. What moves is the prompt, which gets split: conversation style and delegation guidance go to session instructions, while business rules and tool-use instructions go to the delegation instructions and tools. OpenAI explicitly advises against copying an existing Realtime prompt wholesale into the voice layer.

The event plumbing changes too. Audio append and output audio events are renamed onto the session, function results are submitted through a different item-create call, and manual turn control disappears entirely: you stream audio continuously and GPT-Live decides when to speak, so audio commits and voice-turn triggers are removed rather than ported.

GPT-Live-1 API Pricing

The voice session costs $0.05 per minute, billed per second with no rounding up to whole minutes. Backend models and tools are charged separately.

Those are arithmetic examples, not deployment quotes. A useful budget keeps voice-session time separate from backend inference, paid tools, and any telephony or hosting your application carries. A ten-minute conversation does not imply ten minutes of backend inference, and a cheap voice session does not make a completed task cheap. Because rate limits are counted in concurrent sessions rather than tokens, capacity planning here looks different from the token-based math in our explainer on inference cost: the question is how many calls run at once, not how many words flow through.

The Benchmarks, and the Configuration Attached to Each

OpenAI published a broad set of comparisons against its own previous voice models. All figures are OpenAI’s own runs, reported by OpenAI; we have not independently benchmarked GPT-Live-1.

Turn-taking latency is the one row where lower is better, and it is the number that most directly reflects what full duplex is for: the model responds in about eight tenths of a second where its predecessors took well over a second.

Why the backend pairing changes the number

Here is the detail that deserves more attention than the percentages. The Full Duplex Bench v3 figures above were run with a GPT-5.6 Terra backend at low reasoning effort. The separately quoted result, a gain of roughly 30 percentage points over GPT-Realtime-2.1 on Full Duplex Bench along with a first-place finish on Tau3, is reported with a GPT-6 Astra backend at medium reasoning effort.

Same voice model, two different published results, because the thing being measured is a system rather than a model. This is the same lesson that came out of DeepSeek’s release a day earlier, where the same model swung 8.7 points on one coding evaluation depending purely on the agent harness wrapped around it. Two labs, two architectures, one conclusion: a voice or agent benchmark without a stated configuration is not a number you can carry into your own planning.

The practical version is short. When you see a score, ask which backend produced it and at what reasoning effort. When you run your own test, hold that pairing fixed and change one variable at a time. And expect your own results to land somewhere inside the range these configurations describe rather than on the best one.

What the Launch Customers Show, and What They Do Not

OpenAI named Yelp Host, Speak, Intercom’s Fin, and Cognition’s Devin among early users, which is a useful signal about intended territory: restaurant and reservation handling, language learning, customer support, and software agents. Speak reported almost 80 percent fewer interruptions during learners’ thinking pauses compared with its previous turn-based systems.

Treat that as a vendor-reported evaluation from a partner with a specific workload, not a forecast for yours. Fewer interruptions is a real improvement in a language-learning context where silence is part of the task. It says little about whether an agent that sounds natural also updates the right record. A support agent that converses beautifully and changes the wrong reservation has still failed.

For a first product test, use a small set of tasks with inspectable outcomes: a corrected date, a cancellation issued during a lookup, and a deliberately failed tool call. Judge the spoken answer alongside the records that actually changed, not instead of them.

Three Implementation Details That Matter

Interrupting speech is not canceling a task

“Stop talking” and “cancel the booking” are different requests, and OpenAI’s prompting guidance distinguishes stopping speech from stopping backend work. The backend has to handle a changed or canceled request and report what happened. Keep conversation instructions short, and never rely on a prompt alone to enforce a permission check.

A transcript is not proof that an action completed

Input and output transcript fragments can overlap. They are not authoritative completed turns, and their arrival does not prove that audio playback has finished. Confirmed actions and important facts belong in application state rather than in conversation history. In the booking example, the database decides whether the reservation exists; a fluent spoken confirmation is an output to verify, not the system of record.

Measure conversation quality and task success separately

OpenAI’s evaluation guide separates audio interaction from reasoning and task quality, and proposes controlled synthetic-audio tests, recorded-audio replays, and continuous simulated conversations. It also distinguishes response latency from task-completion time, because the first spoken acknowledgment can arrive long before the underlying work is done. Track both, or a fast “I’m checking that” will make an agent look responsive while the useful result is slow, wrong, or missing.

How to Start Testing GPT-Live-1

Browser applications connect over WebRTC, server-side audio integrations over WebSockets, and phone agents through OpenAI’s telephony guidance, which is what makes full-duplex phone support the flagship use case for reservations, order updates and customer service. Browser setup needs a trusted server in the middle, because the API key belongs there and not in browser code.

Start with one narrow workflow and a clear pass condition. Connect the voice interface, confirm that a real backend lookup produces the correct spoken result, then add corrections and interruptions before widening the scope. Resist testing the voice quality first; it is the part least likely to fail.

What This Means If You Are Not a Developer

Most people will meet this release without ever touching the API, in the form of phone systems and support agents that stop cutting you off mid-sentence. That is a genuine improvement over the turn-based voice menus it replaces, and the latency row above is the reason.

It also changes what to expect from those systems. An agentic voice assistant that can act on your account is doing something different from one that reads you an answer, which is the same shift covered in our piece on ChatGPT agent mode. The reasonable habit is the one the implementation notes describe: when a voice agent tells you something is done, check that it is. A confident confirmation is generated text, not evidence.

What to Watch

Watch for independent full-duplex evaluations that state their backend pairing, since none of the current numbers come from outside OpenAI. Watch whether a mini variant appears in the API, as one already exists in ChatGPT for free users. Watch the practical cost curves once teams publish real bills, because the $0.05 voice layer is the part of the invoice nobody will be surprised by. And watch whether Realtime gets a deprecation date, which would turn today’s optional migration into a required one.

The Bottom Line

GPT-Live-1 in the API is a more flexible voice interface onto an agent, not a replacement for the agent’s business logic. The full-duplex gains are real and the latency figures show it, the pricing is legible, and the delegation split is a sound design. The thing to carry away is how its results are reported: every number is a pairing, and the number you get will depend on what you put behind the voice.

FAQ

Build the Habit These Releases Reward

Asking which configuration produced a number, testing on your own workflow, and checking what a confident answer actually changed are transferable skills that outlast any single model. Coursiv teaches them through short daily lessons and hands-on practice with real AI tools, built for people without a technical background. Check the official site for current course details and pricing.