Free Background Remover

A neural network that runs in your browser tab, not on somebody's server

Most background removers upload your photo, process it on a GPU somewhere, and send back a cutout. This one does not, because there is nothing to upload to. It loads u2netp.onnx, a compact version of the U^2-Net salient object detection model, and runs it through onnxruntime-web inside the page using WebAssembly.

The first cutout on a fresh visit is slower because the model weights download once and then cache in the browser. Every run after that skips straight to inference. Close the tab and the photo, the mask and the output are gone.

What actually gets composited

The output you download is three things drawn on top of each other in a fixed order. Understanding the stack explains most of the controls.

One compose() function draws this stack, and it's the same function used for the live preview and the final export. That's deliberate. What you see on screen comes from the identical code path that produces the file, so there's no category of bug where the preview and the download disagree.

The pipeline, left to right

The decontamination step

Cutouts made from a matte alone tend to carry a faint ring of the old background colour, dark hair against a white wall keeps a grey fringe, a subject on green keeps a green tint. This step estimates what the background colour was near each edge pixel and algebraically removes its contribution, so the leftover colour belongs to the subject rather than the wall behind it. Pixels with no clean background nearby, a subject touching the frame edge for instance, fall back to a global background average.

The one slider

Edge cleanup is a single 0 to 1 value that drives three things at once rather than exposing three separate sliders: how aggressively the alpha curve clamps weak and strong pixels to 0 and 1, how much colour decontamination strength and radius to apply, and, only near the top of the range, a small feather blur on the alpha channel. Balanced settings favour the curve and decontamination; pushing toward Maximum adds feathering for a softer edge on hair and fur, at some cost to crispness on hard product edges.

Two models, because one size doesn't fit every photo

The tool ships two versions of the same architecture. Fast is u2netp, 4.4 MB, and is the default for everyone. High quality is the full u2net, 167 MB, about 38 times heavier. Same network shape, more parameters, better at holding onto fine detail: stray hair, low contrast edges, subjects that don't stand cleanly apart from their background.

Fast is right most of the time and there's no reason to make everyone pay a 167 MB download for photos that don't need it. High quality is there when a result comes back rough, picked once per session and cached after that, same as Fast. The tradeoff is real: a bigger download the first time it's selected, and a slower run on every image afterward, since there's more network to push through WebAssembly. The download progress bar and cancel button below exist mainly because of this option, a 167 MB fetch on a slow connection is not something you want to sit through with no feedback and no way out.

Why a logo keeps its caption sometimes and loses it other times

U^2-Net is a salient object detector. It was trained to find the one thing in a frame that draws the eye, not to separate "everything that isn't background" from the background. Point it at an emblem sitting above a line of text, or a chart with a small logo in the corner, and it will often keep the emblem and score the text or the bars as background, because they're thinner, lower contrast, and don't read as a single object the way the model was trained to prioritise.

That's not a bug in this tool, it's what the model is for, and no amount of slider tuning fixes it because the mask genuinely doesn't cover those pixels. Switching to the High quality model helps somewhat, since it holds detail better, but it's the same kind of model underneath and can still drop a low-contrast secondary element entirely.

The real fix here is the Keep all elements toggle. When it's on, the tool samples a ring of pixels around the border of the image to estimate the background colour, then builds a second mask from plain colour distance: any pixel that's clearly not that background colour is treated as foreground, independent of whatever the model thought. The final matte is the maximum of the two masks, so the model still supplies the clean, shaped edge around the main subject, and the colour mask fills in whatever the model dropped elsewhere in the frame. If the border sampling finds the background isn't actually flat, a busy photo bleeding to the frame edge, colour distance would just tag half the scene as foreground, the tool skips the merge and falls back to the model's mask alone rather than making things worse. This is why the toggle is off by default and works best on the kind of graphic it was built for: a logo, a wordmark, a chart, or a diagram sitting on a solid or near-solid background, not a photograph.

Controls, and what each one actually changes

Progress and cancelling

Model downloads are read through a streamed fetch() rather than handed straight to the ONNX runtime, so actual bytes received against the model's known size drive the progress bar, not a guess. Cancel aborts that fetch immediately through an AbortController. Once the model has downloaded and inference starts, cancel stops the pipeline at the next checkpoint, between segmentation and mask upscaling, between upscaling and the optional colour merge, rather than killing the run mid-frame, since a single WebAssembly inference call can't be interrupted once it starts. In practice that means Cancel is closest to instant during the download, which is also the slow part on the High quality model, and takes effect within a beat once inference is underway.

Why local inference matters here

Background removal is one of the few image tasks where the privacy argument is concrete rather than theoretical. The photos people cut out are ID photos, internal product mockups, medical documentation, family pictures. A server side tool means those files sit in someone's request logs and object storage, governed by a retention policy you did not read.

Running the model client side removes that question entirely. The tradeoff is honest: WebAssembly inference on a single thread is slower than a datacentre GPU, and the model has to download once. For a handful of images that's a good trade. For a batch of five hundred it isn't, and a server pipeline is the right tool.

Where the work happens

Model and runtime

• rembg is the source of the u2netp.onnx weights this tool loads, released under the MIT licence.
• U^2-Net is the salient object detection architecture the model is built on, if you want the underlying research. u2netp is the pruned, lighter variant, sized for a browser rather than a server.
• ONNX Runtime Web executes the model as WebAssembly. It's the same runtime used server side, compiled for the browser, MIT licensed.
• toBlob for the export step and its quality parameter behaviour across formats.

Where cutouts get used

Product photos for a marketplace listing that demands a white background, headshots for a company directory that need to match each other, isolating a logo from a scanned letterhead, building a sticker pack from phone photos, or replacing a cluttered room behind a property photo before it goes to a client. The local processing also makes it usable for anything with a confidentiality question attached, which server based tools quietly rule out.