Online EBU R128 loudness meter: what it measures and when to trust it

Anyone publishing audio in 2026 gets measured on loudness. Spotify normalizes. Apple Music normalizes. YouTube normalizes. Broadcasters have to meet EBU R128 (or its US cousin ATSC A/85). Podcast platforms are getting there too.

So a mix that’s “too loud” gets turned down, and a mix that’s “too quiet” gets pushed up and ends up sounding limp. Both are a loss. Measuring it beforehand is the one thing you actually control.

This page explains what a loudness meter really does, which numbers matter, and when a free browser-side EBU R128 / BS.1770-4 meter is enough. The working meter is one click away, open it, drop a file in, and compare what you see against what you read here.

→ Open MixLab Analyzer in the browser

What EBU R128 actually is

EBU R128 is a recommendation from the European Broadcasting Union, first published in 2010 and revised several times since. It describes how to measure loudness for broadcast, but the rest of the world adopted it for everything: mastering, podcasts, streaming services, game audio, accessibility work.

The technical backbone is ITU-R BS.1770-4, the standard that defines the actual algorithm. EBU R128 adds a few rules of thumb on top (target loudness, tolerance, gating practice).

Three numbers do most of the work:

• Integrated loudness (in LUFS): one number for the whole track or clip.
• Loudness range / LRA (in LU): how wide the dynamic spread is.
• True peak (in dBTP): the highest peak between samples, not just on them.

There’s also short-term and momentary loudness for live meters, plus correlation and width for stereo checks. But if you remember nothing else: integrated LUFS, LRA, dBTP.

LUFS: why it isn’t just dB

Plain dB says nothing about how loud something feels. A 100 Hz tone at −10 dB and a 3 kHz tone at −10 dB sound radically different. Your ear is more sensitive to mids than to bass or air.

LUFS (Loudness Units relative to Full Scale) fixes this by applying K-weighting before it measures anything. K-weighting is two filters:

1. A pre-filter that shelves the low end down (a first-order high-shelf around 1681 Hz, +4 dB).
2. An RLB filter that models your ear across the audible range (a second-order high-pass around 38 Hz).

Both are ordinary biquad filters, nothing exotic. Then you take the mean square of the filtered signal, take the log, and you have loudness in LUFS. Done right, this lands within a small fraction of a LU of a reference meter (more on how we check that below).

The targets per platform (2026)

Platform	Target	What happens if you’re off
Spotify	−14 LUFS	Turns louder and quieter material toward −14 LUFS
Apple Music	−16 LUFS	Same, via Sound Check
YouTube	−14 LUFS	Turns down louder uploads; won’t turn quiet ones up
Amazon Music	−14 LUFS	Same idea
TIDAL	−14 LUFS	Same idea
Broadcast EU (EBU R128)	−23 LUFS ±1 LU	Legally required for TV broadcast, max true peak −1 dBTP
Broadcast US (ATSC A/85)	−24 LKFS ±2 LU	Same (LKFS = LUFS)
Podcast (general)	−16 to −19 LUFS	No enforcement, but best practice
Spotify Podcasts	−16 LUFS	Normalizes
Apple Podcasts	−16 LUFS	Sound Check active

The takeaway: streaming platforms put you back on their target no matter what. Winning the loudness war no longer buys anything. You just lose dynamics and gain nothing in perceived volume.

One nuance worth knowing: YouTube and most services only turn down material that’s over target, they don’t push quiet masters up. So aiming a touch under target is safe; going over just gets flattened.

True peak: why sample peak lets you down

A normal “peak meter” reads the highest sample value in your audio. Sounds reasonable, and it’s misleading.

Between two samples, the real analog waveform can be higher than either one. On fast transients (snare hits, clicks, hats) the inter-sample peak can sit 1–2 dB above any single sample. Set your sample peak to 0 dBFS and your codec or converter can still clip on playback.

True peak detection solves this with oversampling. You upsample the signal 4× (or more) through a polyphase filter, measure the real peak, and then you know how much headroom you actually have.

EBU R128 calls for a max of −1 dBTP for streaming and broadcast. Some services are stricter. A Hann-windowed sinc kernel of ~32 taps gives accurate true-peak detection in real time, even in JavaScript, which is why this whole thing runs in a browser tab.

LRA: what’s left after normalization

