VocalFuse is a Fuse Intelligence product.

WHISPER · PODCAST WORKFLOW · 2026

Whisper for podcasts — transcribe every episode locally, for free

Whisper-class models are the accuracy baseline every podcast transcription tool is measured against, and the weights are free. Run them on your own machine and there is no upload, no per-minute meter, and no file cap — an hour-long episode becomes 8,000+ indexable words, captions, and chapter data without leaving your PC. This guide covers the four decisions that separate a clean transcript from a frustrating one: which source files to feed it, which model to pick, how to stop hallucinations on your intro music, and how to batch a whole back catalog.

Why Whisper is the podcast default in 2026

Three reasons, and none of them involve an API key. First, accuracy: on clean English studio audio modern Whisper-class engines land in the 3–6% word-error-rate band — the same numbers the paid cloud services inherit, because most of them run Whisper or a fine-tune of it under the hood. Second, it runs on your hardware: the model file sits on disk, inference happens on your CPU or GPU, and nothing uploads. For interview shows with source-protection concerns, that is not a convenience — it is the whole point (no vendor ever receives the audio, so there is nothing to subpoena, breach, or train on). Third, it is genuinely free software with no minute caps: a ten-year back catalog of 300 episodes costs the same as one episode — zero.

The honest caveat: real podcast audio is harder than benchmarks. On a real two-person show — remote guests, one accent, crosstalk, brand names — expect 8–15% WER and a short cleanup pass, not the marketing 98%. The good news is that the two highest-leverage fixes are free and take minutes: fix your input files (next section) and feed the model a custom vocabulary list for guest names, product names, and jargon. Every engine mishears the same 30–50 words episode after episode unless you teach it once.

Start from per-track source files, not the mixed feed

The single biggest quality decision happens before Whisper ever runs: which audio file you feed it. Remote recording studios keep the goods — Riverside, Zencastr, and StreamYard all record each participant as a separate track. Use those.

Source What Whisper sees Speaker labels Verdict
Per-track WAVs (studio export)One clean voice per file — no crosstalk in the signal at all~98% — transcribe tracks separately or assign per-track; diarization barely neededBest — do this
Mixed master, one voice per channelClean stereo split; each side mostly isolated~95%+ — assign by channelNearly as good
Mixed show feed (the published MP3)Both voices interleaved, crosstalk baked in~90% — diarization required (pyannote/WhisperX)Acceptable fallback
Re-encoded 128 kbps copyArtifacts from the transcodeDegrades furtherAvoid — keep the 320 kbps master

Two mechanical notes. If you transcribe each track separately, you already know who is speaking — label the files and merge, and skip diarization entirely (on one-voice-per-track input it is nearly error-free by construction). And mind the bitrate chain: transcoding a 320 kbps master down to 128 kbps before transcription costs accuracy you never get back — transcribe from the highest-quality file you have, then compress for publishing.

The full step-by-step — from getting the episode audio to publishing the transcript page — is in our podcast transcription workflow guide.

Model size vs accuracy: which Whisper to run

One decision, three sensible answers. The 2026 default is large-v3-turbo: released September 2024 with the decoder pruned from 32 layers to 4 (809M parameters), it runs roughly 5× faster than full large-v3 with near-identical accuracy on well-resourced languages like English — and it made the old medium-model compromise obsolete, beating medium on both speed and accuracy at nearly the same footprint.

Model Params Disk Relative speed Use it when
large-v3-turbo809M~1.6 GB~5×The default — hour episodes in minutes on a mid-range GPU
large-v31,550M~2.9 GB1× baselineAccuracy-critical runs where time is not the constraint
medium769M~1.5 GB~2×Skip it — turbo is better at both ends now
small244M~466 MB~4×Low-RAM machines, overnight batch jobs where time is free
tiny / base39–74M75–142 MB~7–10×Drafts and quick scans only — accuracy not publishable

Benchmarks for context: NVIDIA's Parakeet TDT 0.6B v3 posts a 6.34% average WER vs Whisper large-v3's 7.44% on published English benchmarks, so if you are choosing engines rather than models, the Whisper label is not automatically the accuracy crown. Whisper's advantages are the 99-language coverage and the ecosystem (every tool speaks it).

