GPT-Realtime-2 API Voice Agent Guide (2026): Pricing, Code, and Production Routing

On August 27, 2026, OpenAI launched three new realtime audio models in the API: GPT-Realtime-2, GPT-Realtime-Translate, and GPT-Realtime-Whisper. The headline model, GPT-Realtime-2, is the important one for developers building voice agents because it moves realtime audio closer to a working product layer: it can reason, call tools, recover from interruptions, and keep longer sessions alive with a 128K context window.

That changes the build decision. Voice apps used to be a pipeline: speech-to-text, text LLM, tool call, text-to-speech, then a lot of glue to hide latency. A native realtime model doesn't remove all glue, but it makes the conversation loop cleaner. The catch is cost and architecture. Audio tokens are expensive enough that you should design routing before launch, not after your first bill lands.

Pricing table: OpenAI realtime voice models

Model comparison: which realtime option should you choose?

What GPT-Realtime-2 is actually good for

The best use cases are not “talk to a chatbot.” That demo is easy. The useful version is voice-to-action: change an order, schedule a tour, triage a support issue, check inventory, update a CRM note, or coach a user through a complicated workflow while the user keeps speaking naturally.

OpenAI's launch notes call out preambles, parallel tool calls, tool transparency, better recovery behavior, longer context, stronger domain understanding, and controllable tone. Those details matter. A voice agent that goes silent for five seconds feels broken, even if the backend is working. A short “I'm checking that now” buys time and tells the user the system hasn't died.

Minimal WebRTC session pattern

For browser apps, the usual pattern is: your server creates an ephemeral realtime session, the browser connects over WebRTC, and your backend keeps secrets off the client. Don't put your root API key in JavaScript. Ever.

// server.js
import express from "express";

const app = express();
app.use(express.json());

app.post("/session", async (req, res) => {
  const r = await fetch("https://api.openai.com/v1/realtime/sessions", {
    method: "POST",
    headers: {
      "Authorization": `Bearer ${process.env.OPENAI_API_KEY}`,
      "Content-Type": "application/json"
    },
    body: JSON.stringify({
      model: "gpt-realtime-2",
      voice: "alloy",
      instructions: "You are a concise support voice agent. Explain tool calls before using them.",
      reasoning: { effort: "low" }
    })
  });

  res.status(r.status).send(await r.text());
});

app.listen(3000);

The browser then asks /session for a short-lived credential and starts the WebRTC connection. Keep your app-specific authorization on /session; otherwise anyone who can open DevTools can burn your realtime budget.

Tool calls: make them audible and bounded

Realtime voice agents need tools, but tools are where voice UX gets weird. If a text agent takes eight seconds, the user waits. If a voice agent takes eight seconds with dead air, the user repeats themselves, talks over the model, or hangs up.

Use three rules:

1. Give every slow tool a preamble. “I'll check your order status now” is not fluff; it's state.
2. Set tool timeouts. A broken inventory API should return a graceful failure, not trap the conversation.
3. Never let one tool own the session. Parallel tool calls are useful, but cap concurrency and log every call.

{
  "type": "function",
  "name": "lookup_order",
  "description": "Look up an order by ID and return status, ETA, and refund eligibility.",
  "parameters": {
    "type": "object",
    "properties": { "order_id": { "type": "string" } },
    "required": ["order_id"]
  }
}

Reasoning effort: don't default to xhigh

GPT-Realtime-2 supports adjustable reasoning effort: minimal, low, medium, high, and xhigh, with low as the default in OpenAI's launch post. My take: keep low as your production default. Raise effort only for flows that need planning, multi-step policy checks, or expensive tool decisions.

Voice latency is felt more sharply than chat latency. If a refund policy check needs high effort, fine. If the user asks “what time do you close?”, high effort is wasted money and awkward silence.

Cost control for voice agents

The pricing table makes the main lesson obvious: GPT-Realtime-2 is not a cheap transcription model. It is a realtime agent model. Use it when you need action and reasoning; route simple capture tasks to transcription.

• Use GPT-Realtime-Whisper for live captions, searchable transcripts, and meeting notes.
• Use GPT-Realtime-Translate when translation is the product, not a side task.
• Use GPT-Realtime-2 when the voice session needs decisions, memory, and tools.
• Cache stable instructions where the platform supports cached input pricing.
• Track audio minutes, output tokens, tool latency, and abandoned sessions separately.

If you already run multiple model vendors, keep a routing layer in front of voice workflows too. KissAPI is useful here when your product also needs OpenAI-compatible text fallback, batch summarization, or non-voice post-processing through the same account and billing surface.

A practical routing design

Here's a sane first version for a customer-support voice product:

if task == "live_transcription":
    model = "gpt-realtime-whisper"
elif task == "live_translation":
    model = "gpt-realtime-translate"
elif user_tier == "enterprise" and needs_tool_action:
    model = "gpt-realtime-2"
else:
    model = "text_or_async_followup"

That last branch is important. Not every voice interaction needs to stay live. Sometimes the right answer is: capture the user's request, confirm it, then process the heavy reasoning asynchronously with a cheaper text model. For post-call summarization, QA scoring, and ticket tagging, use a text model and a token budget. The token counter and API cost calculator are built for exactly that planning work.

Production checklist

• Use ephemeral client credentials and keep the root API key server-side.
• Log session duration, audio token usage, text token usage, cached input usage, and tool call count.
• Add per-user and per-organization spending caps before public launch.
• Make tool actions visible to users with short spoken status updates.
• Store transcripts only if your privacy policy and region rules allow it.
• Test interruption handling with messy real speech, not clean demo prompts.

FAQ

What changed in OpenAI's August 27, 2026 realtime launch?

OpenAI introduced GPT-Realtime-2 for voice agents, GPT-Realtime-Translate for live translation, and GPT-Realtime-Whisper for streaming speech-to-text in the Realtime API.

Is GPT-Realtime-2 priced per minute?

GPT-Realtime-2 is priced per million tokens for audio, text, and image modalities. GPT-Realtime-Translate is priced at $0.034 per minute, and GPT-Realtime-Whisper is priced at $0.017 per minute.

What is the target keyword for this guide?

The target keyword is “GPT-Realtime-2 API voice agent guide 2026,” aimed at developers evaluating OpenAI's new realtime voice model for production applications.