Silero VAD: How It Works & How It Compares 2026

Silero VAD is an open-source voice activity detector that tells you which parts of an audio stream contain speech.

It's about 2 MB. In my runs, ONNX scored a 32 ms chunk in a median of 220 to 240 µs on one CPU thread. It supports 8 kHz and 16 kHz audio and is MIT-licensed.

I ran v6.2.3 on a 60-second clip and checked the spec table against the maintainers' pages. ONNX processed the clip about 110 times faster than playback. One setting, minimum silence, moved the segment count from 19 to 7 at 550 ms.

I'd use it for self-hosted Python voice agents after tuning it on your own recordings. The v6.0 notes list music with voice-like instruments and very high-pitched voices as known weak spots.

What is Silero VAD? The 30-second answer

It's a pre-trained neural network that returns a speech probability for every 32 ms chunk of audio (512 samples at 16 kHz). You set a threshold, and chunks above it count as speech.

The project dates to December 15, 2020, when the Silero team released v1, and v6.2.3 is the current release as of September 23, 2026. Pipecat includes it as a core dependency, and LiveKit offers it as a plugin. It runs on a CPU and needs no API key.

Key features

Specs come from the maintainers' pages, mainly the README, plus the file sizes from my v6.2.3 install.

The README calls a chunk "30+ ms." At 16 kHz, the fixed 512-sample chunk (the maintainers also call it a window) lasts exactly 32 ms. The maintainers' performance page labels its test chunk 31.25 ms, slightly under that.

The Model size row looks large for about 260K parameters because, as the FAQ says, the JIT model packs two models into one file, one for 8 kHz and one for 16 kHz.

How does Silero VAD work?

A neural network of about 260K parameters scores fixed-size audio chunks, and a few thresholds turn those scores into speech segments.

Load the audio first with read_audio, which mixes multichannel files down to mono and resamples to the rate you ask for (a mono float32 tensor works too). Each time you invoke get_speech_timestamps, it works through 3 steps:

1. The model scores each chunk. It reads 512 samples at 16 kHz (256 at 8 kHz), and since v5, each chunk includes part of the previous one as context. I feed chunks in order because the wrapper keeps state between calls.

2. A threshold opens and closes speech. A probability above threshold (0.5 by default) starts speech. Speech ends once probabilities stay below neg_threshold for the minimum silence duration. Unless you set it, neg_threshold is threshold - 0.15, with a floor of 0.01.

3. Post-processing cleans up the segments. It drops segments under 250 ms, closes a segment after 100 ms of silence, and adds 30 ms of padding to each side. The Silero defaults are in utils_vad.py.

Each of these values is a parameter you can change, and the Parameters and defaults section below tests what that does.

JIT vs ONNX speed

ONNX was the faster format in the maintainers' v5 benchmark and in my own run. They measure a single chunk on one thread of a Threadripper 3960X. The 1,875 consecutive 512-sample chunks in my run came from a 2.1 GHz Xeon, held to the same thread limit.

ONNX processed my 60-second clip about 110 times faster than playback, and JIT about 84 times faster. The slowest ONNX call took 4.50 ms, more than 8 times the p95. A live-audio latency budget has to absorb spikes like that.

I tested on Python 3.13.16, silero-vad 6.2.3, torch 2.14.1, and onnxruntime 1.29.0, on 2 vCPUs of a 2.1 GHz Xeon, with torch.set_num_threads(1) and one thread for ONNX.

Timings vary between runs (an earlier run gave an ONNX median of 220 µs against 239 µs here). That limits them to comparing the two formats. The segment counts below are deterministic, and the script and raw output are available on request.

Parameters and defaults

Pipecat asks for 0.7 confidence where Silero asks for 0.5, and LiveKit waits 0.55 s of silence where Silero waits 100 ms. Pipecat also applies a min_volume limit of 0.6, which the table doesn't list.

The framework differences raise a practical question, which is how much each setting changes the output. To answer it, I changed one Silero setting at a time and processed the 60-second test.wav from the Silero repo with the v6.2.3 ONNX model.

Minimum silence moved the segment count more than the threshold did. At 300 ms it gave 12 segments, and at 550 ms it gave 7, against 19 at the default.

