Remove a logo or watermark from video, in your browser

What delogo actually does — and what it cannot do

Start with the honest part, because most pages on this subject skip it: nothing can recover what was behind a logo. Those pixels were overwritten before you ever received the file. Every tool that claims to “remove” a watermark is really doing one thing — inventing plausible replacement pixels from the ones nearby.

FFmpeg’s delogo filter invents them in a specific, knowable way. For every pixel inside the rectangle you define, it looks at exactly four pixels: the one immediately left of the box on the same row, the one immediately right of it, the one immediately above on the same column, and the one immediately below. It averages those four, weighting each by the inverse of its distance, so near edges count for more than far ones.

That single design decision explains everything about how the filter behaves:

• Flat backgrounds vanish perfectly. If all four sampled pixels are the same colour, the average is that colour. A logo over a solid lower-third bar or a clear sky disappears without a trace.
• Gradients survive well. A smooth left-to-right or top-to-bottom ramp is exactly what inverse-distance interpolation reconstructs, because the underlying signal really is linear between the edges.
• Detail becomes a smear. Four edge pixels cannot describe a face, a brick wall or foliage. You get a soft rectangular patch that reads as damage. This is not a bug in the filter or a setting you have got wrong — it is the ceiling of the method.

The tool above implements the same algorithm, pixel for pixel, which is why the preview is trustworthy: what you see on the frame is what every frame will get.

The four parameters, and the mistake almost everyone makes

The filter takes four integers:

The mistake is scale. These numbers are in source pixel space — the video’s real dimensions. If you measured the logo on a preview that was displayed at 640 pixels wide but the file is actually 1920 wide, every value is out by a factor of three and the filter will blur a rectangle of empty sky in the wrong corner. The tool above derives the numbers from the real frame size, which is the entire reason it is worth using over a ruler and a screenshot.

The origin is the top left, not the bottom left. If your box appears vertically mirrored, that is why.

Make the box slightly larger than the logo

This is the difference between a clean result and an obvious one, and it follows directly from how the filter works. delogo samples the ring of pixels immediately outside your rectangle. Almost every real logo has an anti-aliased or semi-transparent fringe a few pixels wide. If your box edge lands on that fringe, the fringe becomes the source material, and the filter dutifully spreads a ghost of the logo’s own colour across the whole region.

Pad by three to five pixels on every side, more if the logo has a drop shadow or a glow. You lose nothing: the padding region is background, and interpolating background from background is a no-op.

The region cannot touch the frame edge

Because the sampling ring sits one pixel outside the rectangle, a region flush against the frame boundary has nothing to read. FFmpeg requires:

x >= 1
y >= 1
x + w <= width  - 1
y + h <= height - 1

This is not a soft constraint that degrades gracefully. Violate it and FFmpeg refuses the job outright:

[Parsed_delogo_0 @ ...] Logo area is outside of the frame.

A watermark genuinely pinned to the corner is therefore the awkward case. Inset by one pixel and accept that the outermost row of the logo survives as a hairline against the frame border, or crop the frame first and lose that row entirely. The tool above clamps your selection into the legal range automatically, which is why a box you drag right off the edge still produces a valid command.

One further trap on this filter: delogo does not accept the usual iw / in_w constants, and inside a delogo expression w refers to the logo width rather than the frame width. Anchoring a region to the right-hand edge has to be arithmetic you do yourself.

Verify on one frame before committing to the file

Rendering a ten-minute video to discover the box was in the wrong place is a waste of several minutes. Pull a single frame instead:

# Grab the frame at 00:00:05 as a PNG
ffmpeg -ss 5 -i input.mp4 -frames:v 1 before.png

# Same frame, with the filter applied
ffmpeg -ss 5 -i input.mp4 -vf "delogo=x=1640:y=60:w=210:h=74" -frames:v 1 after.png

Open the two side by side. Iterate on the numbers there — it costs a fraction of a second per attempt — and only then run the whole file.

Logos that move, or that are only there some of the time

A broadcast bug that fades in for the first thirty seconds does not need the filter applied to the whole runtime. Every FFmpeg filter accepts enable, which takes a timeline expression:

# Only between 5s and 30s
ffmpeg -i input.mp4 -vf "delogo=x=1640:y=60:w=210:h=74:enable='between(t,5,30)'" -c:a copy out.mp4

# Two logos at once: chain the filters
ffmpeg -i input.mp4 -vf "delogo=x=40:y=40:w=180:h=60,delogo=x=1640:y=960:w=210:h=74" -c:a copy out.mp4

A logo that genuinely travels around the frame is beyond a single static rectangle. That is the problem multi-delogo exists to solve — it lets you keyframe the region over time — and it is the right tool if the watermark moves.

Whether to do this in the browser or in FFmpeg

For one clip, dragging a box is faster than measuring one. For forty clips with the same overlay in the same position, take the command this page generates and put it in a loop:

for f in *.mp4; do
  ffmpeg -i "$f" -vf "delogo=x=1640:y=60:w=210:h=74" -c:a copy "clean/$f"
done

The quality cost nobody mentions

Applying any filter means decoding and re-encoding the video, so you pay one generation of compression loss across the entire picture — not just inside the box. The audio does not need to suffer: -c:a copy passes the original audio stream through untouched, which is why it is in every command above.

If the source is already heavily compressed, encode the output generously. Starving a re-encode to save a few megabytes adds blocking artefacts that are far more visible than the patch you were trying to hide. If size is the actual constraint, solve that deliberately with a target-size pass rather than by guessing at a quality setting.

One thing worth saying plainly

This is built for footage you own or are licensed to edit — your own superseded branding, a station bug on your own recording, a client’s old logo on archive material you are refreshing. Stripping someone else’s watermark from content you have no rights to is copyright infringement, and a filter that averages four pixels does not change that.