Best STT for Voice Agents in 2026: xAI, Deepgram Flux, Nova-3 and the Session-Billing Trap

What is the best speech-to-text API for voice agents in 2026?

Deepgram Flux if you want transcription and turn detection solved by one model, Deepgram Nova-3 if you'd rather run your own end-of-turn model and pay less, and xAI if cost is the binding constraint and you can live with a newer product. AssemblyAI Universal-Streaming has the lowest published streaming rate in the category at $0.15 an hour, and the most surprising billing mechanic, which you must model before you choose it.

The framing that matters, and which almost no comparison uses: choosing an STT for a voice agent is now choosing a turn-detection architecture. Deepgram's Flux fuses transcription and end-of-turn detection into a single conversational model. Everything else leaves the two separate, so you pair it with something like LiveKit's audio turn detector. These are two different systems with different failure modes, tuning surfaces and costs, and most readers don't realise they're making that decision until it's made.

The accuracy bake-off that dominates this category is largely a distraction. All the major models are good enough on clean English that word error rate isn't what breaks your agent. What breaks your agent is finalisation timing, domain vocabulary, and 8kHz phone-band audio, and only one of those three is fixed by picking a different model.

Everything below is checked against the vendors' own pages on 24 August 2026. Where a figure is a vendor's own reported claim rather than an independent measurement, I say so in the same sentence, because in this category that distinction does most of the work.

Why is xAI's speech-to-text priced per hour, and is it really that cheap?

It's genuinely that cheap, and there's a catch nobody has written up. xAI lists Speech to Text at $0.10 per hour for REST and $0.20 per hour for streaming on docs.x.ai/developers/pricing, last updated 21 August 2026. Converted to the unit everyone else uses, that's $0.0017 and $0.0033 per minute.

The catch is that 2x split. The headline $0.10 per hour is the REST rate, and REST is batch transcription: you send a file, you get a transcript. It can't sit in a live agent's critical path, because a voice agent needs partial results streaming back while the caller is still talking. For an agent you pay the streaming rate of $0.20 an hour. Anyone quoting $0.10 an hour as a voice-agent cost is quoting the wrong SKU, and I expect to see that mistake spread.

Even at the streaming rate it's remarkable. $0.0033 a minute is below Deepgram Nova-3's promotional $0.0048 and well below Flux's $0.0065, and it's corroborated independently: LiveKit's own inference rate card lists xAI Speech to Text at $0.003333 per minute across every plan tier, exactly $0.20 an hour. Two sources, same number.

What you give up is maturity and disclosure. Rime publishes a latency distribution; Deepgram publishes concurrency limits per tier; AssemblyAI publishes its billing mechanics in detail. xAI publishes a price. That's a real trade for a production system, and why I wouldn't tell a regulated buyer to switch on price alone. But at a third of a cent a minute it belongs on every shortlist, and it's a large part of why a self-orchestrated stack lands near 2.5¢ a minute at all.

Put your own volume through the voice AI cost calculator and you'll see the same thing I did: transcription is now the smallest lever you have. If you want the whole pipeline built so that swapping any provider is a one-line change rather than a rewrite, that's what voice AI development is for. And under about 20,000 minutes a month, a managed platform is still the right call, for the reasons in the voice AI build vs buy break-even.

How does AssemblyAI's session billing actually work?

It bills the wall-clock time your WebSocket stays open, not the audio you send. AssemblyAI's own documentation states it in a warning box, in plain language: "Streaming Speech-to-Text is billed on the total duration that your WebSocket connection stays open, not on the amount of audio you send. You're charged for the entire session — including any time the connection is idle with no audio flowing."

Be precise about what this does and doesn't mean, because the sloppy version of the claim is wrong. For an ordinary voice agent that opens a socket at the start of a call and closes it at the end, session-duration billing and audio-minute billing produce almost the same number, and at $0.15 an hour AssemblyAI Universal-Streaming is then the cheapest streaming option on the chart above, cheaper than Deepgram. The mechanic isn't a penalty. It's a different exposure surface.

The exposure is real and has four shapes. A socket you fail to terminate auto-closes after three hours and bills all three, which AssemblyAI's docs call "the most common cause of unexpected charges that lead to negative account balances." Sockets held open between calls to save reconnection latency bill the idle time. Concurrent sessions accumulate in parallel, so dual-streaming a single call under two session IDs bills twice. And their Voice Agent API has a 30-second resume grace window after an unclean disconnect that's billable unless you send an explicit session end.

None of that is hidden. AssemblyAI documents all of it, which is more than most of the category does, and why I'm comfortable recommending them. But it changes what you have to build: a termination path that fires on every exit route including the ones you didn't think of, and an alert on the ratio between session duration and audio duration. Both values come back in the Termination event, which makes the monitoring trivial once you know to look.