The hallucination problem: intro music, silence, and "Thanks for watching"

Every podcast has the exact audio that trips Whisper: a produced jingle, room tone between takes, thirty seconds of dead air at the tail. Whisper was trained on weakly supervised audio paired with subtitle files — segments where the text does not match the audio — so it learned real associations between non-speech sound and fluent text. Feed it your intro music and it may return "Thanks for watching," a subtitle credit, or the same phrase looping until the segment ends. The outputs look plausible — well-formed timestamps, confident text — which is exactly what makes them dangerous in an automated pipeline: nothing marks them as fabricated.

The fix that actually works is VAD — voice activity detection — so non-speech audio never reaches the model. Whisper.cpp ships Silero VAD support:

whisper-cli -m models/ggml-large-v3-turbo.bin \
  --vad -vm models/ggml-silero-v5.1.2.bin \
  -f episode.wav -osrt

Two tuning flags matter most. --vad-speech-pad-ms pads each detected speech segment — set it too low and word onsets get clipped (you trade hallucination for truncation). --vad-min-silence-duration-ms decides how long a pause must be before a segment is cut — too low and sentences fragment, costing accuracy. And note the classic gotcha: --vad needs the VAD model passed via -vm — omit it and the flag appears to do nothing.

If loops persist, escalate: disable cross-segment conditioning (-mc 0), consider --no-timestamps for pure-text runs (timestamp computation is implicated in repetition loops), trim music beds manually, and post-filter the specific boilerplate phrases your audio produces. Confidence-threshold flags alone disappoint: hallucinated boilerplate is high-confidence output — the filter is designed to catch low-confidence text, so raising thresholds starts discarding quiet real speech before it reliably discards confident invention.

Batch workflows: a back catalog on autopilot

The transcription itself is fast; the reason to think in pipelines is everything around it. Published local-pipeline timings for a 90-minute episode: ~5.5 minutes on an RTX 4070, ~8.5 on an RTX 3060 — while CPU-only machines took ~58 minutes for the same file. If you are GPU-less, batch overnight instead of waiting; if you are GPU-equipped, a full back catalog of 40 episodes is an afternoon, not a month.

A practical local stack decouples the stages so each is replaceable:

  1. Transcribe — whisper.cpp or faster-whisper with VAD enabled; word-level timestamps if you want chapters (WhisperX adds per-word alignment via wav2vec2).
  2. Diarize — pyannote 3.x labels speakers (11–19% DER on real-world audio); skip it entirely on per-track input.
  3. Clean — strip disfluencies, fix the 30–50 recurring mishears with your vocabulary list, verify names.
  4. Derive — one timestamped transcript feeds every downstream surface: SRT captions, chapter markers, show notes, the episode-page HTML.

That last step is where the SEO value compounds: the same transcript becomes Google-indexable episode text, chapter markers, show notes, and episode schema. Transcribe once, publish everywhere.

Turnkey option: Whisper-class transcription without the command line

The DIY stack above is the free-and-flexible route, but it is a dev project: you maintain the runtime, the VAD model, the diarization plumbing, and every model update. VocalFuse ships the same architecture as a Windows app — a ~57 MB Whisper-class engine that runs entirely on your machine. Drop the episode in, get a timestamped transcript with speaker labels, export TXT/SRT/VTT. Nothing uploads, ever.

Because the engine runs on your PC, there is no per-minute meter anywhere in the product — the free tier covers real work, Basic is $5/mo flat dictation, and Pro $10/mo adds AI note taking, speaker labels, and summaries. Local processing means your raw interview audio never touches a vendor's cloud — the same guarantee the DIY stack gives you, without the pipeline maintenance.

Related reading

How to transcribe a podcast

The full step-by-step: get the audio, transcribe, label speakers, export, publish.

The workflow guide

Local podcast transcription

No upload, no per-minute meter, SRT/VTT/TXT export — the VocalFuse pipeline in detail.

The local workflow

Podcast chapters

Timestamps from the transcript become chapter markers — all three formats and Apple's rules.

Chapters guide

Podcast episode schema

The PodcastEpisode JSON-LD template that makes episodes rank in Google.

Schema template

Publishing the transcript

Same-URL placement, visible HTML vs accordions, schema, and the per-episode workflow that gets the transcript ranking.

