If you're picking the speech-to-text layer for a voice agent, the AssemblyAI vs Deepgram question comes down to three models: AssemblyAI-STT-3.7-Realtime-Agent, Deepgram Flux and Deepgram Nova-3. On 12,460 English voice-agent calls, AssemblyAI-STT-3.7-Realtime-Agent has a 4.53% word error rate, against 8.64% for Deepgram Nova-3 and 13.50% for Deepgram Flux EN. It's the lowest word error rate and the lowest entity error rate of the 26 streaming models AssemblyAI ran.
This post covers accuracy on the words agents act on, turn detection, what each Deepgram model leaves out, code, and pricing. Every AssemblyAI figure comes from the AssemblyAI-STT-3.7-Realtime-Agent research post, published November 18, 2026. Every Deepgram product fact comes from Deepgram's own docs and pricing page, checked November 18, 2026.
If you're comparing a managed, all-in-one voice agent instead of the STT layer, read the Deepgram Voice Agent API comparison. For recorded audio and general transcription, see AssemblyAI vs Deepgram.
AssemblyAI vs Deepgram for voice agents at a glance
| Factor | AssemblyAI-STT-3.7-Realtime-Agent | Deepgram Flux | Deepgram Nova-3 |
|---|---|---|---|
| Word error rate, 12,460 English voice-agent calls | 4.53% | 13.50% (Flux EN) | 8.64% |
| Entity error rate, same calls | 13.2% | 28.8% (Flux EN) | 25.1% |
| Turn detection | Adaptive, entity-aware endpointing; manual mode for your own turn detector | Model-integrated end-of-turn events | Endpointing and utterance-end events, no turn events |
| Languages | 32, with native code switching | English (flux-general-en); 10 (flux-general-multi) | 55 (multi), plus monolingual options |
| Formatted output | Punctuated, formatted transcripts | No smart formatting | Smart formatting supported |
| Published price | $0.45/hr of session time | $0.0065/min English, $0.0078/min multilingual (pay as you go) | $0.0048/min monolingual streaming (pay as you go) |
Accuracy: AssemblyAI-STT-3.7-Realtime-Agent vs Deepgram Flux and Nova-3
AssemblyAI ran 26 streaming models on the same 12,460 English voice-agent calls: scripted scenarios voiced by 522 real speakers, recorded as telephony audio with no, low or heavy background noise, and streamed with no key terms or context for any provider. The reference transcribes only the caller, so words picked up from a TV or a coworker count as errors.
| Model | Word error rate | Entity error rate |
|---|---|---|
| AssemblyAI-STT-3.7-Realtime-Agent | 4.53% | 13.2% |
| Deepgram Nova-3 | 8.64% | 25.1% |
| Deepgram Flux EN | 13.50% | 28.8% |
Normalized word error rate averaged over three noise conditions, runs August to November 2026. Entity error rates are from the same calls and runs; the Flux EN entity figure is published in the AssemblyAI-STT-3.7 launch post. Flux EN makes nearly three times as many word errors as AssemblyAI-STT-3.7-Realtime-Agent on the same calls, and Nova-3 nearly twice as many. The lead holds in heavy background noise, where AssemblyAI-STT-3.7-Realtime-Agent's word error rate is 5.32% against 9.93% for Deepgram Nova-3. Full tables are on the AssemblyAI benchmarks page.
Entities: the words the agent has to act on
Word error rate averages over every word. A voice agent mostly cares about a few of them: the caller's name, a phone number, a date, an amount. Get one digit wrong and the booking, refund or account lookup fails.
On each entity class, AssemblyAI-STT-3.7-Realtime-Agent makes fewer errors than Deepgram Nova-3, and the gap holds in a paired 95% interval on every one:
| Entity class | AssemblyAI-STT-3.7-Realtime-Agent | Deepgram Nova-3 |
|---|---|---|
| Phone numbers | 2.03% | 4.35% |
| Email addresses | 13.98% | 31.46% |
| Names | 10.18% | 23.69% |
| Dates and times | 17.66% | 43.89% |
| Numbers and currency | 12.38% | 16.70% |
Short replies are where a misheard word changes what the agent does next. On the short utterances in the same calls, AssemblyAI-STT-3.7-Realtime-Agent's entity error rate is 12.0%, against 28.2% for Deepgram Nova-3 and 28.8% for Deepgram Flux EN. Accents widen the gap too: on Indian-accented callers, its entity error rate is 17.6% against 32.93% for Nova-3.
Independent benchmarks
Two outside benchmarks ran AssemblyAI-STT-3.7-Realtime-Agent on their own audio:
- Speko scores streaming models on word error rate, end-of-turn latency and time to first token at real-time pace. AssemblyAI-STT-3.7-Realtime-Agent comes in ahead of Deepgram Flux, ElevenLabs Scribe v3 Live, Soniox Realtime v6, Fish Transcribe Stream 1 and Cartesia Ink-2 on all three.
- Voice Arena scores models on a private conversational set and ranks AssemblyAI-STT-3.7-Realtime-Agent the #1 streaming model for US English, at 2.45% semantic WER.
Stream your own call audio through AssemblyAI-STT-3.7-Realtime-Agent and check the names, numbers and email addresses your agent depends on.
Turn detection: Deepgram Flux vs AssemblyAI
Turn detection decides when your agent starts talking. End the turn early and the agent cuts the caller off halfway through a card number. End it late and every reply feels slow.
How Deepgram Flux handles turns
Per Deepgram's Flux quickstart, Flux runs on the /v2/listen endpoint and emits turn events from the model itself:
- EndOfTurn fires when the model's end-of-turn confidence reaches
eot_threshold(0.5 to 1.0, default 0.7), or when silence reacheseot_timeout_ms(500 to 60,000 ms, default 5,000). - EagerEndOfTurn and TurnResumed are off by default. Setting
eager_eot_threshold(0.3 to 0.9) turns them on so you can start an LLM response early and cancel it if the caller keeps talking. Deepgram's docs say this can raise LLM calls by 50 to 70%. - Thresholds can be changed mid-stream with a Configure message.
Nova-3 has no turn events. It uses endpointing and utterance-end signals, per Deepgram's Flux vs Nova-3 comparison.
How AssemblyAI handles turns
AssemblyAI's turn detection doesn't end turns on silence alone. When the caller pauses for min_turn_silence, the model reads what's been said in the turn so far. If it reads as finished, the turn ends. If it ends in something that may continue, like part of a phone number, an email address, a date or a name, the turn stays open until max_turn_silence. That's entity-aware endpointing, and it's on by default in every mode:
| mode | min_turn_silence | max_turn_silence (entity hold) |
|---|---|---|
| min_latency | 128 ms | 640 ms |
| balanced | 128 ms | 1,280 ms |
| max_accuracy | 512 ms | 2,560 ms |
AssemblyAI-STT-3.7-Realtime-Agent also uses the conversation context in that end-of-turn decision, holds a turn open when the caller starts speaking again, and won't split a long turn inside a number or an address. Against Universal-3.6 Pro Realtime, it has 12% fewer false end-of-turn events, and it returns the final transcript 86 ms after the caller stops speaking. With Gemma 4 31B through AssemblyAI's LLM Gateway and AssemblyAI-TTS-1, end-to-end turn latency is regularly around 250 ms.
Two more controls matter if you've built around Flux's events:
- Your own turn detector. Connect with
mode=manualand sendForceEndpointwhen your detector (LiveKit's turn detector, your own VAD, a push-to-talk release) says the turn is over. Manual mode is supported only on AssemblyAI-STT-3.7-Realtime-Agent. - Barge-in.
SpeechStartedfires only once the model has produced a transcript, so background noise alone doesn't trigger it. Stop your TTS when it arrives.
For a deeper walk-through of the trade-offs, read how turn detection works in voice agents.
What Deepgram Flux leaves out
These come from Deepgram's own Flux vs Nova-3 comparison and models and languages overview:
- No speaker diarization on Flux.
- No smart formatting on Flux.
- Redaction covers numbers only on Flux.
- Languages:
flux-general-enis English only.flux-general-multicovers 10 languages: English, Spanish, French, German, Hindi, Russian, Portuguese, Japanese, Italian and Dutch. If your agent needs a language outside those 10 with turn events, you're switching models. - Meeting transcription, pre-recorded audio and call analytics are listed as unsupported on Flux. Those run on Nova-3, a separate model with a separate endpoint (
/v1/listen).
AssemblyAI-STT-3.7-Realtime-Agent covers 32 languages with native code switching on one model, with keyterm prompting and context carryover built in, and Voice Focus for noisy rooms.
Code: stream a call to AssemblyAI-STT-3.7-Realtime-Agent
This connects to the streaming WebSocket with the Agent model, boosts a few terms with keyterms_prompt, seeds the first turn with the agent's greeting through agent_context, and passes each agent reply back in with UpdateConfiguration. keyterms_prompt goes on the URL as one JSON-encoded parameter. The raw API key goes in the Authorization header with no Bearer prefix.
# pip install websocket-client
import json
import os
import threading
import time
import wave
from urllib.parse import urlencode
import websocket
API_KEY = os.environ["ASSEMBLYAI_API_KEY"]
CONNECTION_PARAMS = {
"speech_model": "assemblyai-stt-3-7-realtime-agent",
"sample_rate": 16000,
"encoding": "pcm_s16le",
"keyterms_prompt": json.dumps(["Byrne-Donoghue", "ORD-652895", "Uber Eats"]),
"agent_context": "Thanks for calling. What's the name on the order?",
}
API_ENDPOINT = f"wss://streaming.assemblyai.com/v3/ws?{urlencode(CONNECTION_PARAMS)}"
def on_open(ws):
def stream_audio():
# 16 kHz, mono, 16-bit PCM. Send 50 ms chunks at real-time pace.
with wave.open("caller_16k_mono.wav", "rb") as wav:
while True:
chunk = wav.readframes(800)
if not chunk:
break
ws.send(chunk, websocket.ABNF.OPCODE_BINARY)
time.sleep(0.05)
ws.send(json.dumps({"type": "Terminate"})) # always close the session
threading.Thread(target=stream_audio, daemon=True).start()
def on_message(ws, message):
data = json.loads(message)
if data.get("type") == "Turn" and data.get("end_of_turn"):
print("Caller:", data["transcript"])
# Your LLM and TTS go here. Pass what the agent says next back in as context.
reply = "Got it. What's the best number to reach you?"
ws.send(json.dumps({"type": "UpdateConfiguration", "agent_context": reply}))
def on_error(ws, error):
# websocket-client reports the server's normal close frame here; ignore it.
if isinstance(error, websocket.ABNF) and error.opcode == websocket.ABNF.OPCODE_CLOSE:
return
print("Error:", error)
ws = websocket.WebSocketApp(
API_ENDPOINT,
header={"Authorization": API_KEY},
on_open=on_open,
on_message=on_message,
on_error=on_error,
)
ws.run_forever()The model carries finalized caller turns forward on its own; agent_context fills in the agent's side. The context carryover docs cover the full pattern.
Get an API key with free credit, change the WebSocket URL and model ID, and run your own calls through the Agent model.
Pricing: AssemblyAI vs Deepgram for voice agents
AssemblyAI bills streaming per hour of session time, the time the WebSocket stays open. Deepgram bills per minute and lists separate pay-as-you-go and Growth rates. Prices below are as published on November 18, 2026; see the AssemblyAI pricing page and Deepgram's pricing page.
| Model | Published rate | Notes |
|---|---|---|
| AssemblyAI-STT-3.7-Realtime-Agent | $0.45/hr | Session duration; volume discounts available |
| Deepgram Flux English | $0.0065/min pay as you go; $0.0057/min Growth | Promotional; listed as "was" $0.0077 and $0.0065 |
| Deepgram Flux Multilingual | $0.0078/min pay as you go; $0.0068/min Growth | 10 languages |
| Deepgram Nova-3 streaming, monolingual | $0.0048/min pay as you go; $0.0042/min Growth | Promotional; listed as "was" $0.0077 and $0.0065 |
| Deepgram keyterm prompting | $0.0013/min pay as you go; $0.0011/min Growth | Add-on, billed on top of the model rate |
Deepgram's Growth plan starts at $4,000+ per year in pre-paid credits. Its pricing page lists 150 concurrent streaming connections on pay as you go and 225 on Growth.
AssemblyAI limits how many new streaming sessions you open per minute, not how many are open at once. Paid accounts start at 200 new sessions per minute, and the limit grows by 10% every minute you use 80% or more of it, with no ceiling, per the streaming rate limits docs. For a voice agent, that means a traffic spike doesn't hit a fixed stream cap.
Which should you choose for your voice agent?
If your agent books appointments, takes orders, verifies identities or collects payment details, the numbers above point one way. AssemblyAI-STT-3.7-Realtime-Agent makes fewer errors than Deepgram Flux and Nova-3 on the full call, on short replies, in heavy noise, and on each entity class measured against Nova-3. Its turn detection holds the turn open for the entity your agent asked for, and you can hand turn control to your own model when you need to. One model covers 32 languages, so a caller who switches languages mid-call doesn't force a model swap.
Deepgram Flux has turn events built into the model, an English-only model plus a 10-language variant, and no diarization or smart formatting. Nova-3 adds languages and formatting but drops turn events. Choosing Deepgram for a voice agent means choosing between those two sets of gaps.
The fastest way to settle it is to run the same calls through both. For more options, see our list of Deepgram alternatives.
Start free, stream your own recordings through AssemblyAI-STT-3.7-Realtime-Agent, and compare the transcripts with what Flux gives you today.
What changed from Universal-3.6 Pro Realtime
If you compared AssemblyAI and Deepgram on Universal-3.6 Pro Realtime, here's what moved. Universal-3.6 Pro Realtime is still fully supported at the same $0.45/hr.
| Metric | Universal-3.6 Pro Realtime | AssemblyAI-STT-3.7-Realtime-Agent | Change |
|---|---|---|---|
| Word error rate, voice-agent calls | 5.26% | 4.53% | −14% |
| Background-speech leakage (words per 1,000) | 2.53 | 1.34 | −47% |
| Dropped short responses | 0.29% | 0.18% | −38% |
| Number errors, Voice Code Bench | 11.28% | 2.27% | −80% |
| Time to final transcript | 172 ms | 86 ms | −50% |
Moving over is a one-line change: set speech_model to assemblyai-stt-3-7-realtime-agent. The AssemblyAI-STT-3.7 launch post covers the rest of the family.
Frequently Asked Questions (FAQs)
Is AssemblyAI more accurate than Deepgram for voice agents?
Yes. On 12,460 English voice-agent calls, AssemblyAI-STT-3.7-Realtime-Agent has a 4.53% word error rate against 8.64% for Deepgram Nova-3 and 13.50% for Deepgram Flux EN, and a 13.2% entity error rate against 25.1% for Nova-3 and 28.8% for Flux EN. It's the lowest word error rate and entity error rate of the 26 streaming models AssemblyAI ran. On the independent Speko benchmark, it comes in ahead of Deepgram Flux on word error rate, end-of-turn latency and time to first token.
What is Deepgram Flux?
Flux is Deepgram's streaming speech-to-text model for voice agents. It runs on Deepgram's /v2/listen endpoint and emits turn events (EndOfTurn, plus optional EagerEndOfTurn and TurnResumed) from the model. flux-general-en is English only and flux-general-multi covers 10 languages. Per Deepgram's docs, Flux doesn't support speaker diarization or smart formatting.
What are the differences between Deepgram Flux and Nova-3?
Flux has model-integrated turn detection and turn events; Nova-3 doesn't. Nova-3 supports speaker diarization, smart formatting and 55 languages in multilingual mode. Flux supports neither diarization nor smart formatting, and its multilingual model covers 10 languages. They also use different endpoints: Flux on /v2/listen, Nova-3 on /v1/listen. On AssemblyAI's voice-agent benchmark, Flux EN's word error rate is 13.50% and Nova-3's is 8.64%.
How much does Deepgram cost compared to AssemblyAI?
As published on November 18, 2026, Deepgram Flux English is $0.0065 per minute on pay as you go (a promotional rate, listed as down from $0.0077), Flux Multilingual is $0.0078 per minute, and Nova-3 monolingual streaming is $0.0048 per minute. Keyterm prompting is a $0.0013-per-minute add-on. AssemblyAI-STT-3.7-Realtime-Agent is $0.45 per hour of session time, with volume discounts available.
How is AssemblyAI's turn detection different from Deepgram Flux?
Flux ends a turn when its end-of-turn confidence passes eot_threshold (default 0.7) or after eot_timeout_ms of silence (default 5,000 ms). AssemblyAI checks whether the turn reads as finished after a short pause, and holds the turn open when it ends in an entity that may continue, such as part of a phone number or an email address. Entity-aware endpointing is on by default, and the mode preset sets how long a held turn can wait.
Can I use my own turn detection model with AssemblyAI?
Yes. Connect AssemblyAI-STT-3.7-Realtime-Agent with mode=manual and send a ForceEndpoint message when your own detector or VAD decides the turn is over. The server returns that turn's final transcript right away. In the other modes, ForceEndpoint still works, but the server also ends turns on its own.