# AssemblyAI returns both in the Termination event.
{"type":"Termination","audio_duration_seconds":118,"session_duration_seconds":121}
  ratio 1.03 — healthy. 3s of setup and teardown.
{"type":"Termination","audio_duration_seconds":118,"session_duration_seconds":10800}
  ratio 91.5 — a leaked socket that hit the 3-hour auto-close.
  billed 180 min for a 2 min call. this is the failure mode.
$ # alert rule: session_duration_seconds / audio_duration_seconds > 1.5

What is Deepgram Flux and how is it different from Nova-3?

Flux is a conversational speech recognition model that fuses transcription with turn detection; Nova-3 is a general-purpose streaming transcription model that leaves turn detection to you. That single architectural difference is worth more of your attention than any accuracy comparison between them.

Deepgram reports roughly 30% fewer false interruptions and 200–600ms lower agent response latency for Flux against a traditional pipeline. Those are Deepgram's own reported figures, not an independent benchmark, so read them as a directional vendor claim. The architecture is real and the reasoning is sound: a model that already has the acoustic and lexical context can decide the turn is over without a second round trip to a separate model.

What you give up is a separately tunable endpointing surface. With Nova-3 plus LiveKit's audio turn detector you control min_delay, max_delay and an unlikely_threshold you can set per language, exactly the knob you need to make an assessment agent patient and a booking agent fast. With Flux, turn-taking is a property of the model. LiveKit's docs note that where an STT provides built-in end-of-turn signals, a configured turn detector takes precedence and the STT's signals are used only when you explicitly set turn_detection to "stt". So you can run both, but decide which one is authoritative rather than discovering it.

On price the difference is small: Flux English at $0.0065 a minute promotional against Nova-3 Monolingual at $0.0048, both against a $0.0077 regular rate. That's $0.0017 a minute, or $170 at 100,000 minutes a month. Don't pick on that. Pick on whether you want to own the tuning surface, which is the subject of turn detection and barge-in for voice agents.

What actually fixes your STT accuracy problem?

Keyterm prompting, almost always. If your agent mishears product names, drug names, ticker symbols or your own company name, that's not a model-choice problem and switching vendors won't fix it. Deepgram prices keyterm prompting at $0.0013 a minute on streaming, the cheapest accuracy improvement anywhere in a voice stack.

Word error rate benchmarks mislead for voice agents in two ways. They're computed on clean read speech rather than 8kHz phone-band audio with background noise, and they weight all words equally. But in a voice agent, getting "amoxicillin" wrong matters enormously and getting "um" wrong matters not at all. A model with a worse headline WER and better handling of your twenty domain terms produces a better agent.

The second real fix is acknowledging the phone path. Telephony audio is narrowband and lossy in ways your browser testing isn't, and accuracy degrades accordingly. I won't put a number on that degradation because I haven't measured it rigorously enough to publish one, and neither has anyone else I can cite. But evaluate on recorded phone audio from your own traffic rather than studio samples, and the difference will be visible without a number.

The third is knowing what to turn off. Diarization, entity detection and sentiment analysis are useful for post-call analytics and useless in the critical path of a live turn, and Deepgram prices each separately: diarization at $0.0020 a minute, entity detection at $0.0017. Run them on the recording after the call, not on the stream during it.

What are the concurrency limits, and why do they break launches?

Because your concurrent-call ceiling is almost always a vendor tier rather than your servers, and raising it is a commercial conversation that takes days. You can provision as much compute as you like and still be capped at a number you never checked.

Deepgram publishes theirs, which is unusually helpful: up to 150 concurrent streaming WebSocket connections on pay-as-you-go and 225 on Growth, up to 50 on the REST API, 45 TTS on pay-as-you-go and 60 on Growth, 45 and 60 on the Voice Agent API, 5 for Whisper Cloud, and 10 for Audio Intelligence. Growth starts at $4,000 a year and offers up to 20% off. AssemblyAI's new-session rate limits scale automatically with usage, defaulting to 5 for free accounts.

The failure mode is what makes this worth a section rather than a footnote. Hitting a transcription concurrency cap doesn't produce a clean error your monitoring catches. It produces a call that connects, the caller says hello, and nothing happens: a connected-but-silent call. If you haven't seen it before that's a three-hour incident at peak traffic, and it'll happen during the launch you told your customer about.

So do the arithmetic before launch week. Peak concurrent calls is roughly your busiest-hour call volume times average call duration in hours. Add 50% headroom, compare against every ceiling in your stack, STT, TTS, LiveKit sessions, telephony channels, and get the smallest one raised in writing. The telephony half is covered in LiveKit SIP trunking with Twilio vs Telnyx.