A streamed reference isn’t the master. It’s the master after the platform turned it down (or up), ran it through a codec, and sometimes through a limiter — so if you match your loudness to the stream, you’re matching an offset you never measured. Get a lossless file, measure both on the same meter, and compare there.

We’ve all done this one. The mix is nearly there, you pull up the record you love on Spotify or YouTube, flip between it and your bounce, and nudge the limiter until they feel the same. It’s fast, and it feels like the responsible move. The catch: what comes out of the app isn’t the file that engineer delivered. It’s that file plus a gain change the platform picked, plus a lossy encode, plus whatever your app and system volume are doing. You matched against all of it at once.

None of this is a reason to stop referencing. It’s a reason to reference the right file.

What the stream did before you heard it

Every big store measures integrated loudness when the track comes in and applies one playback gain. Loud records get turned down. Quiet ones get turned up only sometimes, and only as far as their peaks allow. We built two synthetic references, one loud (−8.8 LUFS) and one dynamic (−17.4 LUFS), and simulated what each platform would hand you: the platform’s gain, then an encode and a decode.

These are synthetic signals and simulated platform behavior, based on what the platforms document, so treat the tenths as illustration. The shape is the point. The loud reference came out of four players at three different levels, and none of them was its real −8.8. The dynamic one didn’t move on three of them, then got shoved through a limiter on the fourth.

Check the peaks, too. The loud reference’s Spotify capture measured −5.1 dBTP. The actual file runs at −0.3. Read peaks off a stream and you’ll decide the pros leave 5 dB of headroom. They don’t. You’re reading the turn-down.

How it bites once you upload

Say you matched the loud reference by meter while it played with Sound Check on. The capture reads −16.0, so you master to −16.1 with a −1.1 dBTP ceiling. Then both records land on Spotify. The reference gets turned down to −14.0. Yours is quiet, and Spotify only lifts quiet tracks until their peaks reach −1 dBTP. You’re already there, so you get about a tenth of a dB. Your record plays around 2 LU under the one you matched. YouTube never turns up, so same story there.

It goes the other way just as easily. Say you referenced the dynamic record on Spotify with the Premium “Loud” setting on. That mode targets −11 regardless of peaks and runs a limiter to get there, so the dynamic reference came out at −12.3 with its peaks already squashed. You chase that and limit your master to −12.3. On Normal playback you get turned down to −14 while the reference plays at its real −17.4. You’re now 3.4 LU hotter than the record you were matching, and you paid for it with limiting you didn’t need.

Same ears, same mix decisions, a completely different result, purely because of which setting was on when you A/B’d. That’s the trap. It also bakes in the codec: lossy streams soften the very top end and smear transients a little, so an air-band or punch match against a stream is partly a match against the encoder.

Platform targets, as guidance not gospel

Sources: Spotify for Artists, “Loudness normalization” (tracks adjusted to −14 LUFS per ITU 1770); Apple Support, “Sound Check” (Apple describes the feature but does not publish a LUFS figure there, so ≈ −16 is the commonly reported value); AES TD1008, the AES recommendations for streaming loudness; ITU-R BS.1770, the loudness and true-peak measurement. The YouTube, Amazon Music and TIDAL rows are commonly reported figures; we did not find an official published target to link.

These drift. Platforms change targets, apps change defaults, listeners change settings. Read the table as the shape of the problem, not a spec sheet. The one constant: the level you hear from a stream is the platform’s decision, not the engineer’s.

The fix: compare files, not apps

The clean version takes about ten minutes:

1. Get a lossless file of the reference. A Bandcamp or Qobuz purchase, a label promo, or the WAV your mastering engineer worked from. A lossless stream beats a lossy one, but it’s still gain-shifted unless normalization is off.
2. If all you have is a stream, measure the offset. On YouTube, right-click the video, open Stats for nerds and read “content loudness”: 5.2 dB there means it’s playing 5.2 dB under its own file. In Spotify or Apple Music, switch off normalization (Normalize volume, Sound Check), set the app volume to full, and treat a loopback capture as a ballpark, not a measurement.
3. Measure both files on the same meter: integrated, short-term max, loudness range, true peak.
4. Loudness-match for listening with clean gain only, turning the louder file down so nothing clips. Then compare tone, punch and width at equal loudness.
5. Pick your delivery number separately. Matching a reference’s balance is the goal. Copying its loudness is optional. Copying its peaks is how you inherit someone else’s codec problem.

Here are steps 3 and 4 as a script. It measures both files on ffmpeg’s EBU R128 meter and writes a loudness-matched listening copy, gain only, so you hear balance instead of level.

#!/usr/bin/env bash
# refcheck.sh — measure your master and a lossless reference on the same meter,
# then write a loudness-matched listening copy (clean gain only, no limiter, no EQ).
# Usage: ./refcheck.sh my_master.wav reference.wav       Needs: ffmpeg
set -euo pipefail
mine="$1"; ref="$2"
meas(){ ffmpeg -nostats -hide_banner -i "$1" -af ebur128=peak=true -f null - 2>&1 |
  awk '/Integrated loudness/{s=1} s&&$1=="I:"{i=$2} s&&$1=="LRA:"{l=$2} s&&$1=="Peak:"{p=$2} END{print i, l, p}'; }
read -r mi ml mp < <(meas "$mine")
read -r ri rl rp < <(meas "$ref")
printf "mine  I %6s LUFS  LRA %5s LU  TP %5s dBTP\n" "$mi" "$ml" "$mp"
printf "ref   I %6s LUFS  LRA %5s LU  TP %5s dBTP\n" "$ri" "$rl" "$rp"
d=$(awk -v a="$ri" -v b="$mi" 'BEGIN{printf "%+.1f", a-b}')
echo "reference minus yours: ${d} LU"
# Turn the louder file DOWN, so nothing in the listening copy can clip.
if awk -v d="$d" 'BEGIN{exit !(d>0)}'; then src="$ref"; g="-${d#+}"; else src="$mine"; g="${d#+}"; fi
out="${src%.*}_listen.wav"
ffmpeg -v error -y -i "$src" -af "volume=${g}dB" -c:a pcm_f32le "$out"
echo "wrote $out (${g} dB). A/B it against the other file at one monitor level."

On our synthetic pair, a master at −14.9 against the loud reference file, it reports:

mine  I  -14.9 LUFS  LRA  12.3 LU  TP  -1.1 dBTP
ref   I   -8.8 LUFS  LRA   6.0 LU  TP  -0.3 dBTP
reference minus yours: +6.1 LU
wrote ref_loud_listen.wav (-6.1 dB). A/B it against the other file at one monitor level.

Six LU is the real distance between the two files, the number the Spotify capture hid by reading −14.0. Now A/B the listening copy against your master at one monitor level. If yours still sounds smaller at matched loudness, that’s a real mix note: low-mid density, transient shape, width. If it sounds the same or better, the gap you heard in the app was the app.

When you want more than loudness, CoProducer’s reference table does this same comparison on two local bounces, with loudness, peak, balance and the delivery gates side by side, so you’re reading divergence on files you control instead of on a stream. Meters only mean something when both sides came through the same door.

Can I use a Spotify or YouTube stream as a mix reference?

For arrangement and vibe, sure. For loudness or peaks, no: the stream has already been turned down or up by the platform and passed through a codec. Use a lossless file, or measure the stream’s offset and compensate for it.

How do I loudness-match a reference track properly?

Measure the integrated LUFS of both lossless files on the same meter, then turn the louder one down by the difference with clean gain. Compare at equal loudness, and set your own delivery level separately.