The two formats, in plain terms

PNG (Portable Network Graphics) was created in 1996 as a patent-free replacement for GIF. Its design goal is simple: store pixels exactly as they are. Every pixel you put in comes back out bit-for-bit, no matter how many times you save the file. PNG also has an alpha channel — up to 256 levels of transparency per pixel — which is why it's the default for logos, icons, UI screenshots, and anything else that needs to sit cleanly on top of another background.

The price for that fidelity is file size. A real photograph saved as PNG is enormous, because PNG's lossless DEFLATE compression cannot do much with the high-frequency noise a camera sensor produces. A 12-megapixel phone photo exported as PNG typically lands at 10–25 MB. The same photo as a JPG at quality 85 is 300–800 KB.

JPG (Joint Photographic Experts Group) is from 1992, and its design goal is the opposite: shrink photographs as aggressively as possible while keeping them looking the same to a human eye. It does this with lossy compression — it throws away high-frequency detail in flat areas, merges similar colors, and rounds frequency coefficients. The result is a file 5–20× smaller than the equivalent PNG, with artifacts you have to zoom in to find.

JPG has no alpha channel. Every pixel must be a solid color. There is no "transparent JPG." That single design choice is the source of most PNG-to-JPG conversion problems.

The size difference, with real numbers

Theory is fine; numbers are better. Here is what happens when you take a 12-megapixel photograph (4000×3000, 24-bit color) and save it as different formats:

| Format | File size | Quality | |---|---|---| | PNG (lossless) | 14.8 MB | bit-for-bit identical | | JPG (quality 95) | 1.9 MB | visually identical | | JPG (quality 85) | 640 KB | visually identical at normal size | | JPG (quality 75) | 380 KB | mild softening visible if zoomed | | JPG (quality 60) | 220 KB | artifacts visible in flat areas | | WebP (quality 85) | 480 KB | visually identical | | AVIF (quality 70) | 320 KB | visually identical |

The headline number people remember: a 14.8 MB PNG photo becomes a 640 KB JPG at quality 85. That is a 23× reduction. The same photo at quality 75 — still perfectly good for web — drops to 380 KB, a 39× reduction.

Now the inverse case. Take a logo — flat colors, sharp edges, transparency — at 1000×400 pixels:

| Format | File size | Notes | |---|---|---| | PNG (8-bit alpha) | 28 KB | crisp, transparent | | JPG (quality 90) | 44 KB | larger than PNG, no transparency, visible artifacts on edges | | WebP (quality 90) | 22 KB | smaller, supports transparency |

For graphics, JPG is worse on every axis: larger, no transparency, and it introduces visible artifacts along sharp edges. The format choice is doing more work than any quality slider ever can.

When converting PNG to JPG makes sense

There is one situation where PNG-to-JPG is almost always the right move, and three where it usually is.

The clear case: a photograph stored as PNG. This happens more than you'd think. A scanned document saved as PNG, an old archival image, a screenshot of a photo, a stock photo downloaded from a site that defaults to PNG. These files are enormous for no reason — PNG's lossless compression has nothing to bite into with photographic content. Converting them to JPG at quality 85 typically produces a 5–15× smaller file with no perceptible quality loss.

Web publishing. If you're putting a photographic image on a webpage, JPG (or WebP, or AVIF) is the format. A 12 MB PNG hero image will tank your Largest Contentful Paint score and burn through mobile data plans. The same image at 400 KB JPG loads in a fraction of a second.

Email attachments. Most email providers cap attachment size at 25 MB, and many recipients are on mobile. A handful of phone photos saved as PNG can blow past that limit instantly. JPG keeps attachments small and universally compatible — every email client on earth opens JPG.

Social media and messaging. Instagram, Facebook, X, WhatsApp, and similar platforms all re-encode uploads to JPG on their CDN anyway. Sending a 15 MB PNG just means a slow upload followed by aggressive recompression you can't control. Send a 500 KB JPG and you control the quality that goes in.

When converting PNG to JPG is a mistake

For a different class of images, converting to JPG is the wrong call — full stop.

Logos and brand marks. Sharp edges, flat colors, often transparency. JPG turns those clean edges into halos and ringing artifacts, and you lose the transparent background. A 30 KB PNG logo becomes a 50 KB JPG with worse quality.

Icons. Same problem as logos, magnified — icons are tiny, so even minor artifacts consume a large fraction of the visible image.

UI screenshots. Text in screenshots is brutal on JPG. The encoder treats the high-contrast edge between text and background as high-frequency detail and rings it. The result is blurry, ugly text. PNG keeps every pixel of text crisp.

