NVIDIA-Nemotron-3.5-Transcribe-30B-A4B

NVIDIA Nemotron 3.5 Transcribe

Open-weight transcription of recorded speech in 40 languages, with word-level timestamps and a prompt that steers vocabulary and formatting.

Released 28 October 2026 — model card · technical report

A Language Model That Listens

Most speech recognisers map sound to text directly. This one reads the audio with a speech encoder and writes the transcript with a language model.

NVIDIA call the design a Speech-Augmented Language Model. The practical consequence is that the transcript is shaped by language knowledge as well as by sound — which is where its accuracy on long, messy, real-world recordings comes from, and why a short text prompt can guide how names and numbers are written.

What It Is Built From

The timestamp head is part of the model. Word timings come from a dedicated alignment head trained alongside the language model, not from a separate aligner run afterwards.

Only about an eighth of the parameters work on each token. The mixture-of-experts backbone routes each token to a few experts, which is how a 34-billion-parameter model transcribes at the cost of a much smaller one.

Recorded Audio Only

This is an offline model. It reads a complete recording and returns its transcript.

It is not a live-streaming recogniser. The encoder processes audio in 30-second chunks internally — an implementation detail, not a latency property and not a 30-second limit.

For live captions or voice agents, a streaming recogniser is the right tool; this model is for audio that already exists.

Limits

Training covered recordings up to one hour. Split anything longer before sending it — behaviour beyond that length is not guaranteed.

Audio and transcript share the context. An hour of audio uses about 45,000 tokens at 80 ms per token, leaving room for the transcript of a dense conversation.

Languages — Three Quality Levels

NVIDIA grade the 40 languages rather than presenting them as equal.

Leading — state of the art or close to it, out of the box: Czech, Dutch, English, French, German, Hindi, Italian, Korean, Polish, Portuguese, Russian, Slovak, Spanish.

Production-ready: Bulgarian, Croatian, Danish, Estonian, Finnish, Hungarian, Japanese, Latvian, Lithuanian, Romanian, Slovenian, Swedish, Thai, Turkish, Ukrainian.

Supported — may need fine-tuning: Arabic, Bengali, Chinese Mandarin, Greek, Hebrew, Indonesian, Maltese, Marathi, Norwegian, Tagalog, Tamil, Telugu, Vietnamese.

French is in the leading group — 3.16% word error rate on FLEURS.

Arabic is in the supported group — 6.35% on FLEURS. Test it on your own recordings before relying on it.

Code-switching is covered across all 40 — speech that moves between languages mid-sentence is transcribed in the languages actually spoken.

Benchmarks

Published by NVIDIA, captured 12 October 2026, unless stated otherwise. Lower is better for every error rate.

Transcription

Independently, Artificial Analysis place it joint first among open-weight models at 2.8% on their AA-WER index — with about 4B active parameters against 24B for the model it ties. On AA-AgentTalk, their held-out voice-agent speech set, it scores 1.8% against 2.3% for the next open-weight model.

Selected English sets

The spread is the useful part. Clean read speech is close to solved; meetings and degraded recordings are where errors concentrate, and where testing on your own audio matters most.

Vocabulary hints

Supplying the terms a recording contains nearly doubles how many of them come out right. On earnings calls, recall of company and product names rose from 58% to 96% — the single largest gain available without training.

Specifications

Capabilities

Using Nemotron 3.5 Transcribe on DEVUP AI

Base URL: https://api.devupai.com/v1 · Model ID: nvidia/NVIDIA-Nemotron-3.5-Transcribe-30B-A4B

Python

import os
from openai import OpenAI

client = OpenAI(
    api_key=os.environ["DEVUP_API_KEY"],
    base_url="https://api.devupai.com/v1",
)

with open("meeting.wav", "rb") as audio:
    transcript = client.audio.transcriptions.create(
        model="nvidia/NVIDIA-Nemotron-3.5-Transcribe-30B-A4B",
        file=audio,
    )

print(transcript.text)

Node.js

import { readFile } from "node:fs/promises";

const form = new FormData();
form.append("model", "nvidia/NVIDIA-Nemotron-3.5-Transcribe-30B-A4B");
form.append("file", new Blob([await readFile("meeting.wav")]), "meeting.wav");

const response = await fetch("https://api.devupai.com/v1/audio/transcriptions", {
  method: "POST",
  headers: { Authorization: `Bearer ${process.env.DEVUP_API_KEY}` },
  body: form,
});

if (!response.ok) {
  throw new Error(`HTTP ${response.status}: ${await response.text()}`);
}

const { text } = await response.json();
console.log(text);

cURL

curl -X POST "https://api.devupai.com/v1/audio/transcriptions" \
  -H "Authorization: Bearer $DEVUP_API_KEY" \
  -F "model=nvidia/NVIDIA-Nemotron-3.5-Transcribe-30B-A4B" \
  -F "file=@meeting.wav"

Word Timestamps

Ask for verbose_json with word granularity, and every word comes back with its start and end time.

Python

with open("lecture.wav", "rb") as audio:
    transcript = client.audio.transcriptions.create(
        model="nvidia/NVIDIA-Nemotron-3.5-Transcribe-30B-A4B",
        file=audio,
        response_format="verbose_json",
        timestamp_granularities=["word"],
    )

print(f"duration: {transcript.duration:.2f}s")

for word in transcript.words:
    print(f"{word.start:7.2f} → {word.end:7.2f}  {word.word}")

cURL

