Use a meter that runs in your browser or your DAW, and nothing leaves your computer. Integrated LUFS and true peak come from a published method (ITU-R BS.1770) that any laptop can run, so a free meter plug-in, one FFmpeg command or the CoProducer analyzer in your browser will read a finished bounce in seconds, with no queue, no account and no copy of your unreleased song on someone else’s server.

It’s an easy habit to fall into. You finish a bounce at 1 a.m., you want to know if it’s too loud for Spotify, and the first search result is a site that asks you to upload. So you sign up, wait for the progress bar, wait in a queue, and get back a number your own computer could have worked out before the upload finished. Meanwhile a song nobody has heard yet is now sitting on a disk you don’t control, under terms you probably didn’t read.

Why would I avoid uploading a song just to check its loudness?

• It’s slower. Measuring is fast. Moving a big WAV over a home upload connection is not. The numbers are below.
• You lose track of the file. Once it’s uploaded, how long it’s kept, who can see it and what it may be used for is up to that service’s terms. Some are clear and fair. You still have to go and read them, for every site, every time they change.
• Unreleased means unreleased. A leak before release can cost you the rollout you planned. The fewer copies exist, the fewer can leak.
• Friction adds up. Accounts, logins, credits, per-track limits, “pick a genre preset” screens. None of it changes the math of a loudness measurement.

None of that makes online tools bad. It just means “I want a number” is the wrong reason to use one.

How long does uploading a song actually take?

Here’s the plain arithmetic. A four-minute stereo WAV at 48 kHz and 24-bit is 4 × 60 × 48,000 × 3 bytes × 2 channels, which is about 69 MB. Upload time is just size divided by your upload speed. These are example speeds, not anyone’s actual connection, and real uploads add overhead and queue time on top:

Upload speeds on home connections are often much lower than download speeds, so run a test at Speedtest and look at the “Upload” number for your real figure. Now compare that with measuring locally. On our test machine, FFmpeg measured four minutes of synthetic audio across four files (92 MB) in about one second, including true peak. Your computer may be slower or faster, but the measurement is rarely the slow part.

How do I check LUFS on my own computer?

Three ways, from no setup to fully automatic.

1. A meter plugin in your DAW. Put a loudness meter on the master bus and play the whole song through. The Youlean Loudness Meter has a free version that runs as a VST, AU or AAX plugin and shows integrated LUFS, short-term loudness and true peak. Most DAWs also ship a meter of their own. Play the song start to finish, because integrated loudness only means something once it has heard the whole track.

2. One FFmpeg command. FFmpeg is free and runs on Windows, macOS and Linux. Its ebur128 filter follows the EBU R 128 method, which uses BS.1770 loudness. It reads the file faster than real time, so you don’t sit through playback. Here it is on a synthetic test file, trimmed to the summary it prints at the end:

$ ffmpeg -hide_banner -nostats -i mix_v2.wav -af ebur128=peak=true -f null -
...
Summary:

  Integrated loudness:
    I:          -9.8 LUFS
    Threshold: -19.8 LUFS

  Loudness range:
    LRA:         0.3 LU
    Threshold: -29.7 LUFS
    LRA low:    -9.9 LUFS
    LRA high:   -9.6 LUFS

  True peak:
    Peak:       -1.0 dBFS

“I” is integrated loudness. “LRA” is loudness range. With peak=true, the “Peak” line under “True peak” is the true peak; FFmpeg labels it dBFS, but it’s the true-peak value, so read it as dBTP.

3. A whole folder at once. When you’re checking an album, an EP or a pile of alternate mixes, measure them all in one go. This script runs the same FFmpeg meter over every audio file in a folder, prints a table and saves a CSV next to the songs:

#!/usr/bin/env python3
"""measure_folder.py: loudness for every audio file in a folder, measured on this machine.
    python3 measure_folder.py ./bounces
Prints a table and writes loudness.csv into the folder. Uses ffmpeg's EBU R128 meter
(integrated LUFS, loudness range, true peak). No account, no upload, no network."""
import csv, re, subprocess, sys, time
from pathlib import Path

AUDIO = {".wav", ".aif", ".aiff", ".flac", ".mp3", ".m4a", ".ogg", ".opus"}

def measure(path):
    err = subprocess.run(["ffmpeg", "-hide_banner", "-nostats", "-i", str(path), "-vn",
                          "-af", "ebur128=peak=true", "-f", "null", "-"],
                         capture_output=True, text=True).stderr
    s = err[err.rindex("Summary:"):]
    f = lambda pat: float(re.search(pat, s, re.S).group(1))
    return f(r"I:\s+(-?[\d.]+) LUFS"), f(r"LRA:\s+(-?[\d.]+) LU"), f(r"Peak:\s+(-?[\d.]+) dBFS")

folder = Path(sys.argv[1] if len(sys.argv) > 1 else ".")
files = sorted(p for p in folder.iterdir() if p.suffix.lower() in AUDIO)
rows, t0 = [], time.perf_counter()
for p in files:
    I, lra, tp = measure(p)
    rows.append((p.name, I, lra, tp, "check peak" if tp > -1.0 else ""))
    print(f"{p.name:22} {I:6.1f} LUFS  LRA {lra:4.1f} LU  TP {tp:+5.1f} dBTP  {rows[-1][4]}")
loud = [r[1] for r in rows]
if loud:
    print(f"spread: {max(loud) - min(loud):.1f} LU between loudest and quietest")