LRA (Loudness Range) tells you how much your audio swings between quiet and loud, in LU.

• LRA 0–4 LU: over-compressed. Reads as “wall of sound” but lifeless.
• LRA 4–8 LU: pop / EDM mastering. Most of what’s on Spotify.
• LRA 8–15 LU: acoustic, jazz, podcast. Dynamics breathe.
• LRA 15+ LU: classical, film score. Strong dynamic contrast.

There’s no “correct” LRA, it’s a context question. A podcast at LRA 3 gets fatiguing (everything at one level); an EDM track at LRA 12 disappears in a club mix.

Here’s the point most guides miss: once a platform normalizes on integrated LUFS, LRA is what’s left of your actual loudness curve. Too tight is boring. Too wide is awkward in a car. That trade-off is yours to make, and a meter is how you see where you landed.

When an online loudness meter is enough

Almost always. Specifically:

• Pre-flight check before upload: does my master hit the target for where it’s going?
• A/B against a reference: how does my mix sit next to a known track in the same genre?
• QA for podcasts: is my editor delivering consistent integrated LUFS?
• Quick check on a client file: someone sends audio and you want to know fast whether it’s usable.

When it’s not enough:

• Broadcast deliverables where a certified meter is formally required (Nielsen, TC Electronic, Nugen stamps). That needs a certified plug-in or hardware.
• Forensic audio where the meter itself is evidence.
• Live multitrack mixing where you want a DAW meter running in real time as you work.

For mastering checks, pre-upload validation, and QA passes, a good browser-side EBU R128 / BS.1770-4 meter is plenty. It also has one thing no plug-in does: your audio never leaves your device. No upload, no cloud, no account.

How MixLab Analyzer does it

MixLab Analyzer implements BS.1770-4 client-side in TypeScript:

audio file
  ↓ decodeAudioData (WebAudio)
AudioBuffer (Float32 PCM)
  ↓
  ├─ K-weighting (pre + RLB biquads)  → LUFS / LRA
  ├─ true peak (4× polyphase)         → dBTP
  ├─ peak / RMS / crest               → levels
  ├─ Mid/Side decomposition           → stereo width
  ├─ Pearson correlation              → mono-safety
  └─ FFT (radix-2, Hann)              → spectrum

No ML, no API call, no upload. A few hundred lines of TypeScript over the Float32 arrays your browser already decodes.

We validated the output against ffmpeg’s EBU R128 implementation (the industry reference) across a suite of test files. Maximum deviation: ±0.08 LU on integrated loudness, well inside the tolerance that matters for mastering and A/B work.

For the full engineering walkthrough, see Building MixLab Analyzer: BS.1770-4 LUFS in the browser.

If you’d rather run this in a pipeline than a browser, the same engine is available as an API and MCP server, POST an audio file, get integrated LUFS, LRA and dBTP back as JSON, from code or from an AI agent.

Frequently asked questions

Is an online loudness meter as accurate as a DAW plug-in?

For pre-flight checks, yes, provided the implementation runs BS.1770-4 correctly (K-weighting, gating, true peak via oversampling). MixLab Analyzer sits at ±0.08 LU from ffmpeg’s reference, comfortably inside the tolerance for mastering work.

Do I upload audio to audiolab.tools?

No. Nothing leaves your browser. All the DSP runs client-side in WebAudio + JS. No server, no logs, no cloud storage.

What target should I hit for Spotify in 2026?

−14 LUFS integrated with a max of −1 dBTP true peak. Quieter is fine (Spotify won’t push you above target); louder gets flattened.

Does this work for podcasts?

Yes. Target −16 LUFS for Spotify Podcasts / Apple Podcasts. For pure audiobook or meditation content, −18 to −20 LUFS is more comfortable.

What’s the difference between LUFS and LKFS?

Nothing technical, it’s just a different name in a different standard. LKFS comes from the US ATSC A/85, LUFS from EBU R128. Both measure exactly the same thing via BS.1770-4.

Does the meter work offline?

Yes. The browser caches the tool, so on a repeat visit MixLab Analyzer runs without a network connection.

Further reading

• Building MixLab Analyzer: BS.1770-4 LUFS in the browser: the build walkthrough.
• AI mastering plateau: why AI mastering tools hit a ceiling.
• MixLab: the working analyzer + stem compare.
• Methodology: loudness: how we measure and validate this.