Yes, Spotify turns quiet songs up, and the noise floor comes up with them. A master below −14 LUFS gets positive gain during playback, but only as far as its true peak allows, with 1 dB of headroom left over. On the Loud setting it goes to −11 LUFS regardless. Either way, the hiss, rumble and room tone in your quiet parts get the same lift as the music, so check them before you release.

Most of the loudness talk online is about the other direction: masters that are too hot getting turned down. That side is real, and the essay on why streaming turns loud masters down covers it. But plenty of producers now bounce quieter on purpose, because they’ve heard that dynamics survive normalization better. That’s a fair choice. It just comes with a catch that’s easy to miss on studio monitors: a quiet master is a master that will probably be turned up.

Does Spotify actually turn up quiet songs?

It does, and Spotify’s loudness normalization page spells out the rule. Tracks are adjusted toward −14 LUFS, measured with the ITU-R BS.1770 method. Loud masters get negative gain. Softer masters get positive gain, but Spotify considers the track’s headroom and leaves 1 dB for lossy encoding. Their own example is a −20 LUFS track with a true peak of −5 dBFS: it only gets lifted to −16 LUFS, because 4 dB of gain puts its peak at −1.

Two other details from the same page matter for quiet songs:

• The Loud setting ignores peaks. Premium listeners can choose Loud, which targets −11 LUFS regardless of true peak and uses a limiter that engages at −1 dB. A −20 LUFS master gets 9 dB of gain there.
• Albums are normalized as a whole. When someone plays the album, the gain doesn’t change from track to track, so your quiet interlude stays quiet relative to the singles. On a playlist or on shuffle, each track is adjusted on its own.

The page also notes that the web player and some third-party devices don’t normalize at all. So the same file can play at its mastered level in one place and several dB louder in another.

Why does the hiss come up with the music?

Because playback gain is just a volume knob. It doesn’t know which part of the file is your vocal and which part is the preamp hiss under it. If the song goes up 4 dB, the noise floor goes up 4 dB.

In a dense mix that rarely matters, because the music covers the noise from start to finish. In a sparse song it does. The places to worry about are the ones where the music thins out:

• a quiet intro before the beat drops,
• a breakdown that’s down to one pad or a dry vocal,
• a long reverb tail or fade-out,
• gaps between phrases in an acoustic or spoken-word piece.

Earbuds make it worse. They sit right at your ears, they block the room, and people often listen in a quiet bedroom at night. That’s exactly when a hiss you never noticed on monitors becomes the loudest thing in the breakdown.

How do you check your noise floor before release?

Listening is the real test, but a quick measurement tells you where to listen and how much gain to expect. The script below does three things. It reads integrated loudness and true peak with FFmpeg’s ebur128 filter. It works out the gain each Spotify setting would apply, using the rule from their page. Then it finds the quietest moments of the song and measures what’s in them: full-band, above 4 kHz where hiss lives, and below 32 Hz where rumble lives.

#!/usr/bin/env python3
"""noise_floor_check.py: how loud will the quiet parts (and the hiss) be after streaming turn-up?
Usage: python3 noise_floor_check.py song.wav [more.wav ...]
Needs FFmpeg on PATH plus numpy and soundfile (pip install numpy soundfile).
- Integrated loudness and true peak come from FFmpeg's ebur128 filter (ITU-R BS.1770).
- 'Normal' turn-up follows Spotify's published rule: lift toward -14 LUFS, but stop where
  true peak would pass -1 dBTP. 'Loud' is Spotify's -11 LUFS setting, which applies the gain
  regardless and lets a limiter catch the peaks.
- Floors = the 5th-percentile level of 50 ms windows (the quietest real moments, digital silence
  ignored), measured full-band, above 4 kHz (hiss) and below 32 Hz (rumble).
- The -70 dBFS warning line is our starting point for earbud listening, not a standard."""
import sys, re, subprocess
import numpy as np, soundfile as sf

def ebur128(path):
    err = subprocess.run(["ffmpeg", "-hide_banner", "-nostats", "-i", path, "-af", "ebur128=peak=true",
                          "-f", "null", "-"], capture_output=True, text=True).stderr
    I = float(re.findall(r"I:\s+(-?[\d.]+) LUFS", err)[-1])
    tp = float(re.findall(r"Peak:\s+(-?[\d.]+) dBFS", err)[-1])
    return I, tp

