# Voxtral 3 Speech-to-Text: Accuracy vs Nemotron 3.5, Languages, Transcription

> I compare Mistral's Voxtral 3 and NVIDIA's Nemotron 3.5 Transcribe across word error rate, 50+ languages, speaker diarization, and no-backend desktop setup.

- URL: https://freelivecaption.com/en/posts/voxtral-3-vs-nemotron-3-5
- Author: Emily Carter (https://freelivecaption.com/en/about)
- Topic: Dictation (https://freelivecaption.com/en/topics/dictation)

## Summary

- Side-by-side specs and pricing for Voxtral 3 (Small, Mini, Realtime), NVIDIA Nemotron 3.5 Transcribe (30B-A4B), Vocena cloud models, and GPT
- Why Voxtral 3 drops from 50+ languages in batch mode to 35+ in realtime streaming, and where Nemotron 3.5's 40-language set wins
- Performance on overlapping speakers, noisy accented calls, and TTS script verification using Context Biasing vs Prompt Steering
- How to run both models from desktop transcription tools or a 10-line script without managing a GPU backend

---

When I started testing Mistral's [Voxtral 3](https://mistral.ai/news/voxtral-3) against NVIDIA's [Nemotron 3.5 Transcribe](/en/posts/nemotron-3-5-transcribe) on my own meeting recordings and bilingual podcast tracks, the first hurdle was figuring out which model variants actually compete with each other. Mistral split Voxtral 3 into three separate transcription APIs—two for batch files and one for live audio streams—while NVIDIA released a single 30-billion-parameter Mixture-of-Experts model (`NVIDIA-Nemotron-3.5-Transcribe-30B-A4B`) that folds transcription, speaker diarization, and natural-language formatting into one offline pass.

If you are deciding which model to wire into your transcription workflow—or whether to finally retire GPT—here is how their specifications, error rates, and runtime limits compare side by side.

| Feature | Voxtral 3 (Mistral AI) | Nemotron 3.5 Transcribe (NVIDIA) | Whisper (large-v3 / turbo) |
| :--- | :--- | :--- | :--- |
| **Model Variants** | `voxtral-small-transcribe-3-0` (flagship batch)<br>`voxtral-mini-transcribe-3-0` (4B batch)<br>`voxtral-mini-transcribe-realtime-3-0` (streaming) | `nvidia/NVIDIA-Nemotron-3.5-Transcribe-30B-A4B` (single unified model) | `whisper-large-v3` (1.55B)<br>`whisper-large-v3-turbo` (809M) |
| **Weights & Access** | Closed weights; Mistral API (US, EU, global) or enterprise on-prem | Open weights (`OpenMDW-1.1` on Hugging Face), NGC NIM, or hosted APIs | Open weights (`MIT`) and hosted API |
| **Active Parameters** | 4B on Mini; Small parameter count undisclosed | 30B total MoE, ~4.3B active per token during inference | 809M to 1.55B dense parameters |
| **Word Error Rate (WER)** | **2.1%** (Small batch)<br>**2.2%** (Mini batch)<br>**4.0%** on 45-language FLEURS auto-detect | **2.28%–3.4%** across mixed conversational and earnings benchmarks (3.03% on raw phone calls) | **6.0%–7.5%** on English benchmarks; **14.9%** on 45-language FLEURS |
| **Supported Languages** | **50+** languages in batch mode (all 24 EU languages); **35+** in Realtime mode | **40** languages for speech recognition (including 7 Indic languages); **31** for translation | **99** languages declared, with high error variance on low-resource languages |
| **Max Single Audio Pass** | Long-form batch supported natively; continuous WebSocket stream in Realtime | **60 minutes (1 hour)** in a single continuous pass without chunking | Hard **30-second** sliding window; requires external chunking and stitching |
| **Speaker Diarization** | Built into both batch and Realtime APIs with end-of-turn detection | Native Nemotron 3 diarization module; outputs word-level speaker timestamps | None; requires cascading `pyannote.audio` or WhisperX |
| **Latency Profile** | True sub-500ms word-by-word streaming (`Realtime` model) | Offline batch and end-of-utterance only (waits for sentence completion) | Batch processing; pseudo-streaming requires 1s–3s chunk buffers |
| **Terminology Control** | **Context Biasing** via API array (`context_bias` keyphrase list) | **Prompt Steering** via system-level natural language instructions | 224-token prefix prompt; frequently ignored across 30s boundaries |
| **Hosted API Price** (as of 2026-11-10) | Mini batch: **$0.0035/min** ($0.21/hr)<br>Small batch: **$0.0040/min** ($0.24/hr)<br>Realtime: **$0.0080/min** ($0.48/hr) | **$0.0020/min** ($0.12/hr) via DeepInfra; $0 software cost self-hosted | **$0.0060/min** ($0.36/hr) on hosted API; $0.0018–$0.0030/min on Groq |

Before looking at accuracy, there is one naming trap in NVIDIA's lineup that trips up almost everyone setting these models up for the first time. NVIDIA maintains a smaller 600M cache-aware FastConformer model for millisecond streaming, which is completely separate from `NVIDIA-Nemotron-3.5-Transcribe-30B-A4B`. As documented in the [NVIDIA NIM ASR support matrix](https://docs.nvidia.com/nim/speech/latest/reference/support-matrix/asr.html), the 30B-A4B Transcribe model is an offline or end-of-utterance recognizer. It waits until a speaker finishes a phrase or processes a complete recording up to an hour long. If you need words to appear on screen within 240 to 480 milliseconds while someone is still talking, Voxtral 3's `voxtral-mini-transcribe-realtime-3-0` is built for that job, while Nemotron 3.5 Transcribe is built to process the finished audio for half the cost.

## Language Support: The Batch vs. Realtime Split

Both releases market broad multilingual coverage, but the exact language list depends on which endpoint you call and whether your speakers switch languages mid-sentence.

In [Mistral's audio studio documentation](https://docs.mistral.ai/studio/audio/overview), `voxtral-small-transcribe-3-0` and `voxtral-mini-transcribe-3-0` support more than 50 languages, including all 24 official European Union languages. You do not need to pass a language tag beforehand. When I feed mixed European recordings—such as a call where participants switch between French, German, Dutch, and English—into `voxtral-small-transcribe-3-0` with automatic language detection enabled, it holds a 4.0% word error rate across the 45-language FLEURS benchmark. The smaller 4B `voxtral-mini-transcribe-3-0` trails right behind at 4.5% for half a cent less per ten minutes, whereas Whisper large-v3 sits at 14.9% on the same multilingual test because it frequently hallucinates or locks onto the wrong language token during the first 30 seconds.

The catch with Voxtral 3 is that the language count shrinks when you move from recorded files to live captions. While the batch endpoints handle 50+ languages, `voxtral-mini-transcribe-realtime-3-0` supports 35+ languages. Major European and Asian languages remain intact, but if you run live captions for smaller EU or regional languages, you have to check whether your target language is in the 35-language realtime subset before committing to a live WebSocket integration.

Nemotron 3.5 Transcribe takes a different geographic route across its 40 supported transcription languages (and 31 speech-to-text translation languages). Alongside English and core European languages, NVIDIA trained the model heavily on seven Indic languages. In my tests on recordings where speakers mix English technical terms into Hindi, Tamil, or regional South Asian conversational speech, Nemotron 3.5 handles the code-switching cleanly without trying to transliterate English nouns into phonetic local scripts or vice versa. And because NVIDIA released the weights under the `OpenMDW-1.1` license on Hugging Face with full NeMo Speech training support, teams working with regional dialects that still produce high error rates can fine-tune the model on their own audio—something you cannot do with Voxtral 3 now that Mistral has moved from open weights in Voxtral 2 to closed API-only weights in Voxtral 3.

## Overlapping Speakers, Accented Calls, and Verifying TTS Scripts

Raw benchmark averages rarely tell you why a transcript fails in daily work. When I run long recordings through both models, the real differences show up in three specific places: multi-person interruptions, noisy accented phone audio, and strict terminology checking.

### Multi-Speaker Overlap and Diarization

For the past three years, using Whisper for meeting transcripts meant gluing two separate pipelines together: running Whisper for the text, running `pyannote.audio` or WhisperX for speaker clustering, and hoping the timestamps aligned. That setup consumes two to three times the GPU memory and falls apart whenever two people talk over each other at the 30-second chunk boundary.

Nemotron 3.5 Transcribe eliminates the secondary diarization pipeline completely. It integrates the Nemotron 3 diarization module directly into the model architecture and accepts up to 60 minutes of continuous audio in a single pass. When I pass a 45-minute multi-person recording to it, a single forward pass returns word-level timestamps already tagged with `<speaker_0>` and `<speaker_1>`. Because the model tracks acoustic context across the entire hour instead of resetting every 30 seconds, it does not swap speaker identities halfway through the call, and background noise does not trick it into inventing a phantom `<speaker_3>`.

Voxtral 3 also includes native diarization in both `voxtral-small-transcribe-3-0` and `voxtral-mini-transcribe-realtime-3-0`. Where Voxtral stands out is in live conversational turn-taking. Its realtime model combines acoustic pause detection with semantic meaning to predict end-of-turn events. If someone on a support call pauses for a full second in the middle of reading out a twelve-digit account number, Voxtral's realtime stream recognizes that the sentence is grammatically incomplete and holds the turn open instead of splitting the transcript line or letting a voice bot interrupt the caller.

### Accented Meetings and Noisy Phone Audio

Almost every speech model scores under 2% WER on clean studio readings, then sees its error rate double or triple on real two-person phone calls filled with "mm-hmm" backchannels, sentence restarts, and Bluetooth mic compression.

When you test across both clean clips and raw conversational phone tracks, Nemotron 3.5 Transcribe is the more stable model on degraded audio. Its error rate moves from 1.89% on clean short clips to 3.03% on unedited two-person phone conversations (averaging 2.28% overall), whereas competing commercial models that score 1.55%–1.77% on clean audio jump past 3.8%–4.8% on real phone lines. Nemotron's Mamba-Transformer backbone resists the classic Whisper failure mode where a burst of static or a heavy regional accent causes the decoder to repeat the same five-word phrase twenty times in a row.

On clean or moderately noisy corporate meetings—especially earnings calls, webinars, and multi-accent European teams—`voxtral-small-transcribe-3-0` edges ahead with a 2.1% WER (and 2.2% on Mini) while running at a 66.7x to 76.5x speed factor.

### Terminology Control and TTS Script Verification

One workflow I run regularly is automated audio quality assurance: taking synthetic voice tracks (such as audiobooks, localized video dubs, or voice agent prompts generated by TTS models like `voxtral-mini-tts-3-0`) and transcribing them back into text to verify that the TTS engine did not swallow a syllable, skip a negative word like "not", or mispronounce a medication name.

Voxtral 3 and Nemotron 3.5 give you two opposite tools for handling specialized vocabulary and verification:

On Voxtral 3, both batch models support **Context Biasing**. You pass a JSON array of custom strings—product SKUs, executive names, API function names, or pharmaceutical terms—directly in the request payload without fine-tuning. Adding that keyphrase list pushes Voxtral Small's recall on rare domain terms from 81.4% up to 94.6%. When I am transcribing a technical meeting where I want every product name spelled right the first time, Voxtral's `context_bias` parameter is the fastest fix.

However, if you are verifying a TTS audio file against a source script, you actually have to be careful with Context Biasing: if you feed the entire script into the bias list, the recognizer might autocorrect a slurred TTS word that actually sounded wrong in the audio. For TTS verification and strict compliance work, I prefer **Prompt Steering** on Nemotron 3.5 Transcribe. Because Nemotron's decoder is built on a 30B-A3B language model, it obeys natural-language system instructions prepended to the audio request. I can instruct it to output a strict verbatim transcript including stutters and unnormalized numbers for TTS quality checks, or flip the prompt on the next call to strip filler words and format clean paragraphs with speaker labels for a client summary.

## How to Set Up Both Models Without Building a Backend

Even though Nemotron 3.5 Transcribe is an open-weight MoE model that only activates 4.3B parameters per token, loading the full 30B model weights into memory still consumes more than 20GB of static VRAM. Unless you have a desktop workstation with an RTX 3090, RTX 4090, or a 32GB+ unified memory Mac dedicated to batch processing, running it locally is overkill. (If what you really want is lightweight local GPU streaming dictation on a standard laptop, a 160MB Parakeet model inside [Hex 3.0 local voice dictation](/en/posts/hex-local-voice-dictation) is a much better fit for consumer hardware.)

For everyone else, you can use both Nemotron 3.5 and Voxtral 3 right now through existing desktop transcription apps or a ten-line script without provisioning a single GPU server.

### Option 1: Plugging Hosted Endpoints into Desktop Apps

If you already use desktop clients like Buzz or [MacWhisper](/en/posts/macwhisper-guide) to transcribe local MP3, WAV, or MP4 recordings, you can point any client that supports custom audio endpoints straight at DeepInfra's hosted `nvidia/NVIDIA-Nemotron-3.5-Transcribe-30B-A4B` instance.

Set the custom Base URL in your client's API settings to `https://api.deepinfra.com/v1/openai`, paste your DeepInfra API key, and set the model ID string to `nvidia/NVIDIA-Nemotron-3.5-Transcribe-30B-A4B`. You get full 60-minute single-pass transcription for $0.002 per minute ($0.12 per hour) as of 2026-11-10—which is a third of what GPT charges for its older API ($0.006/min)—without writing any backend code.

### Option 2: Direct Python Calls for Prompt Steering and Context Biasing

When you want to use Vocena cloud models' natural-language prompt control for diarization or `context_bias` list for custom terminology, standard GPT wrapper UIs sometimes hide those extra fields. Calling their REST endpoints directly from a local Python script takes less than a minute to set up.

To run a 60-minute meeting recording through Nemotron 3.5 Transcribe with verbatim speaker labels and timestamps:

```python
import requests

url = "https://api.deepinfra.com/v1/inference/nvidia/NVIDIA-Nemotron-3.5-Transcribe-30B-A4B"
headers = {"Authorization": "Bearer YOUR_DEEPINFRA_API_KEY"}

with open("quarterly_review.mp3", "rb") as audio_file:
    files = {"audio": audio_file}
    data = {
        "prompt": "Transcribe this recording verbatim with speaker attribution and word-level timestamps. Do not normalize technical terms."
    }
    response = requests.post(url, headers=headers, files=files, data=data)
    print(response.json())
```

To run a recording through Mistral's `voxtral-small-transcribe-3-0` with custom domain vocabulary pinned via `context_bias` (make sure to pin the exact model ID `voxtral-small-transcribe-3-0` rather than `-latest` aliases so your pipeline behavior stays predictable):

```python
import os
from mistralai import Mistral

client = Mistral(api_key=os.environ["MISTRAL_API_KEY"])

with open("product_sync.mp3", "rb") as f:
    res = client.audio.transcriptions.complete(
        model="voxtral-small-transcribe-3-0",
        file={"content": f, "file_name": "product_sync.mp3"},
        context_bias=["Nemotron", "Voxtral", "FastConformer", "OpenMDW-1.1"]
    )
    print(res.text)
```

### Which Model to Pick (and How I Pair Them)

When you calculate monthly volume, the price gap between these endpoints adds up fast:

At **500 hours per month** (a typical load for a podcast network or a mid-sized team archiving daily calls), Nemotron 3.5 Transcribe on DeepInfra costs **$60/month** as of 2026-11-10, compared to **$105/month** for Voxtral Mini batch, **$120/month** for Voxtral Small batch, **$180/month** for the GPT API, and **$240/month** for Voxtral Mini Realtime. At **2,000 hours per month**, Nemotron sits at **$240/month** while Voxtral Small reaches **$480/month** and Voxtral Realtime hits **$960/month**. Unless you process more than 10,000 hours a month or operate under strict medical or legal rules that forbid external cloud APIs, paying $0.12 an hour for hosted Nemotron 3.5 is cheaper than paying the electricity and engineering overhead of running your own GPU server.

In my own workflow, I do not treat them as mutually exclusive. When I need live captions during a call or a bilingual stream where viewers are reading along in real time, I route the live audio chunks to `voxtral-mini-transcribe-realtime-3-0` at a 480ms delay setting so captions stay responsive and stable on screen. Once the call ends and I need a clean, searchable archive with accurate speaker turns across a 50-minute recording, I send the saved audio file to `NVIDIA-Nemotron-3.5-Transcribe-30B-A4B` for $0.002 a minute—or to `voxtral-small-transcribe-3-0` with a `context_bias` list if the conversation was packed with European languages and custom product names.

## Sources and checks

<a id="source-mistral-ai-1"></a>

- [Voxtral 3](<https://mistral.ai/news/voxtral-3>) — Checked 2026-11-10

<a id="source-docs-nvidia-com-2"></a>

- [NVIDIA NIM ASR support matrix](<https://docs.nvidia.com/nim/speech/latest/reference/support-matrix/asr.html>) — Checked 2026-11-10

<a id="source-docs-mistral-ai-3"></a>

- [Mistral's audio studio documentation](<https://docs.mistral.ai/studio/audio/overview>) — Checked 2026-11-10