Audio
silero
speech detection

Voice Activity Detection

Detecting speech vs silence in audio streams. Silero VAD is the open-weight default — small, fast, accurate.

Capability notes

Voice Activity Detection (VAD) identifies whether each short audio frame contains human speech — it outputs a binary speech/silence decision at 10-30ms granularity. It's the simplest AI audio task and a critical pre-processing step for [speech-to-text](/tasks/speech-to-text), [diarization](/tasks/diarization), [dubbing](/tasks/dubbing), and any pipeline that should only process speech segments. Two systems dominate local deployment: **Silero VAD** (open-weight, 2021-2025) and **WebRTC VAD** (Google, C implementation, battle-tested in billions of browser calls). Silero VAD is the accuracy leader among open-weight VADs. Architecture: a small LSTM/CNN hybrid (~1 MB) that outputs frame-level speech probability (0-1) at 30ms granularity from 16kHz audio. On standard benchmarks (Common Voice + noise mixtures): speech detection accuracy 95-98% at SNR >10dB, dropping to 70-85% at SNR 0dB (speech and noise equally loud). Key advantage over WebRTC VAD: outputs continuous probability scores (not just binary), enabling threshold tuning per deployment. Silero VAD processes at 100-500× real-time on CPU — 1 hour of audio in 7-36 seconds. WebRTC VAD is the industrial standard embedded in Chrome, Firefox, Edge, Zoom, Teams, and every WebRTC-based application. It outputs a binary decision (0-3 activity levels) at 10/20/30ms frames from 8/16/32/48kHz audio. Accuracy at SNR >10dB: 90-95% — trails Silero by 3-5 percentage points. Advantage: battle-tested across billions of hours, sub-0.1ms per frame latency (10,000× real-time), implemented in C with zero dependencies, and runs on any CPU since 2010. The accuracy gap vs Silero is repaid in deployment reliability — WebRTC VAD has been tested in more adverse network/acoustic conditions than any ML model. For recommended models, see [Llama 3.3 70B](/models/llama-3-3-70b). Deploy locally with [Ollama](/tools/ollama) on [RTX 4090](/hardware/rtx-4090).

If you just want to try this

Lowest-friction path to a working setup.

Install Silero VAD via pip: `pip install silero-vad`. It's a single Python file with the model weights embedded — no PyTorch, no model download, no configuration. Basic usage: ```python from silero_vad import load_silero_vad, read_audio, get_speech_timestamps model = load_silero_vad() wav = read_audio("recording.wav") speech_timestamps = get_speech_timestamps(wav, model, return_seconds=True) for segment in speech_timestamps: print(f"Speech: {segment['start']:.2f}s - {segment['end']:.2f}s") ``` This prints start/end times for each speech segment. No GPU needed — runs on any CPU at 100-300× real-time (a 30-minute recording processes in 6-18 seconds). A 10-year-old laptop processes faster than real-time. For your first test: record 2 minutes of yourself talking with 5-second pauses between sentences, plus some keyboard typing and chair squeaking in the background. Run Silero VAD — it should segment your speech into chunks with the pauses trimmed. If it misses quiet speech (your voice trailing off at end of sentences): lower the speech threshold from the default 0.5 to 0.3 — more sensitive but slightly more false positives on background noise. If you need C/C++ integration (embedding in a native app, game engine, audio driver): use WebRTC VAD via its C library. Install: `git clone https://github.com/wiseman/py-webrtcvad && pip install webrtcvad`. The Python wrapper has the same interface: `vad.is_speech(audio_frame, sample_rate)` → True/False. Simpler API than Silero VAD but binary output only (no probability scores). For recommended models, see [Llama 3.3 70B](/models/llama-3-3-70b). Deploy locally with [Ollama](/tools/ollama) on [RTX 4090](/hardware/rtx-4090).

For production deployment

Operator-grade recommendation.

