Parakeet

Trigger phrases: "transcribe with parakeet", "nemo transcribe", "nvidia speech to text", "parakeet transcribe", "transcribe this audio", "convert speech to text", "what did they say", "make a transcript", "audio to text", "subtitle this video", "transcribe in [language]", "European language transcription", "best accuracy transcription", "high accuracy speech to text", "transcribe long audio", "transcribe lecture", "transcribe meeting", "word timestamps"

🦜 Parakeet vs 🗣️ faster-whisper — When to Use Which

Rule of thumb:

• Parakeet when you want: best accuracy, fastest speed, auto-punctuation, European languages
• faster-whisper when you need: diarization, 99+ languages, translation, chapters/search, more output formats, audio preprocessing

⚠️ Agent guidance — keep invocations minimal:

CORE RULE: default command (./scripts/transcribe audio.wav) is the fastest path — add flags only when the user explicitly asks for that capability.

Transcription:

• Only add --timestamps if the user asks for word-level or segment-level timestamps (auto-enabled for srt, vtt, json formats)
• Only add --format srt/vtt if the user asks for subtitles/captions in that format
• Only add --format json if the user wants structured/programmatic output
• Only add --long-form if the audio is longer than 24 minutes
• Only add --streaming if the user wants live/progressive output for long files
• Only add -l/--language CODE if the user specifies a language (auto-detection is usually fine)
• Only add --model if the user wants a specific model variant (v2, 1.1b)
• Only add --device cpu if GPU is not available or user requests CPU
• Only add --batch-size N if the user reports OOM errors
• Only add --max-words-per-line or --max-chars-per-line for subtitle readability on long segments

Batch processing:

• Only add --skip-existing when resuming interrupted batch jobs
• For batch output, always use -o <dir> (directory, not file)
• ETA is shown automatically for batch jobs (no flag needed)

Output format for agent relay:

• Text (default) → safe to show directly to user for short files; summarise for long ones
• JSON → useful for programmatic post-processing; not ideal to paste in full to user
• SRT/VTT → always write to -o file; tell the user the output path, never paste raw subtitle content

When NOT to use:

• Need speaker diarization → use faster-whisper with --diarize
• Non-European languages (Asian, African, etc.) → use faster-whisper
• Need translation to English → use faster-whisper with --translate
• Cloud-only environments without local compute

Quick Reference

Model Selection

Available Models

Supported Languages (v3)

Bulgarian (bg), Croatian (hr), Czech (cs), Danish (da), Dutch (nl), English (en), Estonian (et), Finnish (fi), French (fr), German (de), Greek (el), Hungarian (hu), Italian (it), Latvian (lv), Lithuanian (lt), Maltese (mt), Polish (pl), Portuguese (pt), Romanian (ro), Slovak (sk), Slovenian (sl), Spanish (es), Swedish (sv), Russian (ru), Ukrainian (uk)

Language is auto-detected — no prompting or configuration needed. The model identifies the language from the audio content automatically.

Accuracy Benchmarks (v3)

Setup

Linux / WSL2

# Full install (creates venv, installs NeMo + CUDA PyTorch)
./setup.sh

# Verify installation
./setup.sh --check

# Upgrade NeMo toolkit
./setup.sh --update

Requirements:

• Python 3.10+
• NVIDIA GPU with CUDA (strongly recommended; CPU works but is much slower)
• ffmpeg (recommended for mp3/m4a/mp4 format conversion; not needed for .wav/.flac)
• Optional: yt-dlp (for URL/YouTube input)

Platform Support

VRAM: The 600M model only needs ~2GB VRAM to load. An RTX 3070 (8GB) has plenty of headroom.

GPU Support

The setup script auto-detects your GPU and installs PyTorch with CUDA. Always use GPU if available.

If setup didn't detect your GPU, manually install PyTorch with CUDA:

# For CUDA 12.x
uv pip install --python ./venv/bin/python torch torchaudio --index-url https://download.pytorch.org/whl/cu121

• WSL2 users: Ensure you have the NVIDIA CUDA drivers for WSL installed on Windows

Usage

# Basic transcription (auto-punctuated, auto-capitalized)
./scripts/transcribe audio.wav

