"Does Re-Encoding Audio Lose Quality? I Tested 10 Generations"

Every audio forum has the same warning: never re-encode an MP3 to another MP3, because quality "compounds" and the file degrades a little more each time. It sounds plausible. But when I went looking for actual numbers, I found almost none — just advice repeated so often it became folklore.

So I ran the experiment myself. I took one real recording, re-encoded it ten times in a row through the same codec, and measured the error at every single generation. Then I did it again for five more codecs, plus a "format shuffle" chain that mimics what actually happens to files in the wild: MP3 today, AAC tomorrow, OGG after that.

Try MP3 to AAC — free, no sign-up, and it runs entirely in your browser.

One result genuinely surprised me, one confirmed the folklore in a way nobody warns about, and one flat-out busted a myth.

The setup: one song, ten generations, seven chains

The test material is a 1902 piano-roll recording of Scott Joplin's "The Entertainer" — public domain, real musical content with sharp transients, sustained chords, and a wide dynamic range. I cut a 30-second excerpt, converted it to an uncompressed mono WAV, and treated that as the master.

Then I built seven chains:

• MP3 at 128 kbps — the default bitrate of half the internet
• MP3 at 320 kbps — the "archival" bitrate audiophiles swear by
• AAC at 128 kbps — what YouTube and streaming mostly use
• Vorbis at quality 5 — the OGG family's middle setting
• Opus at 96 kbps — the modern efficiency champion
• Opus at 128 kbps
• A format shuffle — MP3 → AAC → Vorbis → Opus → MP3... cycling for ten generations at comparable bitrates

Every generation was encoded from the previous generation, exactly like a file that keeps getting opened and re-saved by different apps. After each pass, I decoded the file back to PCM, aligned it against the master, and computed the error.

The metric is signal-to-error ratio in decibels (bigger = better). Think of it as the distance between the music and the damage: above roughly 35 dB the error is essentially inaudible, in the teens it's clearly there if you listen for it, and at 0 dB the noise is as loud as the music itself. I also split the error into frequency bands, because codecs don't damage all frequencies equally.

The headline results

Read that last MP3 row again, because it's the surprise: ten consecutive re-encodes at 320 kbps did less total damage than a single pass at 128 kbps. One 128 kbps encode landed at 26 dB; ten 320 kbps encodes still sat at 71 dB — an error roughly 20,000 times smaller. At that bitrate, MP3 has enough bits to describe its own output nearly perfectly, so there's almost nothing left to lose generation after generation.

The folklore about "generational loss" is real, but it's a low-bitrate phenomenon, not an MP3 phenomenon.

MP3 at 128 kbps falls off a cliff

The 128 kbps MP3 chain is the disaster scenario the forums warn about, and the shape of the collapse matters more than the endpoints:

• Generation 1: 26.0 dB (fine for casual listening)
• Generation 2: 20.2 dB (error nearly doubles)
• Generation 3: 16.9 dB
• Generation 5: 12.9 dB (clearly audible dulling and swirling)
• Generation 10: 7.9 dB (error RMS is roughly one-third the signal level)

Each pass doesn't add a fixed slice of noise — the error roughly doubles in the early generations, because the codec is now encoding its own quantization noise along with the music, then mangling both. Where does the damage land? The measurement's frequency split is unambiguous: the 8–16 kHz "air" band degrades first and worst. First pass, the error up there is about 4% of the signal; by generation ten it's nearly half the signal's level. That's why badly recycled MP3s don't sound "noisy" so much as dull and phasey — the sparkle is progressively amputated.

If you've ever wondered why a track that traded hands through three apps and a messaging service sounds lifeless compared to the original, this is the mechanism, measured.

AAC plateaus — and Opus barely moves

Here's the finding I didn't expect: AAC at the same 128 kbps doesn't compound the same way. It takes the biggest single first-pass hit (36.3 dB, the best first generation of any 128 kbps chain), drops through generation four... and then just stops. Generations 4 through 10 sit within 0.7 dB of each other, and the air-band error barely moves after the first pass. The encoder reaches a stable output that it can re-describe almost exactly.

