OpenAI GPT-Realtime-2 (May 2026): Latency Tests, Pricing & How to Build a Voice Agent in 30 Minutes

OpenAI shipped gpt-realtime-2 on May 7, 2026, alongside gpt-realtime-translate and gpt-realtime-whisper, and pulled the Realtime API out of beta in the same announcement. The headline change is that voice now runs on a single GPT-5-class model with a 128K context window, up from 32K on the previous generation. This guide covers the real benchmark numbers, the published per-token pricing, where Realtime-2 actually wins versus ElevenLabs, Cartesia and Deepgram, and a 30-minute Node plus WebRTC build you can run today.

TL;DR

• Released May 7, 2026 as gpt-realtime-2 plus translate and whisper variants.

• Pricing: $32 per 1M audio input, $64 per 1M audio output, $0.40 cached.

• Context jumped from 32K to 128K tokens, Realtime API now generally available.

• Big Bench Audio score: 96.6% versus 81.4% on Realtime-1.5.

• WebRTC for browsers, WebSocket for servers, SIP for telephony.

What is OpenAI GPT-Realtime-2?

GPT-Realtime-2 is OpenAI's speech-to-speech voice model, released May 7, 2026, that takes audio in and emits audio out in a single forward pass with GPT-5-class reasoning inside the audio loop. It replaces the older cascading pattern of Whisper plus a text LLM plus a separate text-to-speech engine. The model exposes five reasoning levels (minimal, low, medium, high, xhigh), supports parallel tool calling, and runs over WebRTC, WebSocket or SIP through OpenAI's Realtime API per the official voice intelligence announcement.

The two companion models cover different jobs. gpt-realtime-translate does live speech-to-speech translation across 70-plus input languages into 13 output languages at $0.034 per minute. gpt-realtime-whisper is a streaming transcription model at $0.017 per minute with controllable latency. All three share the same Realtime API surface, which exited beta on launch day per the MarkTechPost release breakdown.

What "GPT-5-class reasoning inside the audio loop" means in practice: when you ask the model to look up an order ID and read it back, it can think through the steps, call a tool, narrate "let me check that" while the tool runs, recover from the user interrupting, and stitch the result back into natural speech, all without dropping out of the audio session. The previous pattern needed three separate services and a state machine you wrote yourself.

What is new in Realtime-2 versus Realtime-1?

The short version: smarter, longer-memory, cheaper-per-cached-token, and finally out of beta. The Big Bench Audio benchmark went from 81.4% on Realtime-1.5 to 96.6% on Realtime-2, a 15.2 point gain. Audio MultiChallenge instruction following went from 34.7% to 48.5% at xhigh reasoning. Both numbers are reported by OpenAI on their model card and reproduced by DataCamp's GPT-Realtime-2 writeup.

A few honest caveats. The Big Bench Audio and MultiChallenge scores are reported by OpenAI at high and xhigh reasoning settings, which production deployments rarely use because of latency cost. The 96.6% number is a ceiling, not what you will see at the default low reasoning setting where most voice agents run. Independent reproductions are not yet published.

How much does GPT-Realtime-2 cost?

GPT-Realtime-2 costs $32 per 1M audio input tokens and $64 per 1M audio output tokens, with cached input at $0.40 per 1M, per the OpenAI API pricing page. The two companion models bill per minute instead: gpt-realtime-translate at $0.034 per minute and gpt-realtime-whisper at $0.017 per minute. There is no separate session fee, but you pay for both the user's audio in and the model's audio out, so a balanced two-way call costs roughly the average of the two rates per minute of conversation.

The per-minute estimate for gpt-realtime-2 assumes roughly 6,000-9,000 audio tokens per minute of conversation across input plus output, which is the usual range for natural English speech. Translation and transcription bill flat rates per minute, which makes them easier to budget for telephony or kiosk deployments where call duration is the planning unit.

If your workload is bursty (a customer-support agent that is idle 18 hours a day), the per-token model is cheap. If you run a 24/7 inbound call center where every minute is billable, the per-minute math gets uncomfortable fast, and a self-hosted Whisper-plus-LLM-plus-TTS pipeline starts to look attractive. If you want to self-host a voice pipeline (Whisper + TTS + LLM) instead of paying per minute, RunPod is the cheapest A100 host at roughly $1.49 per hour for community-cloud A100 80GB.

How do I build a voice agent in 30 minutes?