# Transcribe an MP3 (auto-converts to WAV via ffmpeg)
./scripts/transcribe recording.mp3

# SRT subtitles
./scripts/transcribe audio.wav --format srt -o subtitles.srt

# WebVTT subtitles
./scripts/transcribe audio.wav --format vtt -o subtitles.vtt

# Full JSON with word/segment/char timestamps
./scripts/transcribe audio.wav --timestamps --format json -o result.json

# Transcribe from YouTube URL
./scripts/transcribe https://youtube.com/watch?v=dQw4w9WgXcQ

# Long lecture (>24 min, up to 3 hours)
./scripts/transcribe lecture.wav --long-form

# Streaming mode (print segments as they're transcribed)
./scripts/transcribe audio.wav --streaming

# Batch process a directory
./scripts/transcribe ./recordings/ -o ./transcripts/

# Batch with glob, skip already-done files
./scripts/transcribe *.wav --skip-existing -o ./transcripts/

# Use English-only v2 model
./scripts/transcribe audio.wav --model nvidia/parakeet-tdt-0.6b-v2

# JSON output with metadata
./scripts/transcribe audio.wav --format json -o result.json

# Specify expected language (validation only; v3 auto-detects)
./scripts/transcribe audio.wav --language fr

Options

Input:
  AUDIO                 Audio file(s), directory, glob pattern, or URL
                        Native: .wav, .flac (16kHz mono preferred)
                        Converts via ffmpeg: .mp3, .m4a, .mp4, .mkv, .ogg, .webm, .aac, .wma, .avi, .opus
                        URLs auto-download via yt-dlp (YouTube, direct links, etc.)

Model & Language:
  -m, --model NAME      NeMo ASR model (default: nvidia/parakeet-tdt-0.6b-v3)
                        Also: nvidia/parakeet-tdt-0.6b-v2 (English), nvidia/parakeet-tdt-1.1b (larger)
  -l, --language CODE   Expected language code, e.g. en, es, fr (v3 auto-detects if omitted)
                        Used for validation; does not force the model

Output Format:
  -f, --format FMT      text | json | srt | vtt (default: text)
  --timestamps          Enable word/segment/char timestamps (auto-enabled for srt, vtt, json)
  --max-words-per-line N  For SRT/VTT, split segments into sub-cues of at most N words
  --max-chars-per-line N  For SRT/VTT, split lines so each fits within N characters
                        Takes priority over --max-words-per-line when both are set
  -o, --output PATH     Output file or directory (directory for batch mode)

Long-Form & Streaming:
  --long-form           Enable local attention for audio >24 min (up to ~3 hours)
                        Changes attention model to rel_pos_local_attn with [256,256] context
  --streaming           Print segments as they are transcribed (chunked inference)

Inference:
  --batch-size N        Inference batch size (default: 32; reduce if OOM)

Batch Processing:
  --skip-existing       Skip files whose output already exists (batch mode)

Device:
  --device DEV          auto | cpu | cuda (default: auto)
  -q, --quiet           Suppress progress and status messages

Utility:
  --version             Print version info and exit

Output Formats

Text (default)

Clean, automatically punctuated and capitalized transcript:

Hello, welcome to the meeting. Today we'll discuss the quarterly results
and our plans for next quarter.

JSON (--format json)

Full metadata including segments, word/char timestamps, and performance stats:

{
  "file": "audio.wav",
  "text": "Hello, welcome to the meeting.",
  "duration": 600.5,
  "segments": [
    {
      "start": 0.0,
      "end": 2.5,
      "text": "Hello, welcome to the meeting.",
      "words": [
        {"word": "Hello,", "start": 0.0, "end": 0.4},
        {"word": "welcome", "start": 0.5, "end": 0.9},
        {"word": "to", "start": 0.95, "end": 1.1},
        {"word": "the", "start": 1.15, "end": 1.3},
        {"word": "meeting.", "start": 1.35, "end": 2.0}
      ]
    }
  ],
  "words": [...],
  "chars": [...],
  "stats": {
    "processing_time": 0.18,
    "realtime_factor": 3380.0
  }
}

SRT (--format srt)

Standard subtitle format for video players:

1