Anything that needs transparency. This is the absolute rule: if the image has transparency and you need it to stay transparent, do not convert to JPG. JPG has no alpha channel. Transparent pixels become solid color — usually black or white, depending on the encoder — and you get an ugly rectangle where there used to be a clean outline.

Diagrams, line art, and charts. Same class as screenshots — sharp edges, flat fills. JPG artifacts are immediately visible.

Images you will edit again. Every time you open a JPG, make changes, and re-save, the encoder re-compresses. Quality compounds downward. This is called generation loss. Keep an editable master as PNG (or TIFF, or PSD) and only export to JPG when you're done.

What you actually lose when you convert

Two things.

Lossless quality. PNG preserves pixels exactly. JPG quantizes them. At quality 85+ the difference is invisible to a human at normal viewing size, but it's there — and if you re-open the JPG, edit it, and save again, the loss compounds. If your workflow is "edit, save, edit, save," PNG is the right working format. Only convert to JPG at the export step.

The alpha channel. This is the more painful one. A PNG with transparency carries a separate per-pixel alpha value, ranging from 0 (fully transparent) to 255 (fully opaque). JPG has no place to store this. When the JPG encoder writes the file, it has to pick a solid color for every pixel — including the ones that were transparent. What you get back is:

  • Transparent pixels → solid black, or
  • Transparent pixels → solid white, or
  • Transparent pixels → whatever garbage color the alpha was hiding

The result is a hard rectangle around your subject where there used to be a smooth fade into the background. Logos that floated cleanly on any background now sit inside an ugly box.

The transparency problem, and how to handle it

If you have a transparent PNG and you need it as a JPG — say, the recipient's software doesn't handle PNG, or you need to email it — you have to deal with the alpha channel explicitly. You can't just hit "convert" and hope.

The standard solution is to flatten the image onto a background color before encoding. You pick a solid color (usually white, sometimes black, sometimes a specific brand color), paint it across the whole image, then composite the PNG on top so the alpha is "baked in" against that background. The result is a solid-color JPG with no transparency — but the background color is one you chose, not garbage.

Here is how to do it on a <canvas> in the browser:

