Remove a Watermark and Keep Transparency: Does the PNG Stay See-Through? (Tested)

Yes — as long as you export as PNG. This is a browser tool, so when you load an image the page keeps all four channels: red, green, blue, and the alpha (transparency) channel. The watermark-removal engine only rewrites the color of the pixels you paint; it never writes to the alpha channel. We proved this two independent ways: by reading the app’s own code, and by running the exact inpainting function the tool uses on a 90,000-pixel RGBA test image whose alpha held three different values (fully transparent, semi-transparent, and opaque). After removal, the alpha channel was byte-for-byte identical — a maximum difference of 0 across all 90,000 pixels. The default export is PNG, which preserves transparency. The one catch: if you switch the format selector to JPEG, the transparency is flattened to black, because JPEG simply has no alpha channel. Keep it on PNG and your transparent background survives the removal.

How we checked it (source code + a real run)

We didn’t guess. The tool is a static client-side page, so its behavior is readable in the source, and the engine it uses is plain JavaScript we can run directly. Two facts from app.js settle the transparency question before we ran anything:

Your image is loaded with its alpha channel. On upload the page grabs the whole canvas with original = ctx.getImageData(0, 0, W, H); (app.js line 36). getImageData returns an RGBA buffer, so the transparency you loaded is present in memory.
The engine only repaints color. Inside the inpaint loop, the code writes out[po], out[po+1], out[po+2] — red, green, blue — of the pixels you painted, and then hands the result back as new ImageData(buf, W, H) (lines 219–246). It never assigns out[po+3], the alpha byte.

To prove the engine behaves that way in practice, we ran the identical inpaint function on a 300×300 (90,000-pixel) RGBA image we built: a fully transparent left half with a semi-transparent watermark painted on it, and an opaque right half with an opaque watermark. We painted both watermarks as the removal mask and ran the engine. Every number below is from that run.

Finding 1: the alpha channel is never touched

Across all 90,000 pixels, the difference between the alpha value before and after removal was 0. Not “close to zero” — exactly zero. We broke it down by the original transparency of each region to make sure nothing slipped through:

Region (original alpha)	Pixels	Alpha after removal	Preserved?
Fully transparent (alpha 0)	38,839	0	Yes
Semi-transparent watermark (alpha 128)	6,161	128	Yes
Opaque photo content (alpha 255)	45,000	255	Yes

The engine did real work: of the 12,322 pixels inside the painted mask, all 12,322 had their color changed (that is the watermark being removed), while 0 pixels outside the mask changed at all. So the color was rebuilt where you asked, and the transparency was left exactly where it was.

Finding 2: a watermark on a transparent area leaves a clean see-through hole

This is the practical payoff. Say your PNG is a logo or a sticker on a transparent canvas, and the watermark sits over a part that was empty. When you paint and remove it, the engine fills the color of those pixels — but because their alpha is 0, that filled color is invisible. The result is a transparent hole where the watermark was, not a gray or black patch. In our test the 38,839 fully-transparent pixels stayed fully transparent even where the mask overlapped them. In other words, removing a watermark from a see-through region does not “paint over” your transparency; the layer stays cut-out.

The one catch: switch to JPEG and transparency is gone

The default export is PNG, and PNG carries the alpha channel, so transparency survives. But the format selector lets you pick JPEG, and the export line reads var type = fmt.value === 'jpeg' ? 'image/jpeg' : 'image/png'; (app.js line 255). JPEG has no concept of transparency: when a canvas is saved as JPEG, every transparent pixel is composited onto a solid background — in a browser that background is black. We confirmed this in a test by flattening our RGBA image to JPEG: the previously transparent pixels became black. So if your source had a transparent background and you export as JPEG, you get a black rectangle behind your image and the cut-out is lost. The fix is trivial: leave the selector on PNG.

This is not a quirk of this tool — it is how the PNG and JPEG formats work — but it is the single way you can accidentally throw away transparency while removing a watermark.

Practical guidance

Keep the export on PNG. That is the default and it preserves the alpha channel exactly. Only switch to JPEG if a destination refuses PNG and you don’t need transparency.
A watermark over a transparent area is safe to remove. The cut-out stays see-through; you don’t trade transparency for a clean edit.
Remember only the mark is rebuilt. As on any surface, the pixels under an opaque watermark are reconstructed by inpainting. On a busy opaque background that fill can leave a soft patch — but your transparency is unaffected.
Re-export, don’t re-save. If you ever open the result in another editor, save it back out as PNG, not JPEG, or the alpha is flattened on the next save.

For how the same engine behaves on other surfaces, our text test, logo test, and resolution test show what actually changes and what doesn’t when you remove a mark.

FAQ

Does removing a watermark keep the PNG’s transparent background? Yes, on a PNG export. We ran the tool’s exact inpainting engine on a 90,000-pixel RGBA image and the alpha channel came back with a maximum difference of 0.

What if my watermark is over a transparent area? It leaves a clean see-through hole. The engine fills color but the alpha stays 0, so the edit is invisible against transparency.

Can I export as JPEG and keep transparency? No. JPEG has no alpha channel, and a browser composites transparent pixels onto black when saving JPEG. Use PNG to keep transparency.

Does the tool flatten transparency while processing? No. The canvas holds the full RGBA buffer the whole time, and the engine only rewrites color bytes, never the alpha byte.

Is the rest of the image changed? No. Outside the area you paint, every pixel — color and alpha — is unchanged. Only the painted mark is reconstructed.