curl -X POST "https://api.devupai.com/v1/audio/transcriptions" \
  -H "Authorization: Bearer $DEVUP_API_KEY" \
  -F "model=nvidia/NVIDIA-Nemotron-3.5-Transcribe-30B-A4B" \
  -F "file=@lecture.wav" \
  -F "response_format=verbose_json" \
  -F "timestamp_granularities[]=word"

Response shape

{
  "task": "transcribe",
  "duration": 9.57,
  "text": "Hello, this is a transcription test.",
  "words": [
    { "word": "Hello,", "start": 0.07, "end": 0.58 },
    { "word": "this", "start": 0.80, "end": 1.04 }
  ]
}

Times are in seconds from the start of the recording. Punctuation stays attached to the word it follows, so "Hello," is one entry.

Subtitles From Word Timestamps

The use case word timings exist for.

def _srt_time(seconds: float) -> str:
    total_ms = int(round(seconds * 1000))
    hours, rest = divmod(total_ms, 3_600_000)
    minutes, rest = divmod(rest, 60_000)
    secs, ms = divmod(rest, 1000)
    return f"{hours:02}:{minutes:02}:{secs:02},{ms:03}"


def to_srt(words, *, max_seconds: float = 6.0, max_chars: int = 42) -> str:
    """Group timed words into subtitle cues bounded by duration and line length."""
    cues, current = [], []

    for word in words:
        candidate = " ".join(w.word for w in current + [word])
        too_long = current and (word.end - current[0].start > max_seconds or len(candidate) > max_chars)
        if too_long:
            cues.append(current)
            current = []
        current.append(word)

    if current:
        cues.append(current)

    blocks = []
    for index, cue in enumerate(cues, start=1):
        text = " ".join(w.word for w in cue)
        blocks.append(f"{index}\n{_srt_time(cue[0].start)} --> {_srt_time(cue[-1].end)}\n{text}\n")

    return "\n".join(blocks)


with open("lecture.srt", "w", encoding="utf-8") as handle:
    handle.write(to_srt(transcript.words))

Six seconds and 42 characters per cue keep subtitles readable on screen. Adjust both for your player.

Guiding the Transcript With a Prompt

The prompt field steers vocabulary and formatting. The output is always a transcript in the language spoken.

Vocabulary

with open("product_call.wav", "rb") as audio:
    transcript = client.audio.transcriptions.create(
        model="nvidia/NVIDIA-Nemotron-3.5-Transcribe-30B-A4B",
        file=audio,
        prompt=(
            "Transcribe with punctuation and capitalization. "
            "Context terms: DEVUP AI, Model Studio, Nemotron, Oran, Tizi Ouzou."
        ),
    )

List the names, products, and places the recording contains. On earnings calls, keyword recall rose from 58% to 96% with context terms supplied — the largest gain available without training.

Formatting

with open("order_call.wav", "rb") as audio:
    transcript = client.audio.transcriptions.create(
        model="nvidia/NVIDIA-Nemotron-3.5-Transcribe-30B-A4B",
        file=audio,
        prompt="Transcribe with punctuation and capitalization. Write numbers as digits.",
    )

Without guidance, a spoken sequence comes back as words — "four, seven, two, nine". With it, the same audio returns 4729.

Treat the prompt as guidance, not a guarantee. Check formatting on your own recordings — a phrase like "ten thirty" may stay in words while a digit sequence converts.

cURL

curl -X POST "https://api.devupai.com/v1/audio/transcriptions" \
  -H "Authorization: Bearer $DEVUP_API_KEY" \
  -F "model=nvidia/NVIDIA-Nemotron-3.5-Transcribe-30B-A4B" \
  -F "file=@product_call.wav" \
  -F "prompt=Transcribe with punctuation and capitalization. Context terms: DEVUP AI, Model Studio."

A Guard Against Repetition Loops

In rare cases, generation fails to stop and repeats. NVIDIA apply this function to every reported transcription result:

import re

CHAR_RUN = re.compile(r"(.)\1{20,}", re.DOTALL)
BLOCK_RUN = re.compile(r"(.{1,4096}?)\1{19,}", re.DOTALL)


def cleanup_generation_loops(text: str) -> str:
    """Collapse runaway repetition in a decoded transcript."""
    text = CHAR_RUN.sub(lambda m: m.group(1), text)
    return BLOCK_RUN.sub(lambda m: m.group(1), text)


clean = cleanup_generation_loops(transcript.text)

Where It Fits

Meeting, interview, and lecture transcription — up to an hour per recording.

Subtitles and captions for recorded video, built from word timestamps.

Searchable audio archives, where each word links back to its moment in the recording.

Call and support recordings, with product names supplied as context terms.

Financial, medical, and technical audio, where vocabulary hints matter most.

Multilingual and code-switched recordings across 40 languages.

Not for live captions or voice agents. It reads complete recordings.

Not for recordings over an hour. Split them first.

Practical Notes

Send 16 kHz single-channel audio when you control the recording.

Supply context terms for any recording with names, products, or jargon.

State formatting in the prompt — digits, punctuation — and check the result on your own audio.

Use verbose_json with word granularity for subtitles, search, or editing tools.

Split recordings longer than an hour.

Apply the repetition guard to transcripts.

Test Arabic on your own audio; it is in the supported tier, not the leading one.

Spot-check names and numbers against the recording.

Limitations

Recorded audio only. Not a live-streaming recogniser.

Up to one hour per recording, within 65,536 tokens of context.

The prompt guides; it does not change the task. The output is always a transcript in the language spoken.

Language quality varies. Thirteen languages lead, fifteen are production-ready, and thirteen — Arabic among them — may need fine-tuning.

Rare repetition loops — apply the guard above.

Benchmark figures are NVIDIA's own unless marked as independent.