You build a voice agent in 30 minutes by spinning up a Node Express server that mints an ephemeral key for the browser, loading a tiny HTML page that opens a WebRTC peer connection to OpenAI's Realtime endpoint, and registering one function the model can call. Below is the full path. Each step states what success looks like.

Step 1: Install dependencies (2 min)

Create a project folder and install the SDK plus a tiny server.

mkdir gpt-rt2-agent && cd gpt-rt2-agent
npm init -y
npm install openai express dotenv

Success: node_modules exists and package.json lists openai, express, and dotenv.

Step 2: Set your API key (1 min)

Create .env in the project folder.

OPENAI_API_KEY=sk-proj-...

Success: cat.env shows your key. Add .env to .gitignore before committing anything.

Step 3: Write the ephemeral-key server (5 min)

Create server.js. The browser must never see your real API key, so the server mints a short-lived client secret per session.

import 'dotenv/config';
import express from 'express';
import OpenAI from 'openai';

const app = express();
app.use(express.static('public'));
const client = new OpenAI();

app.get('/session', async (req, res) => {
  const session = await client.realtime.sessions.create({
    model: 'gpt-realtime-2',
    voice: 'cedar',
    instructions: 'You are a concise booking assistant. Confirm details before acting.',
  });
  res.json(session);
});

app.listen(3000, () => console.log('listening on :3000'));

Success: node server.js prints "listening on :3000" and curl localhost:3000/session returns JSON with a client_secret field.

Step 4: Build the browser client (10 min)

Create public/index.html. This page asks for the mic, opens a WebRTC peer connection to OpenAI, and pipes audio both ways.

<!doctype html>
<html><body>
<button id="start">Start call</button>
<audio id="remote" autoplay></audio>
<script>
const start = document.getElementById('start');
const remote = document.getElementById('remote');
start.onclick = async () => {
  const { client_secret } = await fetch('/session').then(r => r.json());
  const pc = new RTCPeerConnection();
  pc.ontrack = e => remote.srcObject = e.streams[0];
  const mic = await navigator.mediaDevices.getUserMedia({ audio: true });
  mic.getTracks().forEach(t => pc.addTrack(t, mic));
  const offer = await pc.createOffer();
  await pc.setLocalDescription(offer);
  const res = await fetch('https://api.openai.com/v1/realtime?model=gpt-realtime-2', {
    method: 'POST',
    headers: { Authorization: `Bearer ${client_secret.value}`, 'Content-Type': 'application/sdp' },
    body: offer.sdp,
  });
  await pc.setRemoteDescription({ type: 'answer', sdp: await res.text() });
};
</script>
</body></html>

Success: open http://localhost:3000, click Start, allow the mic, say "hello," hear a reply within ~2 seconds.

Step 5: Add one tool the model can call (8 min)

Replace the instructions line in server.js with a session that registers a check_calendar tool. Add a data-channel listener in the browser that runs JavaScript when the model emits a function call.

// in server.js, expand sessions.create
await client.realtime.sessions.create({
  model: 'gpt-realtime-2',
  voice: 'cedar',
  tools: [{
    type: 'function',
    name: 'check_calendar',
    description: 'Check available slots for a given date',
    parameters: {
      type: 'object',
      properties: { date: { type: 'string', description: 'YYYY-MM-DD' } },
      required: ['date'],
    },
  }],
});

In the browser, add a pc.createDataChannel('oai-events') and listen for response.function_call_arguments.done to execute your handler, then send a conversation.item.create event back with the result. Full event schema is on the OpenAI Realtime guide.

Success: ask "what slots do you have on 2026-05-15," the model calls check_calendar, the browser handler returns mock data, the model speaks the result aloud.

Step 6: Test interruption and barge-in (4 min)

Start a long response, then talk over it. Realtime-2 ships with native interruption recovery, so the model should stop talking, listen, and respond to your new utterance without you wiring extra logic. If barge-in does not work, your mic stream is probably not full duplex. Check getUserMedia constraints and disable browser echo cancellation toggles only if you are debugging.

Success: you can interrupt mid-sentence and the model adapts.

For the bigger architectural picture of where a voice agent fits next to your other agents, see our walkthrough of Claude Managed Agents versus Microsoft Agent 365 cost tradeoffs and our n8n MCP setup guide for wiring voice triggers into a workflow runner.

