OpenAI Realtime API Alternatives in 2026 (How to Migrate)

OpenAI's Realtime API made "talk to your app" easy to prototype: one model, speech in, speech out, low latency. If you're building voice agents in 2026, you've probably tried it.

Prototyping and shipping are different problems, though. Once real users start calling, the single-model architecture that demos well starts working against you — on cost, on transcription accuracy, and on the details of managing a real conversation. That's what sends teams looking for an OpenAI Realtime API alternative that holds up in production.

This post does two things. First, a clear-eyed rundown of the alternatives in 2026 — Gemini Live, ElevenLabs, Deepgram, a couple of open-source options, and AssemblyAI's Voice Agent API. Then a concrete migration walkthrough, because a list isn't much use if nobody tells you how to actually switch.

Let's be specific about what pushes people to look.

Cost you can't predict. OpenAI Realtime is token-priced. The current flagship, gpt-realtime-2.1, runs roughly $32 per million audio input tokens and $64 per million audio output tokens. At the base rate a call lands around $0.05 per minute — fine on a spreadsheet. But conversation context gets re-processed each turn, so on longer calls real bills commonly run 2x to 5x that base rate. Prompt caching helps, but now you're maintaining caching logic just to keep a voice bot affordable. There's a cheaper gpt-realtime-2.1-mini at about $0.016 per minute, but you trade accuracy for the discount. The through-line: your cost per call climbs with call length, and you can't quote a customer a number without a footnote.

Speech accuracy on real audio. This is the architectural crux. OpenAI Realtime is one multimodal model that also does voice, which means transcription isn't a dedicated step — it's one job the model does among many. In AssemblyAI's own side-by-side testing, OpenAI Realtime hallucinated on messy input, inventing words that were never said. On a support line or a drive-through, that's not a rounding error — that's a wrong order.

Barge-in and turn quality. Interruption handling is what separates a conversation from a walkie-talkie. In that same testing, OpenAI Realtime's barge-in logic triggered on background noise — a cough was enough to make it stop talking. An agent that yields the floor to a sneeze is an agent users don't come back to.

Thirty-plus event types. The Realtime API exposes 30+ event types you subscribe to and emit — session updates, input buffer commits, response deltas, and so on. Every one is a thing to handle, a thing to get wrong, and a thing to keep working as the API evolves.

Lock-in. One model doing everything means you can't swap the transcription layer, the reasoning layer, or the voice independently. When one piece underperforms, you don't have a knob — you have a migration.

The right pick depends on what you're optimizing for. Short, factual rundowns, then a table.

Instead of one model doing everything, the Voice Agent API wires together dedicated models for each step — speech-to-text, LLM, and text-to-speech — behind a single WebSocket and a single bill. Pricing is flat at $4.50/hr all-in, so cost doesn't drift with call length. End-to-end latency is around 1 second, it covers 6 languages (EN/ES/FR/DE/IT/PT), and concurrency is unlimited. It's built on Universal-3.5 Pro Realtime, which is the accuracy story below. Best for: production voice agents where transcription accuracy and predictable cost matter most.

Gemini Live is Google's real-time multimodal offering — native audio, video input, and tight integration if you're already in Google's ecosystem. Architecturally it's the same shape as OpenAI Realtime: one large multimodal model, usage-based pricing, and the same "transcription is a side effect" tradeoff, so it inherits the same accuracy and cost-predictability questions. Best for: teams already standardized on Google Cloud who need audio plus vision in one model.

ElevenLabs is known for its text-to-speech, and its Conversational AI product leans on that voice-output quality. On the input side — the part that decides whether your agent hears the caller correctly — its Scribe v2 model lands at 9.76% WER on Pipecat's benchmark, behind the category leaders, and concurrency is capped (around 30), which becomes a constraint at scale. Best for: applications where expressive TTS output is the top priority and input accuracy is secondary. (More in our AssemblyAI vs. ElevenLabs comparison.)

Deepgram offers a single-API Voice Agent product in the same shape as AssemblyAI's. The differentiator is accuracy on real agent audio: its newer Flux model comes in at 15.58% WER on the Pipecat benchmark, well behind the leaders, and the gap widens on entity error — getting names, numbers, and addresses right — where Flux reaches 50.50%. Best for: teams already invested in Deepgram's stack. (Full breakdown in our AssemblyAI vs. Deepgram comparison.)

If you want to own the whole stack and self-host, the open-source options are worth a look. Kyutai's Moshi is a full-duplex speech model you can run yourself; Alibaba's Qwen-Omni is a multimodal model you can wire into orchestration frameworks like Pipecat or LiveKit. You avoid a per-minute fee, but you take on the hosting, scaling, reliability, and accuracy-tuning yourself. Best for: teams with ML infrastructure that need on-prem or full customization and can staff the maintenance. Here's how they stack up:

The wedge is simple. OpenAI Realtime is one multimodal model that also does voice. The Voice Agent API is dedicated models per step, assembled for conversation quality. That difference shows up in four places that matter when real calls are coming in.