Publishing guide

Explore related AI note taking guides

Whisper for podcasts — FAQ

Is Whisper good for transcribing podcasts?

Yes — Whisper-class models are the accuracy baseline every podcast transcription tool is measured against, and running them locally means no upload, no per-minute meter, and no file caps. On clean English studio audio expect roughly 3-6% word error; on real two-person podcast audio with remote guests and crosstalk, plan for 8-15% and a short cleanup pass. The two things that move real-world results most are starting from per-track source files instead of the mixed show feed, and feeding the model a custom vocabulary list for names, brands, and jargon.

Which Whisper model should I use for podcast episodes?

large-v3-turbo is the 2026 default: 809M parameters (the decoder pruned from 32 layers to 4), roughly five times faster than full large-v3 with near-identical accuracy on well-resourced languages like English — an hour-long episode transcribes in minutes on a mid-range GPU. Use full large-v3 (1.55B) when accuracy is everything and time is not, and skip medium entirely — turbo beats it on both speed and accuracy at a nearly identical footprint. Small (466 MB) is the fallback for low-RAM machines doing batch jobs overnight. Benchmarks for context: Parakeet TDT 0.6B v3 posts 6.34% average WER vs Whisper large-v3 at 7.44%.

Why does Whisper hallucinate on my podcast intro music?

Whisper was trained on weakly supervised audio paired with subtitle files, so it learned real associations between non-speech audio and fluent text — jingles, silence, and room tone come back as "Thanks for watching," credit lines, or a phrase looping until the segment ends. The outputs look plausible (well-formed timestamps, confident text), which is what makes them dangerous in an automated pipeline. The fix that actually works is VAD — only speech regions reach the model. Whisper.cpp ships Silero VAD support: whisper-cli --vad -vm ggml-silero-v5.1.2.bin -f episode.wav. Trimming music beds manually also helps.

How do I stop Whisper hallucinations during silence?

Enable voice activity detection so silence never reaches the model: in whisper.cpp pass --vad with a Silero VAD model via -vm (omitting -vm is the usual reason --vad appears to do nothing). Tune --vad-speech-pad-ms (too low clips word onsets) and --vad-min-silence-duration-ms (too low fragments sentences). If loops persist, disable cross-segment conditioning (-mc 0), consider --no-timestamps for pure-text runs (timestamp computation is implicated in repetition loops), and post-filter the specific boilerplate phrases your audio produces. Threshold flags alone disappoint because hallucinated boilerplate is high-confidence output — the filter is designed to catch low-confidence text.

Should I transcribe each podcast track separately or the mixed audio?

Per-track, whenever your remote studio recorded separate files per participant (Riverside, Zencastr, StreamYard all do). Transcribing each speaker's own track removes crosstalk from the signal entirely and pushes speaker-label accuracy from roughly 90% on mixed audio toward 98% — and if you transcribe tracks separately, diarization is barely needed because speakers are already separated at the recording stage. If all you have is the mixed show feed, clean audio with one voice per stereo channel works nearly as well. Keep bitrates high: transcoding a 320 kbps master down to 128 kbps costs accuracy you never get back.

How long does it take to Whisper-transcribe an hour-long episode?

On a modern GPU, minutes: published local-pipeline timings put a 90-minute episode at roughly 5.5 minutes on an RTX 4070 and about 8.5 minutes on an RTX 3060, and large-v3-turbo runs about five times faster than full large-v3 on the same hardware. CPU-only machines are the slow path — a Ryzen desktop took roughly 58 minutes for the same 90-minute file — so batch overnight rather than waiting. The transcription is the automated part; budget 10-15 minutes of human cleanup for speaker labels and jargon.

What is the easiest way to run Whisper on podcasts without the command line?

VocalFuse runs a Whisper-class engine locally on Windows inside a normal app: drop the episode file in, get a timestamped transcript with speaker labels, export TXT/SRT/VTT, and nothing ever uploads. There is no per-minute meter because the engine runs on your PC — free tier, Basic $5/mo dictation, Pro $10/mo adds AI notes and summaries. If you want the raw open-source stack instead, whisper.cpp with Silero VAD plus WhisperX for word timestamps and diarization is the free DIY route; both paths end at the same transcript.