def band(x, fs, lo, hi):
    X = np.fft.rfft(x, axis=0); f = np.fft.rfftfreq(len(x), 1 / fs)
    X[(f < lo) | (f > hi)] = 0
    return np.fft.irfft(X, len(x), axis=0)

def floor_db(x, fs, win_ms=50):
    n = int(fs * win_ms / 1000); k = len(x) // n
    rms = np.sqrt((x[:k*n].reshape(k, n, -1) ** 2).mean(axis=1)).max(axis=1)   # louder channel per window
    db = 20 * np.log10(rms[rms > 1e-6])                                     # ignore digital silence
    return np.percentile(db, 5)

for path in sys.argv[1:]:
    I, tp = ebur128(path)
    x, fs = sf.read(path, always_2d=True)
    quiet = floor_db(x, fs)                       # whole band: the quietest moments, music and noise together
    hiss = floor_db(band(x, fs, 4000, 20000), fs) # above 4 kHz in those moments: mostly hiss in a sparse song
    rumble = floor_db(band(x, fs, 0, 32), fs)     # below 32 Hz: rumble, HVAC, handling noise
    normal = max(0.0, min(-14 - I, -1 - tp)) if I < -14 else -14 - I
    loud = -11 - I
    print(f"{path}")
    print(f"  integrated {I:6.1f} LUFS   true peak {tp:5.1f} dBTP")
    print(f"  quietest moments {quiet:6.1f} dBFS   hiss band {hiss:6.1f} dBFS   rumble band {rumble:6.1f} dBFS")
    for name, g in (("normal (-14)", normal), ("loud (-11)", loud)):
        h, r = hiss + g, rumble + g
        flags = [w for w, v in (("hiss", h), ("rumble", r)) if v > -70]
        note = "  <- check " + " and ".join(flags) + " on earbuds" if flags else ""
        print(f"  {name:13s} gain {g:+5.1f} dB -> hiss {h:6.1f}, rumble {r:6.1f} dBFS{note}")

We ran it on three synthetic files, built from a generated slow beat, a speech-like test voice and a soft pad, with a near-empty breakdown in the middle. None of it is a real song. The first is clean. The second has broadband hiss and a 22 Hz rumble sitting under everything. The third is the clean version plus one loud rim hit.

$ python3 noise_floor_check.py quiet_clean.wav quiet_hissy.wav quiet_peaky.wav
quiet_clean.wav
  integrated  -20.0 LUFS   true peak  -4.4 dBTP
  quietest moments  -43.9 dBFS   hiss band  -91.2 dBFS   rumble band  -82.1 dBFS
  normal (-14)  gain  +3.4 dB -> hiss  -87.8, rumble  -78.7 dBFS
  loud (-11)    gain  +9.0 dB -> hiss  -82.2, rumble  -73.1 dBFS
quiet_hissy.wav
  integrated  -20.0 LUFS   true peak  -4.4 dBTP
  quietest moments  -43.8 dBFS   hiss band  -63.7 dBFS   rumble band  -63.7 dBFS
  normal (-14)  gain  +3.4 dB -> hiss  -60.3, rumble  -60.3 dBFS  <- check hiss and rumble on earbuds
  loud (-11)    gain  +9.0 dB -> hiss  -54.7, rumble  -54.7 dBFS  <- check hiss and rumble on earbuds
quiet_peaky.wav
  integrated  -20.0 LUFS   true peak  -1.4 dBTP
  quietest moments  -43.9 dBFS   hiss band  -91.5 dBFS   rumble band  -82.1 dBFS
  normal (-14)  gain  +0.4 dB -> hiss  -91.1, rumble  -81.7 dBFS
  loud (-11)    gain  +9.0 dB -> hiss  -82.5, rumble  -73.1 dBFS

Here’s what those numbers say, still on synthetic audio:

• The full-band floor barely moved. All three files read about −44 dBFS in their quietest moments, because the faint pad in the breakdown is louder than the noise. A single “noise floor” number can miss hiss hiding under quiet music. Splitting the measurement into bands is what found it.
• The hissy version gets lifted into earshot. Its hiss and rumble sit around −64 dBFS in the file. After the normal turn-up that’s about −60, and on the Loud setting about −55. In a quiet room on earbuds, that’s a hiss you hear in the breakdown.
• One peak changes the whole picture. The rim hit pushes true peak to −1.4 dBTP, so the normal setting can only add 0.4 dB. That’s why two −20 LUFS masters can play back at different levels. The Loud setting still adds 9 dB, because it doesn’t look at peaks.