Lowering the threshold to 0.3 gave 16 segments, and raising it to 0.9 gave 22. Padding of 200 ms left the count at 19 and added 5.3 seconds of speech. The table rests on a single 60-second clip, enough to show which way each setting pushes and too thin to say how far.

How does Silero VAD compare to WebRTC VAD, TEN VAD, and Picovoice Cobra?

The first difference is the output. Silero VAD returns a probability you can tune, WebRTC VAD returns a 1 or 0 for each frame, and TEN VAD's README lists a 306 KB Linux library.

Sources: WebRTC's header file, its license text, the TEN VAD README, its license file, and Silero's quality metrics page for the ROC-AUC row.

On pure noise clips (ESC-50), Silero's quality metrics page lists accuracy of 0.87 for Silero v6, 0.42 for TEN VAD, and 0 for WebRTC.

The team picked each model's accuracy threshold on its own Multi-Domain Validation Dataset (ROC-AUC doesn't depend on a threshold). Read them as maintainer-reported results. I did not reproduce them.

Cekura Bench is no substitute either, since it scores whole voice platforms and its figures don't isolate a detector.

TEN publishes its own comparison in its README, which shows precision-recall curves against Silero VAD and WebRTC VAD and releases its annotated test set.

The README prints no precision or recall numbers, which leaves the plots and a rerun of plot_pr_curves.py as the only way to read them. It also reports an RTF (processing time divided by audio length) of 0.0086 for TEN VAD against 0.0127 for Silero on a Xeon Gold 6348.

Picovoice Cobra is the commercial option. Picovoice's blog lists it with a free trial and paid plans, and notes that it requires an AccessKey from the Picovoice Console. It also says production use needs a license.

The same blog reports a 98.9% true positive rate at 5% false positives against 87.7% for Silero and 50% for WebRTC.

The blog doesn’t name its dataset, though Picovoice’s open benchmark repo mixes LibriSpeech test-clean with DEMAND noise at 0 dB SNR. Picovoice ran the test itself. Confirm current terms with Picovoice before you plan around it.

By use case, Silero VAD works for Python voice agents that need a tunable probability, including on 8 kHz phone audio. TEN VAD makes sense when library size is the priority and your audio is 16 kHz, provided your product doesn't compete with Agora's offerings, which its license bars.

WebRTC VAD is enough when a yes-or-no answer per 10 ms frame will do, and your audio has little background noise (it scored 0 accuracy on the ESC-50 noise clips).

What changed in Silero VAD v5 and v6

v5 doubled the model to 2 MB and, per the maintainers, added 6,000+ languages, and v6 cut errors on noisy audio by about 16%. Dates come from PyPI and the release pages.

On the maintainers' benchmark, Multi-Domain ROC-AUC went from 0.96 for v5 to 0.97 for v6. The larger change is in noise, where ESC-50 accuracy rose from 0.61 to 0.87 and the private noise dataset from 0.44 to 0.71.

These are different metrics from the release notes' 16% and 11% error reductions, and they don't convert into each other.

The v6.0 notes list music with voice-like instruments and very high-pitched voices as known issues. The v6.2 notes report gains on child and cartoon voices without publishing new numbers.

My take is to upgrade to v6 if your audio is noisy, and to test child and cartoon voices yourself before you trust the v6.2 gains.

What I liked and didn't like about Silero VAD

Four things worked in my tests, and three limits are worth knowing before you adopt it.

Pros (what works)

• ONNX used under 1% of each chunk's 32 ms. It took a median of 220 to 240 µs per chunk across two of my runs, single-threaded.

• 8 kHz runs on 256-sample chunks. The v5.0 notes say quality is nearly identical at 8 kHz and 16 kHz (I only ran 16 kHz), which helps on phone audio.

• Streaming comes included, with VADIterator emitting {'start': ...} and {'end': ...} events chunk by chunk.

• There's nothing to sign up for. The README says it sends no telemetry and needs no keys or registration, and nothing expires.

Cons (where it struggles)

