Your TTS Sounds Great Until the Feed Normalizes It: A Twelve-API Loudness Audit
Photo: Audio Mix House from United States, CC BY 2.0, via Wikimedia Commons
Every generative audio demo has the same tell: someone plays the output through a laptop speaker, nods, and says "that's clean." It is clean. It's also, in a surprising number of cases, six to nine decibels hotter than the delivery spec for the show it's headed into, or so quiet that the platform's normalizer has to drag it up and bring the noise floor along for the ride.
The browser does not have an opinion about any of this. Your distribution pipeline does.
The rig
We pulled twelve APIs into the same harness: eight text-to-speech endpoints (four conversational, two narrator-style, two multilingual clones) and four music/SFX generators. For each, we rendered the same three scripts — a 42-second narrated intro, a 90-second two-speaker dialogue, and a 15-second ad read — at each vendor's default settings, then again at whatever the vendor called "broadcast" or "high quality." That's 72 files per pass, two passes a week apart to catch drift.
Measurement stack was boring on purpose: [ffmpeg](https://en.wikipedia.org/wiki/FFmpeg) in analysis mode for integrated LUFS and true peak, pyloudnorm as a cross-check, sox stat for peak/RMS, and a 4x-oversampled true-peak pass because inter-sample overs are exactly the thing that a naive peak meter misses.
ffmpeg -i input.wav -af loudnorm=I=-16:TP=-1.5:LRA=11:print_format=json -f null -
We then pushed every file through a simulated platform chain: one normalizer targeting -16 LUFS stereo (Apple Podcasts-style), one targeting -14 LUFS (Spotify-style), and one targeting -14 LUFS with a hard -1 dBTP ceiling (YouTube-style). Same gain staging, same limiter, three destinations.
What actually came back
Grouping the twelve into failure modes was more useful than ranking them, because the rankings shuffled between passes and the failure modes didn't.
The hot masters. Four APIs shipped defaults between -11 and -13 LUFS integrated, with true peaks from -0.2 to +0.6 dBTP. That last number matters. A file that reads -0.2 dBFS on a sample-peak meter can still clip after the platform's resampler touches it, and two of these did exactly that — audible crackle on plosives in the dialogue script, invisible in every waveform view we rendered at native rate.
The timid masters. Three landed between -24 and -27 LUFS. On their own these sound fine — quiet, but fine. The problem arrives at normalization: a -26 LUFS file being lifted 10 dB to hit -16 brings its noise floor up 10 dB too. One multilingual voice clone had a noise floor sitting around -62 dBFS; after the lift it was audible in the gaps between sentences, that faint HVAC-in-a-closet hiss that makes a show feel amateur without anyone being able to say why.
The reasonable ones. Five sat between -16 and -19 LUFS with true peaks under -1.5 dBTP. These needed essentially no work. They were not the five that sounded best in a browser. They were just the five whose vendors had clearly thought about delivery.
The stereo thing nobody warns you about
Three TTS endpoints returned dual mono labeled as stereo. Not a bug, exactly — the channels were identical, so a mono sum is lossless. But two of the music generators returned genuinely decorrelated stereo with heavy wide reverb, and when we summed those to mono (which plenty of smart speakers and phone speakers do), the level dropped 3.4 and 4.1 dB respectively and the vocal element thinned out noticeably. If your podcast is consumed half in cars and half in earbuds, you want to know which of your assets survive a mono fold-down before you ship them, not after.
We added a mono-sum check to the harness after that. It's four lines of ffmpeg and it caught things the stereo meters never would have.
Sample rate and the resample tax
Nine of twelve returned 44.1 kHz. Two returned 48 kHz. One returned 24 kHz and politely called it high quality. The 24 kHz one is the interesting case: upsampled to 48 kHz it measured fine on loudness, but the spectral rolloff above 12 kHz was a hard cliff, and on the ad read — which the vendor had tuned for a bright, punchy delivery — the sibilance turned into a lisp. Nobody flagged it in a subjective listen until we A/B'd against a 48 kHz sibling.
Sample rate isn't a loudness problem, but it's the same class of problem: a property of the file that the browser hides and the pipeline exposes.
The pre-flight check we now run
Nothing here is exotic. It's roughly forty lines of shell and a spreadsheet.
- Measure before you listen. Integrated LUFS and 4x-oversampled true peak on the raw render, every time.
- Reject anything above -1.0 dBTP. Not -0.1. Leave the resampler room.
- Check the noise floor in a silent gap, not on the whole file. Pull a 1.5-second pause and measure it. Anything above -55 dBFS is going to embarrass you after normalization.
- Simulate the target platform's normalization, don't just target a number. A -16 LUFS file that gets turned down is a different animal from a -26 LUFS file that gets turned up.
- Mono-sum everything and compare levels. A 3 dB drop is your warning sign.
- Confirm sample rate at the source and resample once, early, with a decent filter — not three times across the chain.
We're not naming the twelve vendors in this pass. Two of them have asked for the measurement files and one has already shipped a "delivery-safe" preset in response, which is the outcome we actually wanted. When the rest respond, or don't, we'll publish the table.
The uncomfortable takeaway
Generated audio is judged by listeners in maybe four seconds and by normalizers in about four milliseconds. Those are different exams, and passing the first one tells you almost nothing about the second.
The good news is that the delivery spec is not a mystery — it's public, it's stable, and it takes an afternoon to build a harness that checks it. The bad news is that almost nobody does, because the browser keeps telling us everything is fine.