The −70 dBFS line in the script is our starting point, not a standard. Use it to decide which sections to audition, then trust your ears.

How do you lower the noise floor without wrecking the mix?

Work from the source outward. The fixes that happen earliest are the ones that cost the least:

1. Find the track that’s making it. Solo the quiet section and mute tracks one by one. Hiss usually comes from one or two places: a noisy preamp on a vocal, an amp sim, a lo-fi plugin with its noise knob up, or a sample with tape noise baked in.
2. Clean it on that track. A gentle noise reduction pass on the one noisy track is far safer than denoising the master. Clip-gain the gaps down, or use a gate with a slow close, and set the hold so it doesn’t chop the ends of words. The noise gate essay walks through the settings.
3. High-pass what you don’t need. Rumble below the lowest note in the song is wasted energy. A high-pass on the tracks that don’t carry bass, and a careful one on the master, removes it. If it’s a steady buzz rather than rumble, it’s probably mains hum, and the hum essay covers notching it.
4. Fade the edges. Fade intros in from true silence and fade the tail out fully instead of cutting to a noisy room.
5. Dither once, at the end. When you bounce to 16-bit, dither adds a tiny, even noise that’s far quieter than the hiss we’re talking about here. It isn’t the problem, so don’t skip it to chase a cleaner floor.

Some noise is part of the sound. Vinyl crackle, tape hiss and room tone are deliberate choices in plenty of records. The goal isn’t zero noise. It’s noise you chose, at a level you’ve heard on the playback systems your listeners use.

What will an automatic repair do about it?

Not much, and that’s on purpose. CoProducer’s auto-repair may add a cautious high-pass when the rumble or DC evidence is strong. It won’t invent a denoiser for broadband hiss, because guessing at denoising on a finished master tends to smear cymbals, reverb tails and breaths. That’s still mix or restoration work, done on the track that made the noise.

What a meter can do is tell you that the noise is there before you upload. CoProducer reports noise floor next to LUFS in its analysis, which is useful exactly when a song has long gaps.

Should you just master louder to avoid the turn-up?

It doesn’t solve the problem. If you raise the master 6 dB with a limiter, the hiss goes up 6 dB in the file instead of 6 dB at playback, and it ends up in the same place relative to the music. You’ve also given up some of the dynamics you kept the master quiet for.

Pick the loudness the song wants, then make the quiet parts clean enough to survive being turned up. A good check before release:

• Measure integrated LUFS and true peak, and work out how much gain normal playback will add.
• Add that gain to a copy and listen to the intro, the breakdown and the fade on earbuds in a quiet room.
• Then add 9 dB to a −20 LUFS master, or whatever brings it to −11, and listen again, because that’s the Loud setting.
• If you hear hiss or rumble you didn’t choose, fix it on the track that made it and bounce again.

Quiet masters are a good choice for a lot of music. Just remember they’re usually heard louder than you bounced them, and so is everything hiding in the gaps.

Does Spotify turn up quiet songs?

Yes. Spotify applies positive gain to masters below −14 LUFS, but only as far as the track’s true peak allows, leaving 1 dB of headroom. Its own example: a −20 LUFS track with a −5 dBFS true peak is lifted to −16 LUFS, not all the way to −14. On the Loud setting it lifts to −11 LUFS regardless and uses a limiter to catch the peaks.

Will normalization make the hiss in my song louder?

Yes. Playback gain is the same for everything in the file, so if your song is lifted 4 dB, the hiss, rumble and room tone under it are lifted 4 dB as well. It matters most in sparse songs with quiet intros, breakdowns and fade-outs, where there’s little music to cover the noise.

Is −14 always louder than −16 after normalization?

Not in the way people mean. Normalization brings tracks into a similar lane, so the difference you hear afterwards comes from crest factor, tone and arrangement, not from the number on the meter. A −16 master with healthy peaks can sound as full as a −14 one.

Should I master louder so Spotify doesn’t turn my song up?

Only if louder suits the song. Mastering louder raises the noise along with the music, so the hiss ends up in the same place relative to everything else. Clean the noise in the session first, then pick the loudness the song wants.

What noise floor is acceptable for a release?

There isn’t one official number. As a starting point, we flag hiss or rumble that would play back above about −70 dBFS after turn-up and then listen to the quiet parts on earbuds. If you can hear it there, so will listeners.