• The training process isn’t documented. No paper or training code has been published. NVIDIA’s model card names the training sets, including VoxLingua107, Common Voice and MLS, but lists the collection method for some of the data as “Unknown.” The 6,000-language figure relies on the maintainers’ own statement.

• Music with voice-like instruments and very high-pitched voices are the two persisting issues the v6.0 notes name, and the first two places I'd aim a test.

• On v6.2.3, read_audio raised an ImportError the first time I called it, and only installing torchaudio or torchcodec cleared it. Passing your own tensor avoids the error, and so does the audio extra from the install step.

Should you use Silero VAD? My recommendation

If your voice agent runs on a CPU you control and you can tune the parameters on your own recordings, Silero VAD is a good choice. In my test, minimum silence at 550 ms cut the count from 19 segments to 7, so I wouldn’t deploy the defaults unchanged.

Silero VAD works well for

• Self-hosted Pipecat or LiveKit Agents voice agents

• Telephony pipelines that run at 8 kHz

• Python batch jobs that need speech timestamps before transcription

Skip Silero VAD if you

• Need a yes-or-no decision on 10 ms frames, or a library under 1 MB

• Expect a paid support tier (I found none on the Silero repo or wiki as of October 2026)

If the first bullet describes your project, WebRTC VAD or TEN VAD is the better choice, and the comparison above has their specs.

How to use Silero VAD in Python in 5 steps

Install the package, load the model, and pass in a mono float32 tensor. The code below ran on v6.2.3.

1. Install the package. The base package brings in torch only (ONNX Runtime became optional in v6.2.1). The extras add audio I/O or ONNX.

   pip install "silero-vad[audio,onnx-cpu]"
   

2. Load the model with onnx=True for the faster format.

   from silero_vad import load_silero_vad, get_speech_timestamps, VADIterator, read_audio
   
   model = load_silero_vad(onnx=True)
   

3. Read the audio at 16 kHz. read_audio mixes to mono and resamples.

   wav = read_audio("call.wav", sampling_rate=16000)
   

4. Get speech timestamps. Each result is a dict with start and end.

   ts = get_speech_timestamps(wav, model, sampling_rate=16000, return_seconds=True)
   print(ts[:3])
   

   On the repo's test.wav, my run printed [{'start': 0.0, 'end': 2.0}, {'start': 2.7, 'end': 4.7}, {'start': 5.0, 'end': 6.9}].

5. Stream chunks. Feed 512-sample chunks to VADIterator. It returns {'start': ...} or {'end': ...} when speech begins or ends, and None otherwise.

   it = VADIterator(model, sampling_rate=16000)
   for i in range(0, len(wav) - 511, 512):
       event = it(wav[i:i + 512], return_seconds=True)
       if event:
           print(event)
   it.reset_states()  # reset before the next file or stream
   

Silero VAD best practices for production audio

Several frameworks already include Silero VAD, and each sets its own defaults. The habits and mistakes below start there.

Frameworks that already ship Silero VAD

• Pipecat includes SileroVADAnalyzer in its core pipecat-ai package and processes audio with ONNX on CPU. It periodically resets the model state while nobody is speaking.

• LiveKit loads it with silero.VAD.load() inside AgentSession, and LiveKit's docs recommend pairing it with its turn detector model.

• NVIDIA Riva lists the Multilingual Silero VAD on NGC. The listing is still on v5 (updated December 11, 2024) at 2.22 MB and supports ONNX Runtime and Triton on Linux only. NVIDIA’s package falls under the NVIDIA RIVA License Agreement, though the card notes the model itself is MIT.

Habits to adopt

1. Tune the threshold and minimum silence on your own audio. The maintainers recommend per-dataset tuning, and their own benchmark picked each model's value on a validation set.

2. Change one parameter at a time. In my run, minimum silence at 550 ms changed the segment count by 12, while a threshold of 0.9 changed it by 3.

3. Reset state between independent streams. The model keeps state across calls. With VADIterator, call it.reset_states() after each file or call, as the maintainers’ example does. If you call the model directly in your own loop, call model.reset_states() between unrelated streams.

Mistakes to avoid

• Copying a framework's defaults without reading them. The defaults table above shows how far each one drifts from Silero's own.

