Benchmark
What actually happens to your file size when you convert WebP to PNG
A reproducible WebP to PNG and WebP to JPG benchmark: output sizes, transparency survival, and the cases where converting is the right call rather than the reflex.
At a glance
- Test corpus: six images that cover the shapes people actually convert — photo, screenshot, logo, flat art, product cutout and a smooth gradient.
- Output PNG came out 7.3x to 18.2x larger than the WebP file it was converted from.
- Output JPG stayed closer: 2.1x to 7.8x the WebP size, because JPG is lossy like WebP.
- Transparency survived perfectly in PNG: transparent pixel counts matched exactly, and every alpha value was preserved within 1/255.
- JPG has no alpha channel at all — transparent areas are flattened onto a matte colour you choose.
- The whole test is published: test-image generator, benchmark scripts and raw CSV results are linked at the end of this page.
Why we ran this benchmark
People convert WebP to PNG for a reason that has nothing to do with file size: they need a format that every application, printer, marketplace and old desktop tool accepts, or they need transparency that survives a round trip through an editing app. The size increase is the bill for that, and almost every guide mentions it without ever measuring it.
So we measured it. Six images, one encoder build, the same quality settings for every file, and the raw output published so anyone can check the numbers or re-run the test.
| Setting | Value used in this benchmark |
|---|---|
| Encoder | Pillow 11.0.0 (libwebp, libjpeg-turbo, zlib 9) |
| Source WebP | quality 80, method=4 (the setting most tools use by default) |
| PNG output | lossless, optimize=True |
| JPG output | quality 85 and 92, chroma 4:4:4 |
| Metrics | file size in KB, PSNR, SSIM, transparent pixel count |
| Date | 22 October 2026 |
The headline result: PNG output is 7x to 18x the WebP it came from
Every source image was first encoded as a WebP at quality 80 — the same kind of file you would download from a modern site — then decoded and written back out as PNG, JPG and WebP. Sizes are the full files on disk.
| Image (pixels) | WebP q80 source | PNG output | JPG q85 | JPG q92 | PNG / source | JPG85 / source |
|---|---|---|---|---|---|---|
| Photo 1600x1200 | 60.7 KB | 1106.8 KB | 140.3 KB | 230.3 KB | 18.2x | 2.3x |
| Screenshot 1920x1080 | 157.7 KB | 1157.2 KB | 331.9 KB | 439.8 KB | 7.3x | 2.1x |
| Logo 800x800 (alpha) | 7.9 KB | 70.3 KB | 31.1 KB | 39.1 KB | 8.9x | 3.9x |
| Flat art 1200x1200 | 24.7 KB | 190.2 KB | 78.9 KB | 99.8 KB | 7.7x | 3.2x |
| Product cutout 1400x1400 (alpha) | 25.0 KB | 401.5 KB | 82.8 KB | 118.5 KB | 16.1x | 3.3x |
| Gradient 1600x900 | 9.3 KB | 136.9 KB | 72.9 KB | 103.0 KB | 14.7x | 7.8x |
Two rows deserve a comment before the general pattern.
The gradient is the worst case for the ratio: a smooth blend costs almost nothing in a lossy codec (9.3 KB) and a lot in a lossless one (136.9 KB), because PNG has to store the exact value of every pixel rather than "a smooth run that trends downward".
The product cutout shows the same effect with transparency attached. Its WebP was only 25 KB because the alpha channel lets the codec skip most of the image, while PNG still has to describe all 1.96 million pixels plus the alpha plane.
Why PNG grows so much, in one paragraph
WebP at quality 80 is lossy. It drops high-frequency detail the eye is unlikely to miss, and it stores what remains in a format designed to be small. PNG is lossless and, more importantly, it is not trying to be small in the same way: it stores every channel of every pixel at 8 or 16 bits, then squeezes the result with filters and DEFLATE. There is no quality knob and no concept of "close enough", which is exactly why PNG is accepted everywhere and why it costs more bytes. The compression guide linked below walks through the filters and colour types; the short version is that PNG pays for guarantees.
A detail that surprises people: the PNG output here is often smaller than the original PNG of the same image. Our photo started life as a 3167.5 KB PNG, went through a lossy WebP at quality 80, and came back as a 1106.8 KB PNG. Nothing was recovered — the pixels came back exactly as the lossy WebP had left them, noise and grain smoothed away. That is a concrete illustration of what quality 80 does to an image.
Transparency survives PNG byte for byte
Two test images carried real alpha: a logo with fully transparent corners and a product cutout with a soft-edged mask. We compared the alpha plane of the source against the alpha plane of the PNG output.
| Image | Transparent pixels in source | Transparent pixels in PNG | Pixels within 1/255 of the original | Result |
|---|---|---|---|---|
| Logo 800x800 | 229,211 of 640,000 | 229,211 | 100% | identical |
| Product cutout 1400x1400 | 1,056,057 of 1,960,000 | 1,056,057 | 100% | identical |
For the JPG output of the same two images, the transparent pixels came out as the matte colour, 0.12 to 0.36 levels away from pure white on average — invisible in practice, but a hard edge everywhere the alpha ended. If a transparent pixel sits next to a dark shape, converting to JPG is what produces the pale fringe everyone blames on "bad exporting".
Convert WebP to PNG for the master copy, then use the PNG where transparency is required and a JPG where it is not. Converting a transparent image to JPG does not "keep" transparency in any hidden form; it decides for you what colour the transparency becomes.
The quality question: does converting lose anything?
Converting a WebP to PNG is a decode followed by a lossless encode, so the PNG contains exactly the pixels the decoder produced. No detail is invented and none is thrown away — the loss, if any, happened when the WebP was created.
That changes what the useful question is. It is not "does PNG lose quality" (it does not) but "what was already lost in the WebP, and does a lossless container make that visible". Two signs in the data suggest the answer:
- The photo's measured PSNR after JPG re-encoding at quality 85 was 38.9 dB, high enough that the remaining error is dominated by the WebP that came before it.
- The screenshot's PSNR barely moved between quality 40 and quality 95 (26.7 dB at both ends) while the file grew from 170.9 KB to 752 KB. When a metric refuses to improve as you spend four times the bytes, the metric has hit a floor set by something else in the pipeline — here, flat UI panels that JPG handles badly at any quality.
When converting WebP to PNG is the right call
| Situation | Convert to PNG? | Why |
|---|---|---|
| Upload rejected by a form, marketplace or printer that only accepts PNG/JPG | Yes | Compatibility is the entire point; the size increase is the cost of being accepted |
| Logo, icon or UI asset with transparency | Yes, PNG | JPG flattens alpha onto a matte colour, and the fringe shows on any non-white background |
| Master copy you will edit repeatedly | Yes, PNG | Each re-save of a lossy format loses more; a lossless master stops the slide |
| Flat illustration or screenshot going straight to the web | Usually no | WebP is smaller and every current browser reads it; keep the WebP |
| Photograph you are publishing online | No | PNG is 7x to 18x the size in our test and browsers already support WebP |
| Animated WebP | Depends | PNG cannot hold an animation; you need APNG, GIF or an animated WebP |
When you should not convert
If the only reason for the conversion is "PNG feels safer", check the actual requirement first. A browser-based workflow that starts from a WebP and ends in a PNG for the web has spent 7x to 18x the bytes to arrive at a file the browser already understood. If you need to cut file size instead, resize first — dimensions dominate the arithmetic — and only then choose a format.
Reproduce the test
Everything is published:
- corpus.zip — the exact six test images these numbers were measured on; unzip beside the script for a byte-for-byte reproduction
- study-a-format.csv — the full size table above with every column
- study-b-jpeg-quality.csv — the quality sweep used further down this file
- study-c-resize.csv — the resampling comparison
- bench_kit.py — regenerates the six test images pixel for pixel
- bench_kit.py — re-runs the study and rewrites the CSVs
- README.txt — the exact command order
What this test does not cover
The corpus is synthetic and regenerable, which is what makes the numbers checkable, but it is smoother than most camera files. Real photographs carry sensor noise that costs PNG even more bytes and costs JPG more as well, so the direction of every conclusion here holds while individual multipliers will move. We used one encoder build (Pillow 11.0.0); browser canvas encoders differ by a few percent because they run different library versions. The point of publishing the scripts is that you can re-run this on your own files, with your own encoder, and compare.
Convert WebP files to PNG or JPG — in your browser
Batch conversion, ZIP download, transparency kept. No upload.
Sources
- PNG specification (W3C / ISO 15948) — https://www.w3.org/TR/png-3/
- WebP container and compression overview (Google) — https://developers.google.com/speed/webp/docs/compression
- Pillow image format and save-option documentation — https://pillow.readthedocs.io/en/stable/handbook/image-file-formats.html
- Technical details of the test: measured 22 October 2026, Pillow 11.0.0, scripts in
./assets/bench/.