Skip to content
Gleam Audioby purplecandy

Search the docs

Download Gleam Audio

Free for personal use, with every tool, up to 20 files a week. You only need a license for work.

Version 2.2.0 · Nov 8, 2026

Windows

macOS

Linux

Run this in a terminal to install it for your user:

curl -fsSL https://static.gleamaudio.com/gleam-audio/releases/latest/download/install.sh | bash

Or download a file below and install it by hand.

Windows packages are not code-signed yet, so SmartScreen will ask you to confirm: More info, then Run anyway. Every file has a checksum in SHA256SUMS.

Gleam AudiohomeGuide

FFmpeg Normalize Audio to -16 LUFS in Two Passes

FFmpeg's loudnorm filter measures loudness the way podcast tools do. One pass measures, the second applies the target, and it says when it lands short.

By 6 min read


FFmpeg normalizes audio with the loudnorm filter. The filter measures how loud a file sounds, then changes the gain so it lands on a target you name. Both jobs can happen in one run, and that is the part people trip over, because a single run often stops short of the number you asked for.

The reliable version is two passes. The first pass measures the file and prints the numbers. The second pass hands those numbers back and applies a single, exact gain. You get a result you can check instead of a command that looks like it worked.

The commands below were run on ffmpeg 9.0.1 on Linux, and the filter’s options were checked against the ffmpeg filters manual on 9 November 2026.

What loudnorm does, and what its defaults are

loudnorm implements EBU R128 loudness normalization. You give it three things: an integrated loudness target (I), a maximum true peak (TP) and a loudness range (LRA).

The defaults are worth knowing, because they are not the podcast numbers. I defaults to -24 LUFS, TP to -2 dBTP and LRA to 7 LU. A bare -af loudnorm will therefore make a podcast episode quieter than the podcast target, and the file will look correct in every log line.

Say all three out loud in the command. For speech going to a podcast feed, that is I=-16, TP=-1 and LRA=11.

Step 1: measure the file

This command changes nothing. It reads the file, runs the loudness analysis and prints a JSON block at the end.

Terminal window
ffmpeg -i talk.mp3 -af loudnorm=I=-16:TP=-1:LRA=11:print_format=json -f null -

-f null - throws the audio away, since this pass only wants the numbers. On a 21 second speech clip, the output ended like this:

{
"input_i" : "-26.47",
"input_tp" : "-6.34",
"input_lra" : "13.00",
"input_thresh" : "-38.11",
"output_i" : "-16.94",
"output_tp" : "-1.00",
"output_lra" : "5.90",
"output_thresh" : "-28.28",
"normalization_type" : "dynamic",
"target_offset" : "0.94"
}

Read it in three parts. The input_ values describe the file as it is: -26.47 LUFS integrated, a true peak at -6.34 dBTP, and 13 LU of loudness range, which is wide for speech. The output_ values are the filter’s estimate of what it would produce. target_offset is the gap it expects to leave: 0.94 LU under the -16 you asked for.

Step 2: apply the measurement

Take the four input_ values and the offset and pass them back in. The numbers are negative, so keep the minus signs.

Terminal window
ffmpeg -i talk.mp3 \
-af "loudnorm=I=-16:TP=-1:LRA=11:measured_I=-26.47:measured_TP=-6.34:measured_LRA=13.00:measured_thresh=-38.11:offset=0.94:linear=true:print_format=json" \
-ar 48000 talk-normalized.wav

linear=true asks for a single gain change rather than the dynamic mode that rides the level through the file. A single gain keeps the internal balance of the recording exactly as it was recorded, which is what you want when the voice already sounds right.

Two things can stop that from happening, and the filter does not raise an error when they do. Either the target LRA is lower than the file’s own loudness range, or the gain needed would push the true peak above your TP. In both cases the filter quietly falls back to dynamic mode. The normalization_type field in the JSON block tells you which mode actually ran.

Set the sample rate, or you get a 192 kHz file

The manual says dynamic mode upsamples to 192 kHz so it can detect true peaks, and that you should set the output rate yourself with -ar or aresample. Skip that and the file keeps the working rate: a test run without -ar wrote a 192000 Hz WAV, which is four times the size of the same audio at 48 kHz.

-ar 48000 or -ar 44100 fixes it, whichever matches your source and your editor.

Targets that match where the file goes

Where it plays Integrated loudness True peak
Broadcast, EBU R128 -23 LUFS -1 dBTP
Podcasts -16 LUFS -1 dBTP
Music streaming -14 LUFS -1 dBTP

The three numbers are the ones most platforms work from, and the LUFS page here explains what the measurement does and why peaks are a separate limit. Pick one target for a series and keep it, so one episode does not sound weaker than the last.

When the second pass comes back short of the target

Measure the output rather than trusting the command:

Terminal window
ffmpeg -i talk-normalized.wav -af ebur128=peak=true -f null -

The Summary block gives integrated loudness, loudness range and true peak. On the clip above, the two-pass run reported dynamic in normalization_type and measured -16.6 LUFS, with the true peak sitting exactly on -1.0 dBFS. The peak ceiling was the binding limit: a linear gain of 10.47 dB would have put the peaks at 4.13 dBTP. The loudness range was the second limit, since the file’s 13 LU is wider than the LRA=11 target.