Accuracy that holds on real audio. On Pipecat's open STT benchmark — lower is better — Universal-3.5 Pro Realtime posts 6.99% WER. For context: Google Chirp3 sits at 9.04%, ElevenLabs Scribe v2 at 9.76%, and Deepgram Flux at 15.58%. The gap widens on entities — the names, order numbers, and addresses your business actually runs on. Universal-3.5 Pro Realtime's entity error rate is 15.31% versus Deepgram's 50.50%. When a caller says "my confirmation is A-as-in-apple 4 7 2," that's the number that decides whether the call works. More on the model in the Universal-3.5 Pro Realtime launch post.

Context that raises accuracy further. You can feed the agent live context — product names, customer vocabulary, whatever your domain needs. Across 20,000 files, using agent_context cut WER by 10.2%. That's a tuning knob a single-model architecture doesn't expose.

One WebSocket instead of 30+ events. No SDK required, standard JSON over a WebSocket. You're not subscribing to a taxonomy of event types — you send audio and handle responses. That's a big reason the Voice Agent API plays well with coding agents like Claude Code, which can scaffold an integration without wrestling a sprawling event model.

Predictable everything. Flat $4.50/hr all-in — STT, LLM, and TTS through one bill — so a 2-minute call and a 20-minute call cost what you'd expect. Around 1-second end-to-end latency. Unlimited concurrency, so a traffic spike doesn't mean a support ticket. And you can change configuration mid-conversation instead of tearing down and rebuilding a session. For where these differences bite, we wrote up where voice agent stacks start showing their limits.

Want to hear it before you read another word of code? Talk to a Live Agent — it's the fastest way to judge latency and interruption handling for yourself.

The good news: if you built on OpenAI Realtime, you already have the hard parts — audio capture, a client transport, and turn logic. Migration is mostly re-pointing them at a simpler surface.

Here's how the mental model translates:

The shift in one sentence: instead of configuring a session with a wall of parameters and events, you define an agent as a durable object, then open a realtime connection to it.

Define it once with a single API call:

curl -X POST https://agents.assemblyai.com/v1/agents
-H "Authorization: $ASSEMBLYAI_API_KEY" \

-H "Content-Type: application/json" \

-d '{

"name": "Quickstart Assistant",

"system_prompt": "You are a friendly assistant having a casual voice conversation. Keep replies short and natural.",

"greeting": "Hey there, what can I help with?",

"voice": { "voice_id": "alba" }

}'

That returns an agent_id. To go live, you connect to it over a realtime WebSocket by referencing that agent_id — and the same agent works unchanged from a server, a browser, or a phone. Define once, connect anywhere. For a fuller build, walk through how to build with the Voice Agent API.

This one trips people up. For best accuracy, feed the model raw audio. If you're capturing in a browser, disable noiseSuppression and autoGainControl in your getUserMedia constraints — but keep echoCancellation on. Aggressive client-side processing is tuned to make audio sound nice to humans, and in doing so it smears the very signal a transcription model relies on. You want the microphone's honest output going over the wire, not a cleaned-up version that's lost detail. Turning that processing off is often the single biggest accuracy win in a migration.

You don't rebuild an agent to change its behavior. Because configuration is live, you can adjust the system prompt or swap context mid-conversation without tearing down the connection — handy for escalating tone, injecting a looked-up account detail, or handing off between skills. And since the agent is a persistent object rather than an ephemeral session, reconnecting a dropped call is a matter of connecting to the same agent_id again, not reconstructing state from scratch.

That's the whole migration. Point your existing audio pipeline at one WebSocket, define your agent once, fix your browser audio constraints, and you're running.

You don't have to take the benchmark numbers on faith.

It depends on what you're optimizing for, but for production voice agents where transcription accuracy and predictable cost matter most, AssemblyAI's Voice Agent API is the closest drop-in. It uses dedicated models per step behind one WebSocket, posts 6.99% WER on Pipecat's benchmark, and bills at a flat $4.50/hr. Gemini Live fits teams deep in Google Cloud, and ElevenLabs fits cases where TTS output quality outweighs input accuracy.

It's token-priced and variable. The flagship gpt-realtime-2.1 runs about $32 per million audio input tokens and $64 per million output tokens — roughly $0.05 per minute at the base rate. Because conversation context gets re-processed each turn, real bills commonly run 2x to 5x higher on longer calls. There's a cheaper gpt-realtime-2.1-mini at around $0.016 per minute. The catch is predictability: your cost per call climbs with call length.

"Cheaper" is less useful than "predictable." AssemblyAI's Voice Agent API is a flat $4.50/hr all-in — STT, LLM, and TTS on one bill — so cost doesn't drift with call length the way token-based pricing does. Open-source options like Moshi or Qwen-Omni have no per-minute fee, but you take on the hosting, scaling, and accuracy-tuning costs yourself.

Reuse your existing audio capture and transport. Create an agent once with a single POST (name, system prompt, greeting, voice), then connect to the returned agent_id over a realtime WebSocket. Replace the 30+ event-type handling with a single send-audio/receive-message loop. One migration tip: if you capture audio in the browser, disable noiseSuppression and autoGainControl while keeping echoCancellation on, since aggressive client-side processing hurts transcription accuracy.

OpenAI Realtime is one multimodal model that handles speech-to-text, reasoning, and speech output all at once — but transcription is just one job among many, which is where hallucination on messy audio creeps in. A cascaded (dedicated-models-per-step) pipeline like AssemblyAI's routes each stage to a purpose-built model, so you get category-leading transcription accuracy, the ability to feed in live context, and the option to tune each layer independently — all still behind one WebSocket.