geekskai Logogeekskai
ToolsBlogPricing
Sign in
Sign in
ToolsBlogSign in
Wednesday, August 12, 2026|7.655Mins Read

How to Normalize Audio Loudness with LUFS: A Two-Pass Guide

Authors
  • avatar
    Name
    Geeks Kai
    Twitter
    @KaiGeeks
Discuss on Twitter • View on GitHub

Tags

AudioLUFSAudio-Tools

Previous Article

Best EHS Software in 2026

Next Article

How AI Is Helping Developers Build More Global Applications
← Back to the blog
geekskai Logo
geekskai

Public tools for developers and creators, plus optional Geekskai Audio Toolkit plans. Built with care.

Popular Tools

SoundCloud DownloaderSoundCloud to MP3SoundCloud to WAVSoundCloud PlaylistSoundCloud Artwork
View All Tools

Resources

BlogAbout MePricingTagsProjectsPrivacy PolicyTerms of ServiceRefund Policy

Connect With Us

mailMail
githubGitHub
twitterTwitter
linkedinLinkedin
© 2026 geekskai • All rights reserved

What is the fastest way to normalize an audio file with LUFS?

The fastest repeatable workflow is to measure the entire file, choose the loudness target required by its destination, and run a second normalization pass using the measured integrated loudness, true peak, loudness range, and threshold. This is more predictable for finished files than adjusting only their highest peak.

If you already own or have permission to process the file, the Geekskai Audio Toolkit performs this two-pass workflow locally in your browser. A signed-in account receives 30 Free Credits per UTC day and processes one file at a time.

LUFS normalization versus peak normalization

Peak normalization answers a narrow question: how close does the highest sample or true peak come to the ceiling? It can make two files share a similar maximum peak while they still sound noticeably different in average loudness.

LUFS-based normalization instead estimates perceived programme loudness over time. The European Broadcasting Union describes EBU R 128 as a move from using peak meters alone to measuring and normalizing loudness with loudness meters. The EBU also publishes separate guidance for broadcast, streaming, radio, short-form, and cinematic material, which is why one target should not be treated as universal. See the EBU loudness specification overview.

Why two-pass normalization is useful

FFmpeg's official loudnorm filter supports both single-pass and double-pass operation. It can target integrated loudness, loudness range, and maximum true peak. See the loudnorm filter documentation.

A two-pass file workflow works like this:

  1. Measure the complete input. The first pass reads the file and records its integrated loudness, true peak, loudness range, threshold, and target offset.
  2. Apply the measured values. The second pass uses those measurements with the requested loudness target and peak ceiling.
  3. Export and verify. Listen to the output and confirm that it satisfies the destination's technical specification.

This workflow is appropriate for completed files because the first pass can inspect the whole programme. A live stream cannot be measured from beginning to end before playback, so live workflows have different constraints.

A reproducible FFmpeg two-pass example

For a command-line workflow, install FFmpeg from its official download page and use Python 3 to carry the first-pass values into the second pass. Save the following as normalize.py. The example target is -16 LUFS with a -1 dBTP ceiling, not a universal delivery specification; change the target string only after checking your destination.

import json
import math
from pathlib import Path
import re
import subprocess
import sys

if len(sys.argv) != 3:
    raise SystemExit("Usage: python3 normalize.py input.wav output.wav")
source_path, output_path = sys.argv[1:]
if Path(source_path).resolve() == Path(output_path).resolve():
    raise ValueError("Keep the source and output paths separate.")
if Path(output_path).exists():
    raise FileExistsError("Refusing to overwrite an existing output file.")
if Path(output_path).suffix.lower() != ".wav":
    raise ValueError("This example writes PCM WAV; use a .wav output path.")

target_filter = "loudnorm=I=-16:TP=-1:LRA=11"
analysis = subprocess.run(
    ["ffmpeg", "-hide_banner", "-i", source_path, "-map", "0:a:0",
     "-af", target_filter + ":print_format=json", "-f", "null", "-"],
    check=True, capture_output=True, text=True,
)
measurement_match = re.search(r'\{\s*"input_i"[\s\S]*?\}', analysis.stderr)
if measurement_match is None:
    raise ValueError("No loudnorm measurement was returned; inspect the FFmpeg log.")
measurements = json.loads(measurement_match.group())
measurement_fields = {
    "measured_I": "input_i", "measured_LRA": "input_lra",
    "measured_TP": "input_tp", "measured_thresh": "input_thresh",
    "offset": "target_offset",
}
if not all(math.isfinite(float(measurements[key])) for key in measurement_fields.values()):
    raise ValueError("Non-finite loudness measurements; check for silence or invalid audio.")
measured_options = [f"{option}={measurements[key]}" for option, key in measurement_fields.items()]
second_filter = ":".join([target_filter, *measured_options, "linear=true", "print_format=json"])
export = subprocess.run(
    ["ffmpeg", "-hide_banner", "-i", source_path, "-map", "0:a:0",
     "-af", second_filter, "-ar", "48000", "-c:a", "pcm_s24le", "-n", output_path],
    check=True, capture_output=True, text=True,
)
print(export.stderr)