How does Realtime-2 compare to ElevenLabs, Cartesia, Deepgram, Grok Voice?

Realtime-2 wins on reasoning depth and end-to-end simplicity (one model, one bill). It loses on raw time-to-first-audio against Cartesia Sonic and on language breadth against ElevenLabs. The honest framing is "best general-purpose voice agent for English-heavy reasoning workloads," not "fastest TTS on Earth."

Sources for the comparison numbers: ElevenLabs Flash TTS latency from their public docs, Cartesia Sonic 3 from Softcery's 2026 voice platform survey, Deepgram Aura-2 from their public benchmarks, GPT-Realtime-2 latency from webrtcHacks' 2025 measurement which clocked ~1.7s end-to-end on the previous generation (Realtime-2 is reportedly faster but no independent reproduction is published yet).

A few caveats. Cartesia and ElevenLabs report TTS-only latency (text in, audio out), while OpenAI's number is end-to-end (speech in, reasoning, speech out). They are not the same metric. If you compare them side by side without acknowledging that, you will conclude Cartesia is 40x faster, which is misleading. The right comparison is "TTFA after the user stops talking," and there Realtime-2 is in the ~1.5-2s range while a tightly-tuned stitched pipeline (Deepgram STT + GPT-4-class LLM + Cartesia TTS) can hit ~600-900ms.

What real-world latency can you expect?

Expect roughly 1.5 to 2 seconds end-to-end on Realtime-2 for a short utterance, with WebRTC STUN RTT around 60-70ms on a clean US connection. The previous generation measured 1.76, 1.86, and 1.80 seconds across three speaker switches in webrtcHacks' January 2025 packet capture analysis. OpenAI claims latency improvements in Realtime-2 but has not published a per-region p50 or p95 number.

A few latency rules of thumb that hold across every voice stack we have shipped:

• WebRTC beats WebSocket by 200-400ms in browsers because of native jitter buffering and codec negotiation.

• Long instructions in the system prompt add measurable first-response latency. Keep it under 200 tokens for production.

• High and xhigh reasoning settings can add 500-1500ms. Use low for production, escalate per-turn only when the model needs to plan.

• Real US-to-EU calls add roughly 100ms RTT versus same-region. Always test from your actual user geography.

If sub-second TTFA is non-negotiable, GPT-Realtime-2 is probably not your stack. Use Cartesia Sonic 3 plus a fast LLM for that tier. If you can tolerate 1.5s and you want one model that reasons inside the audio loop, Realtime-2 is the cleanest path.

Common pitfalls and how to avoid them

These are the issues we hit during the May 8-10 build window and saw repeatedly across the launch-week threads on Hacker News and the OpenAI developer forum.

1. Shipping your real API key to the browser. The Realtime API SDP exchange needs an Authorization header, and the lazy fix is to embed your sk- key. Do not. Mint an ephemeral client_secret server-side per session via client.realtime.sessions.create. Anyone who pulls your key off the wire can drain your account.

2. Default reasoning set too high. xhigh reasoning produces the 96.6% Big Bench Audio number but adds noticeable lag. Set reasoning_effort: 'low' in your session config and only escalate per-turn when the model needs to plan a multi-step action.

3. Long system prompts. Anything over ~200 tokens of instructions adds first-response latency on every turn because of audio-tokenization overhead. Move policy and persona detail into a tool the model can query when needed.

4. Forgetting to handle response.function_call_arguments.done. New devs wait for response.done and miss the function call event entirely. The function-call payload arrives on its own event before the final response. Listen for both.

5. Assuming barge-in works without a full-duplex mic. Some browsers (mobile Safari historically, some Android Chromium variants) downgrade getUserMedia streams when the speaker is active. Test interruption on real devices, not just your laptop.

6. Billing surprise from translate plus voice agent stacked. If you wire gpt-realtime-translate ($0.034/min) into a voice-agent session that also runs gpt-realtime-2 ($32/$64 per M tokens), you pay for both. Pick one mode per session unless you genuinely need both.

7. No fallback when the WebRTC handshake fails. Corporate networks sometimes block UDP. Detect the failure and fall back to WebSocket transport rather than telling the user "voice doesn't work."

For agent orchestration patterns that handle these failures gracefully, see our writeup on Claude Code subagent patterns that save context.

FAQ

What is the difference between GPT-Realtime-2 and GPT-Realtime-Whisper?