Opus tells a similar story from a different angle. At 96 kbps — a bitrate the MP3 era would have called impossible — it loses only 5.7 dB across all ten generations, and its air-band error is the most stable of any chain. Per bit, Opus is untouchable: five consecutive Opus passes at 96 kbps cost less than a single 128 kbps MP3 pass. (Full disclosure: Opus works at 48 kHz internally, so its numbers include a resampling round trip — which is also what happens in any real-world Opus encode of CD audio, so I'd call that fair.)

One honest asterisk on Vorbis: its quality-5 setting is VBR, and on this solo piano recording it delivered only ~48 kbps — the encoder judged the content easy and spent bits accordingly. That's not a flaw; it's VBR doing its job. But it means Vorbis's row in the table is really a "~48 kbps" result, and its mid-pack finish at 17.3 dB is remarkable for half the bitrate of the MP3 chain it beat by 9+ dB. Even so, its air band ended at literally 0 dB — by generation ten, the error above 8 kHz matched the signal itself.

The format shuffle: the way files actually die

Real files don't get re-encoded by the same codec ten times. They get downloaded as MP3, imported into an editor that exports AAC, thrown into a chat app that transcodes again, saved by a screen recorder as something else. So I built that chain: MP3 → AAC → Vorbis → Opus, cycling, at 128 kbps-class settings.

Final damage: 15.8 dB — meaning this mixed chain ended up worse than six straight passes of almost any single codec. The killer detail is which passes did the damage. The MP3 generations were the expensive ones, costing 2.3–3.9 dB each time they appeared, because MP3's 16 kHz lowpass at 128 kbps re-cuts bandwidth that every other codec in the chain had been carefully preserving. The AAC and Opus passes cost almost nothing. Format-shuffling doesn't just add noise — it stacks a new kind of damage on top of the old at every step, and the most bandwidth-limited codec in the chain sets the ceiling for everyone.

And there was a second, sneakier loss: timing drift. My measurement aligns each generation against the master before comparing, and the alignment offsets told their own story: the chain had drifted 1,024 samples behind by generation two, 1,965 by generation six, and 2,906 samples — 66 milliseconds — by generation ten, accumulating ~21 ms on every trip through raw ADTS AAC, which carries no gapless-priming metadata. Sixty-six milliseconds is past the threshold where sensitive viewers notice audio lagging picture. If you've ever re-encoded a video's audio through a couple of tools and found dialogue subtly out of sync with lips, this is likely why — nothing "sounded" worse, the file just slid.

What this means for your files

The practical rules fall straight out of the data:

• Keep a lossless original. One FLAC or WAV master makes every downstream question trivial — you convert once, from the source, and stop the compounding entirely. Storage is cheap; generation ten is forever.
• Converting from the original is harmless; converting from a conversion is not. A 128 kbps MP3 converted to AAC doesn't become "AAC quality" — it becomes a re-encode of damaged goods, and my shuffle chain shows each new codec adds its own tax on top.
• If you must re-encode MP3, use 320 kbps. The myth-bust result: it's essentially a free pass. What it can't do is restore what a previous 128 kbps pass already destroyed.
• For new encodes, AAC or Opus at 128 kbps outclasses MP3 at the same rate — better first generation, dramatically better behavior under repeated processing.
• Watch timing, not just tone, in video workflows. Multiple raw-AAC transcodes can desync audio by tens of milliseconds without any audible quality change.

The natural habitat for these rules is format conversion, which is exactly what a browser-based converter does — with one big caveat worth insisting on: a converter can only be as good as the file you feed it. Whether you're moving MP3 to AAC for a phone-friendly library, going from WAV to MP3 to shrink archives, rescuing an M4A back to MP3, or extracting audio from an MP4, the tool's job is a clean single pass — the "one careful generation" that all seven of my chains survived just fine. The tenth generation is the one nobody survives. (The full toolbox, including lossless-to-lossless routes that dodge this entire problem, is in the audio tools hub.)

There's also a privacy angle hiding in plain sight: browser-based converters that run the encode locally mean your unreleased voice memo or family video never gets uploaded to anyone's server — the processing happens on your machine and the file stays yours. For sensitive audio that matters more than a tenth of a decibel.

Why your ears may disagree with the numbers (and that's fine)

Decibels of error don't map cleanly onto perception. Piano music with hard transients is unforgiving; dense, loud, compressed pop can hide 12 dB of damage behind its own wall of sound. Listener tests consistently show most people can't reliably identify a single 128 kbps opus-grade encode from the original — and my first generations all sit in that near-transparent zone. The generations where measurement and hearing agree are the late ones: below about 15 dB, the dullness and smearing stop being subtle for anyone.

So the honest summary of ten generations across seven chains: one pass of anything at a sane bitrate is fine; ten passes of 128 kbps MP3 is ruin; 320 kbps MP3 is startlingly immortal; AAC and Opus degrade gracefully and then hit a floor; and bouncing between formats is worse than staying put — in sound and in sync. For a parallel test on the image side of the same question — what actually happens when you re-save a JPG seven times — I ran the numbers separately, and the shape of the decay is eerily similar.

FAQ

Does converting an MP3 to another MP3 lose quality? Yes — at 128 kbps the error nearly doubles on the first re-encode (26 dB → 20 dB in my test) and keeps compounding to a clearly audible 7.9 dB by generation ten. At 320 kbps, though, ten consecutive re-encodes stayed near-transparent (71 dB), so the real rule is "don't re-encode at low bitrates," not "never re-encode MP3."

Which audio format degrades least when re-encoded repeatedly? In my test, AAC at 128 kbps degraded least overall: best first generation (36.3 dB) and a stable plateau after generation four where additional passes cost almost nothing. Opus was the most efficient per bit, losing only 5.7 dB across ten generations at 96 kbps. MP3 at 128 kbps compounded the worst.

Is converting between formats (MP3 → AAC → OGG) worse than re-encoding in the same format? Usually yes. My format-shuffle chain finished at 15.8 dB — worse than comparable single-codec chains — because each codec imposes its own bandwidth limits and noise shaping on top of the previous ones. The chain also accumulated 66 ms of timing drift from raw AAC passes, which is enough to desync dialogue from video.

How many times can you re-encode audio before you hear it? With piano music as the material: the first two generations of any 128 kbps-class codec stayed in near-transparent territory, late-generation 128 kbps MP3 (below ~13 dB) was clearly audible, and everything else sat in between. The safe number is "encode once from the best source you have" — every additional generation is a permanent withdrawal from a budget you can't refill.

Does converting to a higher bitrate or lossless format restore quality? No. Lossy damage is information permanently discarded — no downstream conversion can reconstruct it. Converting a 128 kbps MP3 to FLAC or 320 kbps MP3 just faithfully preserves the damage at a bigger file size. Always convert from the least-compressed original that exists.