Production VAD is a pipeline component, not a standalone service — its deployment depends on the downstream system's latency and accuracy requirements. The architecture differs for streaming (real-time) vs batch (offline) use cases. **Streaming VAD** (real-time, web calls, live transcription): WebRTC VAD → Silero VAD cascade. WebRTC VAD runs at ~0.01ms/frame continuously — when it detects speech (activity level ≥1), the audio frame is buffered. When speech ends (3+ consecutive frames of silence), the buffered audio is fed to Silero VAD for confirmation: if Silero probability >0.5, emit speech segment; if <0.5, discard as false alarm. This cascaded architecture gives WebRTC's speed with Silero's accuracy — Silero only runs on ~50% of frames (only the WebRTC-positive segments), keeping total compute at ~5-10× over WebRTC alone while recovering most of Silero's accuracy advantage. **Batch VAD** (offline, meeting transcription, podcast processing): Silero VAD with post-processing. Run Silero on full audio → output speech probability time series → apply hysteresis: speech starts when probability >0.6 for ≥3 consecutive frames (90ms), speech ends when probability <0.3 for ≥10 consecutive frames (300ms). The asymmetric thresholds (higher for start, lower for end) prevent cutting off the beginning of utterances while avoiding false starts from short noise bursts. Then merge segments within 0.5s of each other (speaker pauses for thought) into a single speech segment. This post-processing pipeline is the difference between raw VAD output and production-ready speech segments. **Key VAD tuning parameters**: (1) Speech probability threshold: 0.5 is default Silero; 0.3-0.4 for sensitive (podcast with soft-spoken guests), 0.6-0.7 for conservative (call center with constant background noise). (2) Minimum speech duration: 0.25-0.5s — utterances shorter than this are likely false positives (cough, chair squeak). (3) Minimum silence duration: 0.2-0.5s — silences shorter than this are kept within a speech segment (natural pauses); longer silences trigger a new segment. (4) Padding: add 0.1-0.3s before and after each speech segment (speech onset/offset is gradual; VAD boundaries are slightly late/early). These four parameters account for 90% of VAD tuning effort. For recommended models, see [Llama 3.3 70B](/models/llama-3-3-70b). Deploy locally with [Ollama](/tools/ollama) on [RTX 4090](/hardware/rtx-4090).

What breaks

Failure modes operators see in the wild.

**False negatives on soft/quiet speech.** Symptom: trailing-off sentences, soft-spoken words, and low-energy consonants ("f," "th," "h") are cut off — the VAD marks them as silence. Cause: Silero VAD trained primarily on normal-to-loud speech; quiet speech falls below the default 0.5 threshold. Mitigation: lower threshold to 0.3-0.4, or apply dynamic thresholding (measure per-recording noise floor, set threshold at noise_floor + 0.15). Dynamic thresholds adapt to the recording's volume profile. **False positives on non-speech transients.** Symptom: keyboard typing, door slams, plate clattering, and chair squeaks are detected as speech. Cause: these sounds share spectral-temporal patterns with speech (abrupt onset, broad frequency content, short duration). Mitigation: increase minimum speech duration to 0.5-1.0s (most transients are <0.3s), or add a speech/texture classifier downstream — if Whisper transcribes a VAD-positive segment as nothing or gibberish, classify as false alarm and discard. **Continuous noise as speech (HVAC, crowd babble).** Symptom: air conditioning hum, restaurant background murmur, or traffic drone consistently triggers "speech present." Cause: these sounds have speech-like spectral characteristics (broadband, temporally varying). Mitigation: add spectral flatness check — speech has structured harmonics; HVAC noise is spectrally flat. If a segment's spectral flatness >0.7 (flat = noise), classify as non-speech regardless of VAD output. Combine VAD + spectral analysis for robustness. **Chunk-boundary artifacts (streaming).** Symptom: a word spanning the boundary between two audio chunks is split — "hel-" in chunk 1, "-lo" in chunk 2, and VAD marks chunk 2 as speech starting mid-word. Cause: fixed-duration audio chunks don't align to word boundaries. Mitigation: overlap chunks by 200-300ms, run VAD on overlapping chunks, reconcile overlapping VAD decisions with OR logic (if either chunk has speech at boundary, mark as speech). Overlap + OR eliminates chunk-boundary cutoffs.

Hardware guidance

