GPT-Live vs the Realtime API: Which One Should You Build On?

What GPT-Live is

GPT-Live is the consumer voice model that OpenAI put into ChatGPT on July 8, 2026. It is what you tap when you press the voice button in the ChatGPT app, on iOS, Android, or chatgpt.com. It is a product, not a programmable surface.

The thing that makes GPT-Live feel different from the older Advanced Voice Mode is full duplex: the model is always listening and always ready to respond, and it can produce short backchannel sounds ("mhmm," "yeah") while you are still talking. There is a separate, more capable variant called GPT-Live-1 (paid plans) and a lighter GPT-Live-1 mini (free tier), and there are reasoning-strength variants called Instant, Medium, and High that lean on a stronger backend model. All of that happens inside ChatGPT. You cannot build on top of it.

If you want a user experience of full-duplex voice, you open ChatGPT. If you want a builder experience, you want the Realtime API.

What the Realtime API is

The Realtime API is a developer platform that OpenAI shipped in late 2024 and has been iterating on since. It exposes a low-latency speech-to-speech model over a WebSocket or WebRTC connection. You send audio in, you get audio out, and you can interrupt the model at any time. It is the underlying engine that powers GPT-Live in the ChatGPT app, but you can also wire it into your own product.

Where GPT-Live is a single feature in a single app, the Realtime API is a primitive. It gives you the model, the audio codec handling, the function-calling integration, and the session lifecycle. It does not give you a UI, a mobile app, or a user account system. You build all of that yourself.

For a deeper write-up of the API endpoints and how to get access, see the GPT-Live API page. The short version: the Realtime API has been generally available since late 2024, and the official launch post is the cleanest reference.

Side-by-side comparison

When to use GPT-Live

Use GPT-Live when the user is you, or your team, and the product is ChatGPT itself. Common cases:

• Personal productivity — dictating long emails, talking through a doc, voice journaling.
• Brainstorming — the backchanneling ("mhmm," "right") is genuinely useful for thinking out loud.
• Language learning — practicing spoken conversation without a human partner. See language coverage.
• Real-time translation — pass a phone back and forth, GPT-Live auto-translates both directions.
• Accessibility — users with RSI or visual impairment often find the full-duplex experience more usable than turn-taking.

If your work is "use ChatGPT better," GPT-Live is the right answer. You do not need to touch a single line of code.

When to use the Realtime API

Use the Realtime API the moment you want voice inside your own product. That includes:

• Customer support voice agents — the obvious killer use case. Tier-1 support calls, FAQ bots, escalation to a human.
• In-app voice assistants — a language learning app, a meditation app, a productivity app that wants a hands-free mode.
• Voice-driven workflows — field service technicians talking to a CRM, doctors dictating structured notes, drivers dictating messages.
• In-game NPCs and characters — real-time dialogue for video games or interactive fiction.
• IoT and embedded devices — smart speakers, robots, kiosks, anything with a microphone and a speaker.
• Voice-first interfaces where ChatGPT is not an option — regulated industries, on-prem deployments, custom UX.

The decision is structural: if you are building a product that other people will pay for, you are building on the Realtime API. If you are improving your own workflow, you are using GPT-Live.

Realtime API: WebSocket code (Node.js)

The most direct way to talk to the Realtime API is a raw WebSocket. This is the smallest working example. Save as realtime.mjs, run with node realtime.mjs, and you will hear GPT-4o speak "Hello" back through your speakers.

// realtime.mjs — minimal Realtime API client
import WebSocket from "ws";

const url = "wss://api.openai.com/v1/realtime?model=gpt-4o-realtime-preview-2024-12-17";
const ws = new WebSocket(url, {
  headers: {
    Authorization: `Bearer ${process.env.OPENAI_API_KEY}`,
    "OpenAI-Beta": "realtime=v1",
  },
});

ws.on("open", () => {
  console.log("connected");
  // Tell the model to speak
  ws.send(JSON.stringify({
    type: "response.create",
    response: {
      modalities: ["audio", "text"],
      instructions: "Say exactly: 'Hello from the Realtime API.'",
      voice: "alloy",
    },
  }));
});

ws.on("message", (data) => {
  const evt = JSON.parse(data.toString());
  if (evt.type === "response.audio.delta") {
    // evt.delta is base64-encoded PCM16 audio; pipe it to your audio sink
    process.stdout.write(Buffer.from(evt.delta, "base64"));
  }
});

The official docs have a fuller version with mic capture, interrupt handling, and function calling. The point of the snippet above is to show how thin the integration is — the WebSocket protocol is the only real complexity.

Realtime API: OpenAI Agents SDK (Python)

If you are already using the OpenAI Agents SDK, the Realtime API shows up as a RealtimeAgent. This is the higher-level surface and is what most production teams will reach for. The example below wires a voice agent that calls a single tool, get_weather.

from agents.realtime import RealtimeAgent, function_tool

@function_tool
def get_weather(city: str) -> str:
    return f"It's always 72°F in {city}."

agent = RealtimeAgent(
    name="Weather Concierge",
    instructions="You are a friendly weather assistant. Use get_weather for any city the user mentions.",
    tools=[get_weather],
)

async def main():
    async with agent.run(input_mode="voice", output_mode="voice") as session:
        # session is a live audio I/O loop; pipe it to your mic and speakers
        await session.wait_until_done()

if __name__ == "__main__":
    import asyncio
    asyncio.run(main())

The Agents SDK handles session lifecycle, tool routing, audio framing, and interruption. The trade-off is one more layer of abstraction: you give up fine control over the WebSocket, and you have to upgrade when OpenAI ships breaking changes to the SDK.

Pricing comparison

GPT-Live pricing is flat subscription. Realtime API pricing is per-token, billed in two streams: audio input (your user's voice, plus any system audio) and audio output (the model's voice back to the user). Text tokens are also billed, but they are usually a rounding error compared to audio.

The breakeven math: if you are running a voice agent that costs ~$0.10 per call in API fees and you handle 1,000 calls a day, that is $3,000/month. A ChatGPT Pro subscription is $200/month and covers one person. If your product is "a person talking to a voice AI," GPT-Live is cheaper. If your product is "a thousand people talking to voice AIs you serve," the Realtime API is the only option.

Migration paths

The two products share an underlying model family but the surfaces are different. If you start with one and need the other, here is what changes.

From Realtime API to GPT-Live (consumer product path)

This is uncommon but happens: you build a custom voice product, then realize your users would rather have a turnkey ChatGPT experience. Migration is hard because the Realtime API gives you session control, custom tools, custom voices, and custom system prompts — none of which the consumer ChatGPT surface exposes. Realistically, you are not migrating users; you are sunsetting your product and pointing them at ChatGPT Plus.

From GPT-Live to Realtime API (build-your-own-product path)

This is the common one. You have been using GPT-Live personally, your team loves it, and now you want to ship a voice feature in your own product. The good news: the underlying model behavior is similar, so your prompt-engineering intuition transfers. The bad news: you are now responsible for audio I/O, session lifecycle, error handling, billing, abuse, and all the other things OpenAI handles for ChatGPT. Plan to spend 2-4 weeks of engineering on the platform layer before you ship.

FAQ

Wrapping Up GPT-Live vs the Realtime API

The two products are easy to confuse because they share vocabulary: voice, real-time, full duplex, OpenAI. The simplest way to keep them straight: GPT-Live is a product, the Realtime API is a platform. Pick based on whether you are a user or a builder, and the rest of the architecture falls out from there.

For the broader API landscape — release timeline, endpoints, waitlist — see the GPT-Live API page. For everything else GPT-Live, the main guide is the index.