How to prevent audio clipping before you upload
- Step 1Bounce your mix with a touch of headroom already — Export from your DAW at the highest quality you have — ideally WAV or FLAC. If your DAW master is already slammed to 0.0 dBFS, that's fine; the limiter will pull the overs down. But a mix that's already a few dB below full scale gives the limiter less work and a cleaner result.
- Step 2Confirm you're on Pro (this tool is gated) — The true-peak limiter requires a Pro subscription — Free accounts get a 'requires a Pro subscription' message. Pro allows files up to 200 MB and 120 minutes, one file at a time. Pro + Media and Developer raise that to 100 GB with no duration cap.
- Step 3Drop the file onto the limiter above — FFmpeg WebAssembly loads in the tab and processes the buffer locally. Accepted input is any audio container FFmpeg can decode (MP3, WAV, FLAC, M4A/AAC, OGG, Opus, and more); video files are not the target here — for those use the video-to-wav or video-to-mp3 tools first.
- Step 4Pick the ceiling from the dropdown — -1.0 dBTP · standard is the safe default for almost every streaming platform. -1.5 dBTP · safer adds margin for aggressive low-bitrate encodes. -2.0 dBTP · Amazon matches Amazon Music's tighter spec. -0.3 dBTP · loud keeps the file as hot as practical when you accept a smaller safety margin. These four are the only ceiling values the browser UI offers.
- Step 5Choose your output format — MP3 (192 kbps CBR), WAV (16-bit PCM), FLAC (lossless), or M4A/AAC (192 kbps). For an upload that the platform will re-encode anyway, lossless WAV/FLAC preserves the most fidelity going in. For a direct-to-host file where size matters, MP3 or M4A is fine.
- Step 6Download and verify the reported peak — The result panel shows the achieved true-peak in dBFS measured by ebur128. Confirm it sits at or below your chosen ceiling, then upload. If you also need loudness compliance (LUFS), run the loudness-normalizer first — its two-pass EBU R128 already applies a true-peak limit, so this tool becomes a final safety pass.
Ceiling options the browser UI offers
These are the only four ceiling values selectable in the tool above. The ceiling (dB) is converted to a linear amplitude (10^(dB/20)) and passed to FFmpeg's alimiter as limit=<linear>. The API/MCP schema accepts any value from -6 to 0 dB, but the web UI is fixed to these four.
| UI option | Linear limit passed to alimiter | When to use it | Trade-off |
|---|---|---|---|
| -1.0 dBTP · standard | ≈ 0.891251 | Default. Spotify, Apple Podcasts, YouTube all expect roughly this much headroom | Universally safe; loses ~1 dB of peak level |
| -1.5 dBTP · safer | ≈ 0.841395 | Spoken-word or material that will be re-encoded at low bitrate (64–96 kbps) | Extra margin against codec overshoot; slightly quieter ceiling |
| -2.0 dBTP · Amazon | ≈ 0.794328 | Amazon Music, whose loudness spec pairs -14 LUFS with a -2 dBTP ceiling | Tightest headroom; matches the strictest mainstream platform |
| -0.3 dBTP · loud | ≈ 0.966051 | When you want the file as hot as practical and accept a small safety margin | Minimal headroom — risky for aggressive lossy re-encode |
What this tool changes vs leaves alone
The limiter applies one FFmpeg filter (alimiter) then a verification pass (ebur128). It does not touch loudness, EQ, or dynamics beyond the peak ceiling.
| Aspect | Behaviour | Detail |
|---|---|---|
| Peak ceiling | Enforced | alimiter is a look-ahead brickwall limiter; samples below the ceiling pass unchanged |
| Integrated loudness (LUFS) | Not targeted | Loudness may dip slightly where limiting engages, but no LUFS target is applied — use loudness-normalizer for that |
| Output verification | Always run | ebur128=peak=true re-measures the limited file and reports the achieved peak in dBFS |
| Bitrate (MP3/M4A) | Fixed | Lossy outputs encode at 192 kbps; WAV is 16-bit PCM, FLAC is lossless |
| Sample rate / channels | Preserved | The limiter doesn't resample or downmix — use sample-rate-converter or channel-splitter for that |
Cookbook
Real before/after scenarios for pre-upload limiting. Peak figures are illustrative of the ebur128 dBFS the tool reports after processing.
Mix at 0.0 dBFS, MP3 upload re-encode overshoots
A mix bounced to exactly full scale measures clean in the DAW but the platform's MP3 encoder reconstructs inter-sample peaks above 0 dBFS, producing crackle. Limiting to -1.0 dBTP before upload leaves headroom for that overshoot.
Before (DAW bounce): sample peak 0.0 dBFS → upload to host → MP3 re-encode → decoded peak ~+0.8 dBFS (clips) After (ceiling -1.0 dBTP, output WAV): ebur128 reported peak: -1.0 dBFS → upload → MP3 re-encode → decoded peak stays under 0 dBFS No crackle on playback.
Keep the master lossless for the platform
When the host re-encodes anyway, feed it the cleanest possible source. Limit to -1.0 dBTP and output FLAC so no extra lossy generation is stacked before the platform's own encode.
Input: master.wav (24-bit, 0.0 dBFS peaks) Ceiling: -1.0 dBTP · standard Format: FLAC (lossless) Output: master-limited.flac Peak reported: -1.0 dBFS One limiting pass, no lossy generation added before upload.
Low-bitrate podcast host — use the safer ceiling
A host that re-encodes to 64 kbps mono can introduce larger overshoot. The -1.5 dBTP option gives extra margin without measurably hurting perceived level on speech.
Input: episode.wav Ceiling: -1.5 dBTP · safer Format: MP3 (192 kbps) Output: episode-limited.mp3 Peak reported: ~-1.5 dBFS Survives the host's 64 kbps mono re-encode cleanly.
Loudness first, then limit as a safety pass
The correct order for full platform compliance: normalize loudness, then run this limiter as a guaranteed ceiling. The loudness-normalizer already applies a true-peak limit in pass two, so this final pass is belt-and-braces.
Step 1: loudness-normalizer, preset Spotify (-14 LUFS, -1 dBTP) Step 2: true-peak-limiter, ceiling -1.0 dBTP, format WAV Result: -14 LUFS integrated, peak confirmed -1.0 dBFS Two passes; second pass guarantees the ceiling holds.
Hot file for a context that won't re-encode
Distributing a download that plays back as-is (no platform codec) lets you keep more level. The -0.3 dBTP option holds the file just under full scale.
Input: loud-trailer.wav Ceiling: -0.3 dBTP · loud Format: WAV Output: loud-trailer-limited.wav Peak reported: -0.3 dBFS Maximum level retained; only safe when no lossy re-encode follows.
Edge cases and what actually happens
Free-tier account tries to run the limiter
Requires ProThe true-peak limiter is gated at the Pro tier. A Free account triggers a 'TP Limiter requires a Pro subscription' error before any processing. Free is limited to other audio tools at 50 MB / 30 minutes / 1 file. Upgrade to Pro to unlock the limiter (200 MB / 120 min).
File exceeds the Pro 200 MB or 120-minute cap
Limit exceededPro caps each audio file at 200 MB and 120 minutes — a long, high-bitrate WAV can hit the size cap well before the duration cap. The two limits are independent; either one rejects the file. Convert to FLAC first with wav-to-flac to shrink the size, or upgrade to Pro + Media (100 GB, no duration cap).
Achieved peak reported slightly above the chosen ceiling
By designalimiter is a sample-peak look-ahead limiter, not a true inter-sample (oversampled) limiter. ebur128's peak measurement is true-peak-style and can read a touch higher than the linear ceiling alimiter enforced. That's why the standard advice is -1.0 dBTP rather than 0 — the margin absorbs this difference. Pick -1.5 or -2.0 dBTP if you need a larger guaranteed gap.
Input already sits below the ceiling
PreservedIf the loudest peak in your file is already quieter than the ceiling you chose, alimiter never engages and the audio passes through unchanged (aside from the format re-encode). The tool still runs the ebur128 verification so you get a confirmed peak figure. This is expected — the limiter is a ceiling, not a maximizer; it never raises level.
Expecting LUFS loudness normalization from this tool
Wrong toolThis limiter only enforces a peak ceiling; it does not target integrated loudness. The result panel reports peak in dBFS, with LUFS shown as not-measured. For -14/-16/-23 LUFS targets use loudness-normalizer (two-pass EBU R128, which also applies its own true-peak limit).
MP3/M4A output bitrate isn't selectable
By designThe limiter encodes lossy outputs at a fixed 192 kbps; there's no bitrate dropdown for this tool in the browser UI. If you need a specific bitrate, output WAV or FLAC here, then run bitrate-changer to set the exact target.
OGG or Opus output expected
Not in UIThe browser format selector offers MP3, WAV, FLAC, and M4A (AAC) only. While the underlying engine and MCP schema know about OGG/Opus, the limiter's UI doesn't expose them. Output WAV here, then convert with a dedicated converter if you specifically need OGG/Opus.
Video file dropped in
Audio-only toolThis tool's accepted input is audio. Drop a finished mix or master, not an MP4. To pull audio out of video first, use video-to-wav (lossless) or video-to-mp3, then limit the extracted audio.
Browser tab runs out of memory on a huge file
Memory limitFFmpeg WebAssembly decodes into browser memory; very large files near the tier cap can exhaust the tab's heap, especially on mobile. Close other tabs, use a desktop browser, or split long material with audio-splitter and limit each part. The cap exists partly to keep processing within typical browser memory.
Re-limiting an already-limited file
PreservedRunning the tool twice at the same ceiling is harmless — the second pass finds nothing above the ceiling and changes nothing audibly (only the format re-encode applies). Running it at a lower ceiling the second time simply tightens the peak further. There's no cumulative pumping because alimiter only acts on overs.
Frequently asked questions
What does this tool actually run under the hood?
It runs FFmpeg's alimiter filter as alimiter=limit=<linear>:level=disabled, where the linear value is your chosen ceiling in dB converted via 10^(dB/20). alimiter is a look-ahead brickwall limiter. After limiting, the output is re-measured with ebur128=peak=true and the achieved peak in dBFS is reported back to you. All of it runs in FFmpeg compiled to WebAssembly inside your browser.
Is this a true inter-sample (true-peak) limiter?
alimiter is a sample-peak look-ahead limiter, not a fully oversampled inter-sample limiter. That's why the convention is to limit to -1.0 dBTP rather than 0 — the margin absorbs the small inter-sample overshoot that lossy codecs reconstruct. The verification pass uses ebur128's true-peak-style metering, so the reported figure reflects what platforms will see. For most uploads -1.0 dBTP is the right, safe choice.
Why can't I just bounce at 0 dBFS and upload?
Because the platform re-encodes to a lossy codec (MP3, AAC, Opus), and the decoder reconstructs the analogue waveform between your samples. Those reconstructed peaks can exceed 0 dBFS even when every digital sample is at or below it, producing clipping distortion. Leaving 1 dB of headroom before upload prevents that overshoot from clipping.
Which ceiling should I pick?
Use -1.0 dBTP (the default) for Spotify, Apple Podcasts, and YouTube. Use -2.0 dBTP for Amazon Music. Use -1.5 dBTP when the destination re-encodes at low bitrate. Use -0.3 dBTP only when the file plays back as-is with no further lossy encode. Those four are the only options the UI offers.
Does limiting make my file quieter?
Only at the moments where peaks exceed the ceiling — those instants are pulled down. The overall perceived loudness barely moves unless limiting is engaging constantly. If you want a specific loudness target, run loudness-normalizer first; this tool is a ceiling, not a loudness target.
Is the limiter free?
No — it requires a Pro subscription. Free accounts can't run it. Pro processes files up to 200 MB and 120 minutes, one at a time. Pro + Media and Developer raise that to 100 GB with no duration cap and up to 100 files.
Does my audio get uploaded anywhere?
No. FFmpeg runs as WebAssembly in your browser tab and the audio buffer never leaves your machine. Only a usage counter (file processed, no content) is recorded for signed-in dashboard stats. Unreleased mixes stay private.
What output formats can I get?
MP3 (192 kbps), WAV (16-bit PCM), FLAC (lossless), or M4A/AAC (192 kbps). If the platform re-encodes anyway, WAV or FLAC preserves the most fidelity going in. For a direct download where size matters, MP3 or M4A is fine.
Will the limiter fix audio that's already distorted?
No. If the source was recorded or bounced with clipping already baked into the samples, limiting can't undo that — it only prevents new overshoot from forming. Re-export a clean source from your DAW. The limiter is a pre-upload safety ceiling, not a clip repairer.
Can I set a custom ceiling like -1.2 dBTP?
Not in the browser UI — it's fixed to -1.0, -1.5, -2.0, and -0.3 dBTP. The underlying MCP/API schema accepts any value from -6 to 0 dB, so an automated pipeline driving the audio tool surface could pass a custom ceiling, but the web tool itself uses the four presets.
Should I limit before or after loudness normalization?
Normalize loudness first, then limit. The loudness-normalizer's two-pass EBU R128 already applies a true-peak limit, so running this tool afterward is a final guarantee that the ceiling holds. Doing it the other way round lets normalization re-raise peaks above your ceiling.
How do I confirm the limiting actually worked?
Check the achieved peak the tool reports — it re-measures the limited output with ebur128 and shows the result in dBFS. It should sit at or just below the ceiling you selected. If it reads a hair above, that's the expected sample-peak vs inter-sample difference, which is exactly what the -1 dB margin is for.
Privacy first
Every JAD Audio tool runs entirely in your browser via FFmpeg (WebAssembly) and RNNoise. Your audio files never leave your device — verified by zero outbound network requests during processing.