If the mix already kisses 0 dBFS into the limiter, every dB of “loudness” is distortion and gain reduction you can’t take back. Pull the mix bus down 3–6 dB, then limit into clean headroom.

Here’s the chain that quietly ruins bounce after bounce. The mix bus is already kissing the red. A soft clipper is “warming” what’s left. Then a limiter, maybe two, trying to invent loudness from a signal that has nowhere to go. The meters look busy. The file comes back with clipped samples, a true-peak overshoot, and a chorus that feels smaller than the rough mix did at half the level.

The limiter didn’t fail. It never had headroom to work with.

What “into the limiter” actually means

A limiter needs clean peaks below its ceiling so it can catch overs without living in constant gain reduction. If the mix bounce already hits 0 dBFS sample peak—or worse, already has flat-topped clips—every “extra dB of loudness” is either distortion you already printed or GR that ducks the punch you wanted to keep.

Check the level before the limiter, not after. Solo-safe ways:

1. Bypass the limiter (and any clipper stacked in front of it) and watch the mix-bus peak meter on the loudest section.
2. Bounce a quick mix without the master chain and measure sample peak and true peak on that file.
3. Put a peak meter insert before the first ceiling processor and leave it there while you mix.

You’re looking for something like −6 to −3 dBFS sample peak into the first limiter on a finished mix, depending on genre and how hard you plan to drive. Hitting −0.1 into the limiter is not “competitive.” It’s already out of runway.

Measure the pre-limiter bounce

This script takes a mix bounce (ideally with the limiter bypassed), prints sample peak, a simple 4× true-peak estimate, ffmpeg’s true-peak reading, and how many dB you’d need to pull the file down to leave a chosen amount of headroom before a −1.0 dBFS ceiling.

#!/usr/bin/env python3
"""prelimit_headroom.py — how hot is the mix before the limiter?
Usage: python3 prelimit_headroom.py mix_no_limiter.wav [--headroom 6]
Needs: numpy + ffmpeg on PATH.
Prints sample peak, 4×-oversample peak estimate, ffmpeg true peak,
and the gain to pull so peak + headroom sits under a −1.0 dBFS ceiling.
Use a bounce with the master limiter/clipper bypassed."""
import argparse, re, subprocess, sys
import numpy as np
SR = 48000
def load_stereo(path):
    raw = subprocess.run(
        ["ffmpeg", "-v", "error", "-i", path, "-ac", "2", "-ar", str(SR),
         "-f", "f32le", "-"],
        capture_output=True, check=True,
    ).stdout
    return np.frombuffer(raw, dtype=np.float32).reshape(-1, 2)
def sample_peak_db(x):
    p = float(np.max(np.abs(x)))
    return 20 * np.log10(p + 1e-12)
def truepeak_4x(x):
    # Cheap 4× peak estimate via linear upsample of abs envelope peaks.
    # Good enough to show overs; trust ffmpeg's ebur128 for delivery numbers.
    mono = np.mean(x, axis=1)
    up = np.interp(np.linspace(0, len(mono) - 1, len(mono) * 4),
                   np.arange(len(mono)), mono)
    return 20 * np.log10(float(np.max(np.abs(up))) + 1e-12)
def ffmpeg_tp(path):
    err = subprocess.run(
        ["ffmpeg", "-hide_banner", "-nostats", "-i", path,
         "-af", "ebur128=peak=true", "-f", "null", "-"],
        capture_output=True, text=True, check=True,
    ).stderr
    return float(re.findall(r"Peak:\s+(-?[\d.]+) dBFS", err)[-1])
ap = argparse.ArgumentParser()
ap.add_argument("wav")
ap.add_argument("--headroom", type=float, default=6.0,
                help="dB of clean headroom you want before a −1.0 dBFS ceiling")
ap.add_argument("--ceiling", type=float, default=-1.0)
args = ap.parse_args()
x = load_stereo(args.wav)
sp = sample_peak_db(x)
tp4 = truepeak_4x(x)
tp = ffmpeg_tp(args.wav)
target = args.ceiling - args.headroom          # e.g. −1 − 6 = −7 dBFS
pull = min(0.0, target - sp)                  # only pull down, never suggest boost
print(f"sample peak     : {sp:6.2f} dBFS")
print(f"~true peak (4×) : {tp4:6.2f} dBFS")
print(f"ffmpeg true peak: {tp:6.2f} dBTP")
print(f"want into limit : ≤ {target:.1f} dBFS  "
      f"({args.headroom:.0f} dB under {args.ceiling:.1f} ceiling)")
if pull < 0:
    print(f"pull mix bus    : {pull:6.2f} dB  (then limit into the open headroom)")
else:
    print("pull mix bus    : 0.00 dB  (already has the headroom you asked for)")
if sp > -0.5:
    print("note            : mix already kisses full scale. Limiting from here "
          "is mostly distortion and GR.")

Run python3 prelimit_headroom.py mix_no_limiter.wav. On a synthetic transient-heavy loop that already peaks at −0.2 dBFS, it suggests pulling about 6–7 dB so you have clean space under a −1.0 ceiling. Same loop with the bus already at −6 dBFS sample peak prints “0.00 dB” pull—and that’s the session that still has punch after you limit.

Soft clippers, stacked limiters, already-clipped samples

Three patterns show up across genres:

Hip-hop / 808s. The 808 front and the kick click are the first things a starved limiter grabs. If the mix already hits zero, the limiter ducks the sub on every hit and the bounce feels smaller than the beat did in the session. Leave a few dB into the limiter and let a clipper (if you use one) work on purpose, not as damage control.

Rock drums. Snare and crash transients need height. Driving a full-scale bus into a brickwall turns the kit into a pad. Pull the bus, then limit lightly—or fix the overhead/bus compression that was already squashing the hits.

EDM drops. It’s fine to hit a clipper hard for tone. It is not fine to do that on a bus that’s already clipped, then stack a true-peak limiter on top and call the distortion “energy.” Print the drop with headroom, drive the taste processor, then cap true peak last.

After the final bounce

Once the chain is honest—mix down, then limit into headroom—bounce and check clips and true peak. CoProducer’s analyze row for clip count and true peak is the quick tell: non-zero clips after a “safe” limiter usually means the signal was already broken on the way in, or the ceiling isn’t true-peak aware. Fix the input level first; another limiter stage rarely helps.

How much should I pull the mix down before limiting?

Often 3–6 dB on a mix that was already near full scale. Aim for roughly −6 to −3 dBFS sample peak into the first limiter, then set your true-peak ceiling (commonly −1.0 dBTP). Measure the pre-limiter bounce instead of guessing from the post-limiter meter.

Can a limiter fix clipped samples in the mix?

No. It can stop new overs past its ceiling. Flattened peaks stay flattened. Pull the bus down, repair or rebalance the clipped sources in the session, then limit into clean headroom.