• Passing odd chunk sizes. Since v5, only 512 samples at 16 kHz and 256 at 8 kHz are accepted.

• Treating VAD as endpointing. VAD reports whether a frame contains speech, and endpointing decides whether the caller is done. Cekura's VAD guide notes that a detector with high frame accuracy still produces a poor agent if the logic above it responds after 80 ms of silence.

My verdict on Silero VAD

I'd pick it for a self-hosted voice agent that runs on Python and 8 kHz phone audio, because it gives a tunable probability where WebRTC VAD returns a 1 or 0, and it supports 8 kHz where TEN VAD takes 16 kHz only. ONNX takes a median of 220 to 240 µs per chunk on CPU, and the license is MIT.

TEN VAD's Linux library is 306 KB against about 2 MB for Silero, which is relevant where library size is limited and your audio is 16 kHz. WebRTC VAD returns a 1 or 0 per 10, 20, or 30 ms frame, which is enough for a yes-or-no decision.

Treat the benchmark figures above from Silero, TEN, and Picovoice as a shortlist, then check them against your own recordings.

Silero VAD errors in production voice agents

A Silero VAD error can reach callers in three ways. The agent speaks while the caller is still talking (turn-taking), ends the caller's turn too early or waits too long (endpointing), or keeps talking after an interruption (barge-in).

Cekura's voice activity detection guide covers 4 error types (front-end clipping, mid-speech clipping, hang over, and noise detected as speech), and the grouping above is mine.

Cekura tests VAD through how the agent behaves on simulated calls, playing barge-in, coughs, background noise and packet loss against your live agent. Its interruption and talk-ratio metrics run VAD on the call recording, so a changed threshold or silence setting shows up as a failed scenario.

Pre-production testing

• Interruption, silence, background-noise and sound-effect tags injected into simulated calls

• A GitHub Actions workflow runs selected scenarios on pull requests and fails the step when any of them fail

Call metrics

• Interruption, talk ratio, and speaking pace metrics, plus silence and overtalk, measured from call audio

Post-production monitoring

• OpenTelemetry span-level traces across the voice pipeline, from speech-to-text to tool invocations, with Pipecat agents instrumented through the Cekura Python SDK

Cekura connects natively to hosted platforms like Retell and Vapi, and to LiveKit and Pipecat agents.

For a sense of scale, Cekura Bench's voice agent workflows benchmark ran 9 voice agent platforms through the same 82 scenarios 3 times each.

The top performer, PolyAI, passed all 3 runs on 72 of the 82 scenarios (pass³, 87.80%). The benchmark scores whole agents and says nothing about Silero VAD alone.

Talk to a Cekura QA expert about running barge-in and mid-turn silence scenarios against your own agent.

Frequently asked questions

What is Silero VAD used for?

Silero VAD detects speech in audio. Voice agents use it to tell when a caller is talking, and pipelines use it to remove silence before transcription. It returns timestamps for files and start and end events for streams.

Is Silero VAD free for commercial use?

Yes. Silero VAD is released under the MIT license, which permits commercial use as long as you keep the copyright and license notice. The repository's LICENSE file and the PyPI metadata both confirm MIT.

The README’s license badge reads MIT, and so does the LICENSE file in the repository.

What is the main difference between TEN VAD and Silero VAD?

The main difference between TEN VAD and Silero VAD is size and sample rate. TEN VAD's Linux library is 306 KB and takes 16 kHz input, while Silero's is about 2 MB and supports 8 kHz too. On Silero's own benchmark, v6 scores 0.97 Multi-Domain ROC-AUC against TEN VAD's 0.93.

What changed in Silero VAD v6?

The v6.0 release notes (August 26, 2025) report about 16% fewer errors on noisy audio from everyday use and 11% fewer on multi-domain validation. The v6.2 updates improved results on child, cartoon, and low-quality phone audio, and later versions made ONNX Runtime and torchaudio optional.

How do you test Silero VAD in a voice agent?

You test Silero VAD in a voice agent by running simulated calls with interruptions and mid-turn silence against the agent, then scoring how it handles them. Cekura runs these simulations for agents on Pipecat and LiveKit, which both bundle Silero VAD.