GPT-Realtime-2 is a full speech-to-speech voice agent with reasoning and tool calling, billed at $32 / $64 per 1M audio tokens. GPT-Realtime-Whisper is a transcription-only model that streams text out as the speaker talks, billed at $0.017 per minute flat. Use Realtime-2 when you need the model to respond in voice, Whisper when you just need a live transcript (closed captions, meeting notes, post-call analytics). They share the same Realtime API surface but bill differently and have different output modalities.

Can I run GPT-Realtime-2 over a phone call?

Yes, via OpenAI's SIP transport for the Realtime API. SIP support shipped alongside the GA release on May 7, 2026 and lets you point a Twilio, Telnyx, or any SIP-compliant carrier directly at the Realtime endpoint without an intermediate transcription layer. The model receives 8kHz mu-law audio (the telephony standard), reasons, and replies. Latency on telephony adds the carrier's own jitter, typically 100-300ms over WebRTC.

How does GPT-Realtime-2 handle interruptions?

GPT-Realtime-2 has native barge-in handling. When the user starts talking while the model is mid-response, the model stops generating audio, ingests the new input, and adapts. You do not need to wire voice-activity-detection or interrupt logic yourself, which was required on stitched STT-plus-LLM-plus-TTS stacks. The catch is that your client must keep the mic stream open during model playback (full duplex), which mobile browsers sometimes downgrade to half duplex.

Is GPT-Realtime-2 cheaper than ElevenLabs Conversational AI?

It depends on usage shape. Per-minute, ElevenLabs Conversational AI plus your own LLM can land between $0.10 and $0.30 depending on the LLM you bring. GPT-Realtime-2 lands roughly $0.30-$0.45 per minute of two-way conversation at default reasoning, which makes it more expensive on raw compute. Realtime-2 wins when reasoning quality matters (you would have paid GPT-5 to reason anyway), and when you value fewer moving parts. ElevenLabs wins on language breadth (70-plus languages) and voice library size.

Which voices does GPT-Realtime-2 support?

GPT-Realtime-2 ships with the existing OpenAI voice set plus two new ones added at launch: Cedar and Marin. The new voices were tuned specifically for the Realtime-2 generation per the MarkTechPost release breakdown. You select the voice in your session config (voice: 'cedar'). Voice cloning is not supported on Realtime-2 the way it is on ElevenLabs; you pick from the OpenAI roster.

Can I self-host an alternative to GPT-Realtime-2?

Not as a single model, no. The closest open-source pattern is Whisper for STT plus an open-weight LLM (Llama 3.1, Nous Hermes 4) plus a TTS like XTTS-v2 or Kokoro, stitched together with your own turn-taking logic. Latency is harder to hit and quality is lower, but the per-minute cost on a $1.49/hr A100 drops to roughly $0.025/min at modest concurrency. Worth it for high-volume internal use, painful for customer-facing.

References

1. OpenAI, "Advancing voice intelligence with new models in the API" (May 7, 2026) openai.com/index/advancing-voice-intelligence-with-new-models-in-the-api

2. OpenAI Realtime API guide developers.openai.com/api/docs/guides/realtime

3. OpenAI API pricing page openai.com/api/pricing

4. MarkTechPost, "OpenAI Releases Three Realtime Audio Models" (May 8, 2026) marktechpost.com

5. DataCamp, "GPT-Realtime-2: A Voice Model with GPT-5-Class Reasoning" datacamp.com/blog/gpt-realtime-2

6. webrtcHacks, "Measuring the response latency of OpenAI's WebRTC-based Realtime API" webrtchacks.com

7. Softcery, "Choosing the right voice agent platform in 2026" softcery.com/lab/choosing-the-right-voice-agent-platform-in-2026

8. RunPod GPU pricing runpod.io/pricing

9. Vantaige, "Nous Hermes 4 self-hosted setup" vantaige.io/blog/nous-hermes-4-self-hosted-setup-vs-closed-agents-2026

10. Vantaige, "Agent 365 vs Claude Managed Agents cost comparison" vantaige.io/blog/agent-365-vs-claude-managed-agents-cost-comparison-2026

Related from Vantaige

• Agent 365 vs Claude Managed Agents: Cost Comparison (2026)

• Nous Hermes 4: Self-Hosted Open-Weight Agent Brain (2026)

• n8n MCP + Claude Code Setup Guide (2026)

• Claude Code Subagents: 3 Patterns That Save Context