**CPU-only ($0)**: Silero VAD runs on any CPU at 100-500× real-time. A 1-hour recording processes in 7-36 seconds on a modern laptop — no GPU ever needed. WebRTC VAD runs at 10,000× real-time — a 1-hour recording in <0.5 seconds. These are the most hardware-efficient AI models in existence. If VAD is your only workload, any computer from the last 15 years is sufficient. **Deployment profile by hardware**: (1) Desktop/laptop: Silero VAD for accuracy, negligible compute (<0.1% CPU on modern system while processing). (2) Raspberry Pi 4/5: Silero VAD at 5-15× real-time (1 hour in 4-12 minutes), WebRTC VAD at 500-1,000× real-time. Viable for edge/embedded deployment. (3) Smartphone: Silero VAD via ONNX Runtime on iPhone/Android at 10-30× real-time. WebRTC VAD native implementation in OS. (4) Microcontroller (ESP32, ARM Cortex-M): WebRTC VAD only — Silero VAD requires FPU and 100+ KB RAM beyond typical MCU budget. **GPU acceleration**: Not applicable and not beneficial. Silero VAD is ~1 MB with simple LSTM/CNN operations — GPU overhead (memory transfer, kernel launch) exceeds the compute saved. CPU is always the right platform for VAD. Deployment alongside other GPU workloads: VAD runs on CPU while GPU handles [transcription](/tasks/speech-to-text) and [diarization](/tasks/diarization) — concurrent CPU/GPU utilization is the optimal architecture. **Memory**: Silero VAD: ~10 MB RAM (model + buffers). WebRTC VAD: <1 MB RAM. Both models are memory-trivial — they can run alongside any other workload without memory contention. Neither needs VRAM. This is the lightest-weight AI task in the entire [RunLocalAI](/tasks/text-generation) taxonomy. For recommended models, see [Llama 3.3 70B](/models/llama-3-3-70b). Deploy locally with [Ollama](/tools/ollama) on [RTX 4090](/hardware/rtx-4090).

Runtime guidance

**If you need standalone VAD with Python** → `pip install silero-vad` (PyTorch-based) or `pip install silero-vad-onnx` (ONNX Runtime, no PyTorch dependency, faster startup). Both provide the same API: `get_speech_timestamps(audio, model, threshold=0.5, min_speech_duration_ms=250, min_silence_duration_ms=100)`. ONNX version loads in ~50ms vs PyTorch version's ~2s — use ONNX for serverless/lambda deployments. **If VAD is needed inside a [speech-to-text](/tasks/speech-to-text) pipeline** → [faster-whisper](/tools/faster-whisper) with `vad_filter=True`. faster-whisper bundles Silero VAD internally — set `vad_filter=True, vad_parameters=dict(threshold=0.5, min_speech_duration_ms=250)` in the transcribe call. This is the lowest-friction integration: VAD + transcription in one function call. For [whisper.cpp](/tools/whisper-cpp), Silero VAD is a separate pre-processing step before transcription — whisper.cpp doesn't bundle VAD. **If you need VAD for real-time streaming (WebRTC, live audio)** → WebRTC VAD via `webrtcvad` Python package or native C library. WebRTC VAD operates on 10/20/30ms frames with zero buffering: `vad.is_speech(frame, sample_rate)` returns immediately. Integrate into WebSocket audio streams: receive audio frame → WebRTC VAD → if speech, buffer; if silence for >300ms, flush buffer to downstream processor. This is the standard architecture for live transcription, voice assistants, and VoIP voice analytics. **If VAD is needed for embedded/edge deployment** → Silero VAD ONNX (for Raspberry Pi, Jetson Nano, smartphone) or WebRTC VAD C library (for microcontrollers). Silero VAD ONNX: export to ONNX → `onnxruntime.InferenceSession` → run frame-by-frame. On Raspberry Pi 4: ~10× real-time (1s audio in 100ms). WebRTC VAD C: single .c/.h file, compile with `-O3`, runs on bare-metal ARM Cortex-M4 at >100× real-time. For IoT voice detection (wake-on-voice): WebRTC VAD C library, <1ms latency, <10 KB RAM — the only viable VAD for battery-powered microcontrollers.