Run python3 normalize.py input.wav normalized.wav with your own authorized source. The script refuses to overwrite an existing output. It selects the first audio stream and writes 24-bit PCM WAV at 48 kHz; those are explicit choices for this example, not claims about the browser toolkit’s sample rate. A non-zero FFmpeg exit raises an error; inspect that error instead of treating a partial file as success.

The second-pass log includes normalization_type. Two passes do not guarantee linear processing. FFmpeg can fall back to dynamic mode when the source loudness range exceeds the requested range or the gain would breach the true-peak ceiling. Its filter documentation explains the conditions; the implementation shows the measurement fields. Explicit output sample rate avoids accidentally retaining dynamic mode’s 192 kHz processing rate.

Measure the exported file again

ffmpeg -hide_banner -i normalized.wav -map 0:a:0 -af loudnorm=I=-16:TP=-1:LRA=11:print_format=json -f null -

Read input_i and input_tp from this check: its input is now your exported file. Check them against your destination’s loudness tolerance and peak ceiling. The check’s output_* fields describe another hypothetical normalization pass and are not the measurement of the file you just delivered. Also verify duration, channels and audible quality; matching a number does not repair clipping.

How to normalize audio locally with Geekskai

Geekskai Audio Toolkit with two-pass LUFS, WAV and MP3 presets, and sign-in requirement

Audio Toolkit interface captured on November 12, 2026, before sign-in. The displayed presets are starting points; use your destination’s delivery specification.

The current Audio Toolkit accepts MP3, WAV, FLAC, and M4A input files up to 200 MB each. Processing uses FFmpeg in the browser; audio and filenames are not uploaded to Geekskai for processing.

  1. Open the Audio Toolkit.
  2. Choose an audio file that you own or are authorized to process.
  3. Select WAV or 320 kbps MP3 as the output.
  4. For WAV, choose 16-bit or 24-bit output.
  5. Enter the loudness target required by the destination.
  6. Start processing and keep the tab open until the result is ready.
  7. Download the normalized file and audition it before delivery.

The toolkit’s normalization pipeline requests an analysis pass, then applies the measured values with a -1 dBTP ceiling and linear=true. FFmpeg may still fall back to dynamic mode. The browser workflow does not provide the same command-line log and sample-rate controls as the example above; independently measure an exported file when delivery specifications matter. One Credit covers one minute of combined input audio, rounded up once per batch. Pay As You Go and Regular monthly Credits are available through secure PayPal checkout for batches of up to 50 local files and ZIP export. Paid Credits apply only to Audio Toolkit processing; public third-party downloader allowances remain separate free-product rules.

How to choose a loudness target

Start with the delivery specification, not a number copied from an unrelated platform guide.

  • Broadcast delivery: Follow the broadcaster's current technical specification. EBU R 128 uses -23 LUFS as its basic programme-loudness recommendation, but it also has supplements for different content contexts.
  • Podcast or spoken-word delivery: Follow the host, network, or client's stated integrated-loudness and peak requirements.
  • Music distribution: Preserve the artistic balance and use the distributor's current guidance. Playback normalization does not replace mastering.
  • Client work: Ask for the exact integrated-loudness, true-peak, channel, sample-rate, and output-format requirements before exporting.

Normalization is not a repair tool. It will not remove clipping already recorded into a file, eliminate background noise, correct a poor mix, or restore detail lost to aggressive compression.

Output format: WAV or MP3?

Choose WAV when the file will be edited again, archived, mastered, or delivered in an uncompressed format. Choose MP3 when a smaller listening or review copy is appropriate and the recipient accepts lossy audio.

The toolkit currently offers:

OutputOptionsGood fit
WAV16-bit or 24-bit PCMEditing, mastering handoff, archive, lossless delivery
MP3320 kbpsReview copies and destinations that accept MP3

Converting a lossy MP3 to WAV does not restore information discarded during the original MP3 encoding. It only changes the output container and encoding.

Troubleshooting browser-based audio processing

Processing is slow

Browser processing uses the local device. Long files and lossless formats can require more memory and time. Close memory-heavy tabs, keep the browser tab active, and test with a shorter file if the device is constrained.

The file is rejected

Confirm that its extension is MP3, WAV, FLAC, or M4A and that the file is no larger than 200 MB. Renaming an unsupported file does not convert its actual media format.

The result still sounds distorted

Loudness normalization cannot undo clipping or distortion already present in the source. Return to the mix or an earlier master, lower problematic levels, and export a clean source before normalizing again.

The output is louder or quieter than expected

Check that you entered the intended target and compare it with the destination's current specification. Perceived loudness also depends on dynamics, frequency balance, and listening conditions; matching a LUFS number does not make different mixes sound identical.

Practical checklist

  • Use only audio you own or have permission to process.
  • Obtain the destination's current delivery specification.
  • Keep an untouched copy of the source.
  • Use a two-pass workflow for finished files when predictable measurement matters.
  • Verify the exported format, duration, channel layout, loudness, and true peak.
  • Listen from beginning to end before publishing or delivering the file.

For a private, installation-free workflow, try one file in the Geekskai Audio Toolkit. For plan limits and current checkout availability, see Audio Toolkit pricing.