print(f"{len(rows)} files, {sum(p.stat().st_size for p in files) / 1e6:.0f} MB, "
      f"measured in {time.perf_counter() - t0:.1f} s")
with open(folder / "loudness.csv", "w", newline="") as fh:
    w = csv.writer(fh); w.writerow(["file", "integrated_lufs", "lra_lu", "true_peak_dbtp", "note"]); w.writerows(rows)

We ran it on a folder of four synthetic one-minute tracks made to be deliberately inconsistent, the way a rough album folder often is:

$ python3 measure_folder.py album
01_intro.wav            -15.1 LUFS  LRA  0.9 LU  TP  -2.6 dBTP  
02_single.wav            -8.3 LUFS  LRA  0.3 LU  TP  +1.5 dBTP  check peak
03_ballad.wav           -19.1 LUFS  LRA  0.8 LU  TP  -5.9 dBTP  
04_closer.wav            -9.7 LUFS  LRA  0.4 LU  TP  +0.1 dBTP  check peak
spread: 10.8 LU between loudest and quietest
4 files, 92 MB, measured in 1.0 s

Two things jump out without listening to a note. The tracks sit 10.8 LU apart, so on an album the ballad would land like a different record unless that’s the intent. And two tracks have true peaks above −1 dBTP, one of them at +1.5, which is the kind of file that can clip once it’s encoded. That took about a second, and nothing left the folder.

Is a local meter as accurate as an online one?

It’s the same math. Any meter that follows BS.1770 (and the EBU’s R 128 recommendation built on it) applies the same weighting filter, the same 400 ms blocks and the same gating to work out integrated loudness. Two compliant meters should agree closely on integrated LUFS. True peak can differ by a small amount between meters, because each one estimates the waveform between samples with its own oversampling. The EBU publishes test signals and tolerances in Tech 3341 that meters are checked against.

The bigger source of disagreement is usually not the meter at all. It’s measuring a different file: the MP3 preview instead of the WAV, the version before the last limiter tweak, or 30 seconds instead of the whole song. Measuring locally, on the exact file you’ll deliver, removes most of that.

And remember what the number is for. Spotify’s loudness normalization plays tracks at around −14 LUFS by default and turns louder masters down, so the target isn’t “as loud as possible”. It’s knowing where you are, and keeping true peak below −1 dBTP (−2 dBTP if the master is louder than −14 LUFS).

Which local LUFS meters are worth trying?

All of these read a file you already have, on your machine. Features and free tiers change, so check the vendor page before you rely on one. We make the CoProducer analyzer, so weigh that row accordingly.

Whichever you choose, measure the exported file rather than the session, and use the same meter for every version so the numbers are comparable.

What about stem separation and other heavy jobs?

This is where the trade gets real. Measuring loudness is light work. Splitting a song into vocals, drums and bass with a neural network is heavy, and it runs much faster on a decent graphics card. Open-source separators such as Demucs run locally (its repository is archived now, but the code still works), and on an older laptop without a GPU a split can take a few minutes per song rather than seconds.

So the honest question is whether a few minutes of your own computer’s time is worth keeping the song at home. For an unreleased record, it usually is. For a public song you just want to study, a cloud tool you trust can be fine. Either way, it’s your decision to make on purpose, not the default because a website asked first.

When is uploading the right call?

Plenty of times. Uploading is the whole point when:

• You’re sending the mix to a mastering engineer or collaborator you’ve chosen.
• You’re delivering to your distributor. That upload has to happen, and it’s the one that counts.
• You’ve picked a cloud service to do creative work, such as an online master, and you’re comfortable with its terms.

Before uploading something unreleased, do three quick things. Read the part of the terms about how long files are kept, who can access them and whether they can be used for anything else. Keep your original WAV and session where they are, since an upload is a copy, not a backup. And upload once, the final file, rather than every rough version you’re testing.

For day-to-day checks, keep the meter on your own machine. That’s how CoProducer’s analyzer is built: the page talks to an engine on your own computer, and if that isn’t running, it measures in the browser, so the file stays on your device.

Can I check LUFS without uploading my song?

Yes. LUFS and true peak are defined by a public standard (ITU-R BS.1770) that any computer can calculate. A free meter plugin in your DAW, or FFmpeg’s ebur128 filter from the command line, measures the file on your own machine without an account or an upload.

Is a local LUFS meter as accurate as an online one?

If both follow ITU-R BS.1770, they should agree closely on integrated loudness, usually within a tenth of a dB or so. True-peak readings can differ slightly because meters oversample differently. Pick one meter and use it for every version you compare.

Is local always higher quality?

Not automatically. A local tool isn’t smarter, it’s just better defined: you keep the original WAV, you know which settings ran, and you can run it again tomorrow and get the same answer.

Does the CoProducer site upload my song when I analyze it?

No. The analyzer on the CoProducer page sends your file to an engine running on your own computer (at 127.0.0.1) if you’ve started one. If that engine isn’t running, the page measures the file in your browser, so it stays on your device either way.

Which free LUFS meters run locally?

Youlean Loudness Meter 2 has a free plug-in and standalone app, FFmpeg’s ebur128 filter is free on the command line, and many DAWs include a meter, such as Logic Pro’s Loudness Meter or REAPER’s JS: Loudness Meter. The CoProducer analyzer reads a file in your browser. Whichever you pick, measure the exported file and use the same meter for every version.

Can I check LUFS without uploading my song?

Yes. A loudness meter in your DAW, a free plug-in, an FFmpeg command or a browser-based analyzer measures integrated LUFS and true peak on your own computer, so the file never leaves it.