Setup walkthrough

  1. pip install silero-vad (Silero VAD — the gold-standard open-weight voice activity detection, ~2 MB).
  2. Python script for real-time VAD:
import torch, pyaudio
model, utils = torch.hub.load("snakers4/silero-vad", "silero_vad", trust_repo=True)
(get_speech_timestamps, _, _, _, _) = utils

CHUNK = 512  # 32ms at 16kHz
audio = pyaudio.PyAudio()
stream = audio.open(format=pyaudio.paInt16, channels=1, rate=16000, input=True, frames_per_buffer=CHUNK)
while True:
    chunk = stream.read(CHUNK)
    tensor = torch.frombuffer(chunk, dtype=torch.int16).float() / 32768.0
    speech_prob = model(tensor, 16000).item()
    if speech_prob > 0.5:
        print(f"Speech detected: {speech_prob:.2f}")
  1. First detection in <10 ms — Silero VAD is real-time on CPU, 50× faster than real-time in batch mode.
  2. For file-based VAD: pip install silero-vad + from silero_vad import read_audio, get_speech_timestamps → returns start/end times of all speech segments in an audio file.
  3. Use cases: audio pre-processing before STT (skip silence), real-time voice activity for chatbots, meeting recording segmentation, audio stream monitoring.

The cheap setup

VAD is the lightest AI task on this list. Silero VAD (~2 MB) runs at 500-1000× real-time on any laptop CPU. A 1-hour audio file VAD-processes in ~3-6 seconds. No GPU needed. Even a Raspberry Pi 4 ($35) runs Silero VAD in real-time. Any $200 Chromebook handles production VAD. VAD is so computationally trivial that hardware is never the bottleneck — code integration is the only challenge. If you can run Python, you can run VAD. Total cost to add VAD to any project: $0 hardware, 5 lines of Python.

The serious setup

VAD doesn't need "serious" hardware. The model is 2 MB and runs on CPU at 500-1000× real-time. For production audio pipelines processing 1000+ concurrent streams (call center monitoring, broadcast VAD), any modern server CPU (AMD EPYC, Intel Xeon) handles it trivially. The scaling challenge is I/O and audio streaming infrastructure, not compute. Budget for audio routing (Kafka streams, WebRTC) and storage, not GPU. A $500 refurbished server with 32 cores handles 10,000+ simultaneous VAD streams. VAD is the poster child for "you don't need a GPU for AI."

Common beginner mistake

The mistake: Using VAD with default threshold (0.5) and wondering why half the speech is cut off or why background noise triggers false positives. Why it fails: VAD thresholds are environment-dependent. In a quiet studio, speech_prob=0.1 reliably separates speech from silence. In a noisy café, speech_prob=0.7 might be the minimum to avoid false triggers on background chatter. The default threshold is tuned for clean speech in quiet environments. The fix: Tune the threshold for your environment. Record 1 minute of ambient noise + 1 minute of target speech. Plot speech_prob over time. Set the threshold above the highest noise probability and below the lowest speech probability. For dynamic environments (varying noise levels), use Silero VAD's built-in adaptive thresholding or pair with a noise estimator. A one-size threshold fits no environment.

Recommended setup for voice activity detection

Recommended runtimes

Browse all tools for runtimes that fit this workload.

Reality check

Audio models are surprisingly forgiving on hardware. Whisper, Coqui, OpenAI Whisper-cpp all run well on 8-12 GB GPUs. The bottleneck is rarely the GPU; it's audio preprocessing and disk I/O for batch transcription.

Common mistakes

  • Overspending on GPU for audio-only workflows (8-12 GB is enough for Whisper)
  • Running audio + LLM concurrently without budgeting VRAM
  • Using fp32 weights when fp16 / int8 give 2-3x speedup with no quality loss
  • Forgetting audio preprocessing eats CPU cycles — a fast SSD helps more than expected

What breaks first

The errors most operators hit when running voice activity detection locally. Each links to a diagnose+fix walkthrough.

Before you buy

Verify your specific hardware can handle voice activity detection before committing money.

Specialized buyer guides
Updated 2026 roundup