Now live New models for transcription and text-to-speech. AssemblyAI-STT-3.7 AssemblyAI-TTS-1
Insights & Use Cases

AssemblyAI vs Deepgram for voice agents: AssemblyAI-STT-3.7-Realtime-Agent vs Flux and Nova-3

AssemblyAI-STT-3.7-Realtime-Agent vs Deepgram Flux and Nova-3 on 12,460 voice-agent calls: 4.53% WER vs 13.50% and 8.64%, plus turn detection and pricing.

Abstract green mobius illustration

Written by

Kelsey Foster

Published on

18 November 2026

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.
Hear the difference on your own calls

Stream your own call audio through AssemblyAI-STT-3.7-Realtime-Agent and check the names, numbers and email addresses your agent depends on.

Try playground

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 reaches eot_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=manual and send ForceEndpoint when 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. SpeechStarted fires 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-en is English only. flux-general-multi covers 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.

Swap Flux for AssemblyAI-STT-3.7-Realtime-Agent

Get an API key with free credit, change the WebSocket URL and model ID, and run your own calls through the Agent model.

Sign up free

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.

Run your calls through both models

Start free, stream your own recordings through AssemblyAI-STT-3.7-Realtime-Agent, and compare the transcripts with what Flux gives you today.

Sign up free

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.