Three ways to close the gap, in order of how much I would trust them:

  • Run the same command again on its own output. Each run measures the new file and re-applies. On the clip the numbers went -16.9, then -16.3, then -16.0 LUFS, with the true peak pinned at -1.0 dBFS.
  • Add the difference with the volume filter. -af "volume=0.6dB" moved a -16.6 LUFS file to -16.0 LUFS. It also pushed the true peak from -1.0 to -0.4 dBFS, so this one trades peak headroom for loudness. Use it when the platform only checks integrated loudness.
  • Even out the levels before normalizing. On one test file a compressor before loudnorm did not close the gap by itself, so measure again after it rather than assuming it worked.

Normalize a folder of files

A loop does a whole folder in one go. This is one pass per file, because parsing the JSON between passes needs a script.

Terminal window
mkdir -p normalized
for f in *.mp3; do
ffmpeg -y -i "$f" -af "loudnorm=I=-16:TP=-1:LRA=11" -ar 48000 "normalized/${f%.*}.wav"
done

One sample file landed at -16.9 LUFS and another at -18.3 LUFS from the same command, so check what came out. If you would rather not write the two-pass parsing yourself, ffmpeg-normalize wraps it and runs both passes for you:

Terminal window
uvx --from ffmpeg-normalize ffmpeg-normalize talk.mp3 -t -16 -tp -1 -ar 48000 -ext wav

It writes to a normalized/ folder, and -ext wav asks for a WAV instead of its default Matroska container. On the clip above it produced -16.3 LUFS at a -1.0 dBFS true peak, closer to the target than the one-shot command, because it measures first. It also prints the fallback reason in plain words when linear mode is refused, which is easier to read than a JSON block. Its loudness range target defaults to 7 LU, so a speech file will trip that warning unless you pass --keep-loudness-range-target or a higher -l.

Peak, average level and loudness are three different numbers

volumedetect is the quick check people reach for, and it does not measure loudness. It reports a simple average and the highest peak:

Terminal window
ffmpeg -i talk.mp3 -af volumedetect -f null -

On the clip it printed mean_volume: -28.6 dB and max_volume: -6.3 dB. The same file measured -26.47 LUFS integrated. mean_volume is an unweighted average, so it answers a different question from input_i, and it is the reason a file can look fine in volumedetect and still be far from the loudness target.

For a quick level without a target, dynaudnorm evens out quiet and loud moments inside one file. It has no target to aim at: a test run left a -26.47 LUFS recording at -22.6 LUFS.

When a command line is the wrong tool

The commands above are worth learning if you already work in a terminal, or if you normalize the same feed every week. They are a poor fit when you want to hear the result before you trust it, or when the file also needs noise taken out first.

Gleam Audio does the same job with a button. Its Enhance tool, in version 2.2.0, opens with a Kind of recording preset, so you pick Podcast, Lecture or class, Voice-over or narration, Meeting or phone call, or Room with echo, and it fills in the steps for that sound. A preset leaves the Target loudness setting as you set it, so you change the level and nothing else. It runs on macOS, Windows and Linux with nothing uploaded, and it is free for personal use up to 20 files a week.

If you only want to know where a file sits now, the free LUFS meter reads loudness and true peak in the browser and shows both next to each target. If the problem is uneven words rather than the overall level, audio leveling explains the difference between setting a level and evening one out.

Questions

What is the ffmpeg command to normalize audio?

ffmpeg -i in.wav -af loudnorm=I=-16:TP=-1:LRA=11 -ar 48000 out.wav. That is one pass, so it measures and applies in the same run. For a result closer to the target, measure first with print_format=json and pass the measured values back in a second run.

Why does ffmpeg land below my loudness target?

The filter works in dynamic mode when a linear gain would push the true peak past your TP value, and it reports that as normalization_type "dynamic". Dynamic mode protects the peak first, so a quiet file with wide dynamics can end up a LU or two under the target. Running the command again on its own output moves it closer.

Should I normalize to -16 or -14 LUFS?

-16 LUFS is the podcast number and -14 LUFS is where music streaming sits. Pick the target the platform asks for, keep true peak at -1 dBTP or lower, and stay consistent across every file in a series.

Does normalizing make audio louder or just even?

Normalizing moves the whole file by one gain, so quiet and loud parts inside it stay the same distance apart. It sets the level, not the evenness. For a speaker who drifts away from the mic, even out the levels first with a compressor, then normalize.

Comments


Gleam Audio Pro

Hey, we're working on something new. We're calling it Gleam Audio Pro: a multi-track editor for podcasts, lectures and narration. It's our take on an editor for busy creators, so you spend your time on the show, not the knobs.

Gleam Audio isn't going anywhere. It will keep getting updates and stay focused on one thing: studio-quality sound, without the studio.

Pro is coming to Mac and Windows. Join the waitlist →

By signing up you agree to the privacy policy.