js
async function pngToJpgWithBackground(file, bgColor = '#ffffff', quality = 0.85) { const bitmap = await createImageBitmap(file); const canvas = document.createElement('canvas'); canvas.width = bitmap.width; canvas.height = bitmap.height; const ctx = canvas.getContext('2d'); // 1. Fill the canvas with a solid background color. ctx.fillStyle = bgColor; ctx.fillRect(0, 0, canvas.width, canvas.height); // 2. Draw the (possibly transparent) PNG on top. Alpha is composited // against the background we just painted. ctx.drawImage(bitmap, 0, 0); // 3. Re-encode as JPG. Quality is a number between 0 and 1. return new Promise(resolve => canvas.toBlob(resolve, 'image/jpeg', quality)); }

That is the entire pipeline. Pick the background color thoughtfully:

  • White (#ffffff) — default for almost everything. Matches most document and web backgrounds.
  • Black (#000000) — useful if the image will sit on a dark UI.
  • A specific brand color — if the image will be placed on a known colored surface, match that surface exactly.

What you should not do is let the encoder decide. Some encoders flatten onto black, some onto white, some onto a checkerboard that gets baked in as a texture. The result is unpredictable and usually wrong. Always specify the background.

Quality settings: what 80, 90, and 95 actually cost

Most converters expose a single quality number from 1 to 100 (or 0 to 1 in the Canvas API). It controls how aggressively the encoder quantizes frequency coefficients. Here is what you actually pay at each tier, using the 12-megapixel photo from earlier as a reference:

| Quality | File size | vs quality 95 | What you see | |---|---|---|---| | 100 | 4.8 MB | baseline | visually identical; files often larger than the source PNG | | 95 | 1.9 MB | baseline | visually identical; archival tier | | 90 | 1.1 MB | −42% | visually identical at any normal viewing size | | 85 | 640 KB | −66% | visually identical at normal size; softening only when zoomed | | 80 | 480 KB | −75% | very mild softening in flat areas (sky, skin) | | 70 | 320 KB | −83% | mild artifacts visible in flat areas at full size | | 60 | 220 KB | −88% | clear artifacts; use only for thumbnails | | 40 | 130 KB | −93% | heavy artifacts, color shifts; placeholders only |

The useful pattern: file size drops steeply from quality 100 down to about 85, then flattens. Going from 95 to 85 saves 66% of the file size; going from 85 to 75 saves only another 25%. The first 15 points are the cheap ones.

Practical recommendations:

  • Quality 90 for hero images and any image where you control the viewer's attention. The file is ~40% smaller than q95 and the quality difference is invisible.
  • Quality 85 for the bulk of web photography. This is the default for almost every modern image pipeline. CMS platforms, photo-sharing apps, and most CDN defaults land here.
  • Quality 80 for thumbnails and UI imagery that will be displayed at small size. The artifacts disappear at thumbnail scale.
  • Quality 95+ only for archival, or images that will be re-edited later. For anything served on the web, it's wasted bytes.

A note on the slider's wording: "quality" is a misnomer. It's really a "discard ratio." Quality 85 doesn't mean "85% as good as the original." It means "the encoder is allowed to discard information up to this aggressive threshold." A quality-85 JPG of a photograph is, to a human eye at normal size, indistinguishable from the original. The slider is calibrated to perception, not to a measurable percentage of fidelity.

How to convert PNG to JPG, step by step

The actual conversion takes seconds. The decisions around it take longer.

  1. Identify the image type. Photograph, scan, or screenshot of a photo? Good candidate for JPG. Logo, icon, UI screenshot, diagram, anything with transparency? Stop — JPG is the wrong format.
  2. If the image has transparency, decide on a background color. White is the default; pick something else only if you know where the image will be placed.
  3. Open the SynoxTools converter. Drag in the PNG, or click to browse.
  4. Pick JPG as the output. Set the background color (the converter flattens the alpha onto it for you). Set quality — default 85 is right for almost everything.
  5. Convert. The file is re-encoded in your browser, no upload happens.
  6. Download the result. Verify it looks right at 100% zoom before you delete the original PNG.

For one image, the whole thing takes under ten seconds. The verification step is the part people skip and regret.

Batch conversion: when you have a folder, not a file

You came back from a trip with 200 phone photos, all saved as PNG because some app exported them that way. Each is 8–15 MB. You need them as JPGs to put them on a website or email them. Doing that one-by-one is not a real workflow.

The SynoxTools batch converter handles this. Drag in all 200 PNGs, pick JPG as the output, set quality to 85, set the background color if any of them have transparency, hit Convert. Each file is processed in turn in a Web Worker — the main thread stays responsive, the UI doesn't freeze — and the results are bundled into a single ZIP for download.

A few practical notes on batches:

  • Memory matters. A 4000×3000 PNG decodes into a ~48 MB pixel buffer. Doing that for 200 images simultaneously would crash the tab. A good batch tool processes one image at a time (or a small queue), releases the buffer between images, and never holds more than a handful in memory.
  • Pick one quality setting for the whole batch. You can tune per-image, but for 200 files that's a bad use of time. Pick 85, run the batch, spot-check three images, adjust if needed.
  • Mixed-content batches are risky. If the folder has both photos and logos, the logos will come out worse (JPG artifacts on edges, lost transparency). Filter the folder first, or run the photos through PNG-to-JPG and leave the logos as PNG.
  • Keep the originals. Batch conversion is destructive in the sense that you can't recover the PNG from the JPG. Keep the source folder, write the JPGs to a new folder.

Why running it in the browser matters

There are two ways to convert an image: in your browser, or on a server. The difference is not just about speed.

When you use a server-side converter, you upload your image to someone else's computer. They process it, they send back the result. That means:

  • The image leaves your device.
  • It sits on their server for some period of time — minutes, days, sometimes longer.
  • It's subject to their logging, their retention policy, their security.
  • If the image contains anything sensitive — a photo of a document, a screenshot of a private conversation, a passport scan — that sensitive content is now on a third-party server.

Browser-based conversion is different. The browser downloads the page once, then all the work happens locally. The image is read into memory, decoded by the browser's image pipeline, drawn onto a canvas, re-encoded as JPG, and offered back to you as a download. The bytes never leave your device. No upload, no server processing, no retention policy, no security surface beyond the browser itself.

For most images this distinction is academic. For anything sensitive — ID scans, medical photos, business documents, anything you wouldn't put on a public link — it's the only sane choice. It's also faster (no upload latency) and works offline once the page is loaded.

The trade-off is that the browser has finite memory. A server pipeline can process a 200-megapixel image with no problem; a browser tab will run out of memory somewhere around 50–100 megapixels depending on the device. For normal photos and graphics, this is never an issue.

A quick decision rule

When someone hands you a PNG and asks "should I make this a JPG?", the answer fits in three questions:

  1. Is it a photograph? If no — keep PNG.
  2. Does it have transparency that needs to stay transparent? If yes — keep PNG (or convert to WebP, which supports alpha and is smaller).
  3. Will it be edited again? If yes — keep PNG as the master; export to JPG only at the final step.

If the answer to all three is "no," convert to JPG at quality 85, flatten transparency onto white if any exists, and you'll get a file 5–15× smaller that looks identical at normal viewing size. Keep the original PNG somewhere — storage is cheap, originals aren't.