Skip to main content

Remove pauses from audio online

Shorten long pauses and silent gaps in speech recordings — tighten podcasts, interviews, and voiceovers.

Free & unlimited
All processing happens in your browser — files never leave your device. The audio engine loads once from a CDN.

This tool removes the pauses from a spoken recording. It runs ffmpeg's silenceremove filter, compiled to WebAssembly and executed in your own browser, which deletes every gap that stays below a loudness threshold for longer than the minimum length you set. Two controls do all the work: a sensitivity tier that sets the threshold at -25, -30 or -35 dB, and a minimum pause length between 0.5 and 5 seconds. Be clear about what this is and is not — it detects silence, not speech. It does not transcribe your audio and it cannot find an 'um' or an 'uh', because those are sounds, not gaps. Recordings where a speaker fills every hesitation with a noise will come back barely shorter. Recordings full of real dead air will come back dramatically tighter.

Key facts about Remove pauses from audio online

Key facts about Remove pauses from audio online
Filterffmpeg silenceremove with stop_periods=-1, so every qualifying gap anywhere in the file is removed, not just the leading one
Gentle sensitivity-25 dB threshold — only clearly silent gaps
Balanced sensitivity-30 dB threshold — the default, standard quiet level
Aggressive sensitivity-35 dB threshold — also catches faint room tone as silence
Minimum pauseSlider from 0.5 s to 5 s in 0.25 s steps, default 1.5 s; internally clamped to the 0.1-5 s range the filter accepts
What it detectsSilence only. There is no speech recognition anywhere in this tool, so spoken filler words are never identified
Output formatThe input's own container, with a _trimmed suffix on the filename — an MP3 stays an MP3
Re-encodeThe file is decoded and re-encoded once, because removing time from the middle cannot be done by stream copy
StatsOriginal and trimmed durations are probed after processing so you see exactly how many seconds went
Accepted inputMP3, WAV, OGG, FLAC, AAC and M4A, up to 200 MB
CancellableStopping a run terminates the WebAssembly worker immediately rather than waiting for the filter to finish

What happens to your file

The recording is processed by ffmpeg compiled to WebAssembly, running in a Web Worker inside this tab. Your file is written into that worker's in-memory filesystem, filtered and read back as a blob — it is never sent anywhere, and there is no transcription service involved because no transcription happens. The only network request is the one-time fetch of the ffmpeg core, a fixed 32 MB public asset from the jsDelivr CDN that your browser caches and reuses across every audio tool here; it carries nothing of yours. The trimmed file exists as a blob: URL in your own tab until you download it.

About this tool

  1. 1

    Add the recording

    Drop an MP3, WAV, OGG, FLAC, AAC or M4A up to 200 MB. The page reads its duration so it can show you how much was removed afterwards.

  2. 2

    Pick a sensitivity

    Gentle at -25 dB only removes clear silence. Balanced at -30 dB is the default. Aggressive at -35 dB also treats faint room tone as a pause, which is right for clean studio audio and wrong for a noisy room.

  3. 3

    Set the minimum pause length

    Only gaps longer than this are cut. 1.5 seconds is a good default for conversation; drop to 0.75 s for a tighter edit, raise past 3 s if you only want to lose genuine dead air.

  4. 4

    Process

    The filter runs in a WebAssembly worker with a live progress percentage. You can stop at any point, which kills the worker rather than letting it finish.

  5. 5

    Compare the durations

    The stats grid shows original length, trimmed length and seconds removed. Play both back; if the speech now runs together without breathing room, raise the minimum pause length and run again.

  6. 6

    Download

    The file comes back in its original format with a _trimmed suffix, ready to publish or drop into an edit.

Specs & compatibility
Input formatsMP3, WAV, OGG, FLAC, AAC, M4A
Maximum file size200 MB — input, decoded audio and output share one ~2 GB WebAssembly heap
Output formatSame as the input, with a _trimmed suffix
Threshold range-25 dB, -30 dB or -35 dB by tier
Pause length range0.5 s to 5 s, in 0.25 s steps
Engine download~32 MB ffmpeg core, fetched once and cached
SpeedSingle-threaded WebAssembly; a one-hour podcast is a multi-minute job on a typical laptop
BrowsersChrome, Edge, Firefox and Safari 15+; needs WebAssembly and Web Workers
  • Check the seconds-removed figure before you trust the result. If it is near zero, your speaker fills pauses with sound and this tool cannot help — the gaps are not actually silent.
  • Aggressive sensitivity is for clean recordings only. In a room with air conditioning the noise floor never drops to -35 dB, so nothing gets removed at all.
  • Long minimum pause lengths produce natural-sounding edits. Short ones tighten the speech but make it sound clipped, because normal speech rhythm relies on gaps under a second.
  • If the recording is noisy, run the noise reducer first. Lowering the noise floor is what makes silence detection work at all.
  • For fine control over exactly where cuts land, and for padding around each kept region, use the silence remover instead — it shows you a silence map before it processes.
  • Every run re-encodes lossy input once. On a file you are going to edit further, work from a WAV and encode at the very end.
  • The output keeps its extension, so a trimmed MP3 goes straight into a podcast host with no conversion step.
  • ffmpeg silenceremove running client-side on WebAssembly
  • Three sensitivity tiers at -25, -30 and -35 dB
  • Minimum pause length from 0.5 to 5 seconds
  • Before and after playback with a source switch
  • Duration stats showing exactly how much was removed
  • Output keeps the input's own format and container
  • Cancellable mid-run
  • Tightening a remote interview where the connection made both people wait before answering
  • Trimming the dead air out of a solo podcast recorded in one take
  • Shortening a webinar or meeting recording before archiving it
  • Cutting the long gaps out of a voice memo dictated while thinking
  • Making a lecture recording faster to listen to without changing playback speed
  • Removing the silence at the start and end of a take along with everything in between
No, and it never has. Removing spoken fillers requires speech recognition to locate the word in time, and this tool contains no recognition of any kind. What it does is find silence — any stretch quieter than the threshold for longer than the minimum pause length — and delete it. For many recordings that achieves the same goal, because hesitation usually shows up as a gap. For a speaker who voices every hesitation, it will not help. The page's own interface says the same thing above the controls.
The recording probably never drops below the threshold. Silence detection is absolute: at the balanced -30 dB setting, a room with air conditioning, a computer fan or street noise outside can sit permanently above that level, so the filter sees no silence at all. Try the aggressive -35 dB tier, which is stricter about what counts as quiet, or run the noise reducer first to pull the noise floor down and then come back. The other common cause is a minimum pause length longer than any real gap in the file.
It can, if the minimum pause length is set too short. Natural speech is full of gaps under a second, and removing all of them leaves sentences colliding into each other. Start at 1.5 seconds, which only takes out pauses a listener would already notice as long, and shorten from there only if the result still drags. If you want the cuts padded so words keep their leading consonants and a fraction of each pause is left behind, use the silence remover, which offers both of those controls.
The same one it went in as, with a _trimmed suffix. An MP3 returns as MP3, a WAV as WAV, a FLAC as FLAC. Because time is being removed from the middle of the file, the audio has to be decoded and re-encoded — stream copying is not possible for this operation — so a lossy input costs one generation of quality. That is usually invisible on speech at normal bitrates, but if the file will be edited further, work from a lossless source and encode once at the end.
Longer than a native ffmpeg run, because this is single-threaded WebAssembly executing in your browser rather than compiled code using every core. As a rough guide, expect a few minutes for a one-hour podcast on a current laptop, and considerably longer on a phone. Progress is reported as a percentage while it runs, and you can cancel at any point, which terminates the worker outright. The 200 MB size cap exists for the same reason: everything has to fit in one WebAssembly heap.
No. It is processed by ffmpeg compiled to WebAssembly, running in a Web Worker on your own machine, and nothing leaves the tab. There is no transcription step and therefore no speech service involved. The single network request the tool makes is fetching the ffmpeg core itself — about 32 MB of fixed public code from the jsDelivr CDN, cached by your browser and shared with every other audio tool here. Your file has no part in that request, and the trimmed output lives only in your tab's memory.

Related tools

View all

Part of Audio tools that run in your browser

Updated

We use anonymous analytics to improve ToolChamp. No personal data is stored or sold. Privacy Policy