# Image Watermark Remover — Batch Remove Logos & Stamps (`muhammadafzal/ai-image-watermark-remover`) Actor

Remove watermarks, logos and date stamps from up to 20 image URLs per run via API. Get JPG, PNG or WebP files plus before/after previews. USD 0.05 per image.

- **URL**: https://apify.com/muhammadafzal/ai-image-watermark-remover.md
- **Developed by:** [Muhammad Afzal](https://apify.com/muhammadafzal) (community)
- **Categories:** AI, Automation, Developer tools
- **Stats:** 2 total users, 2 monthly users, 84.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $40.00 / 1,000 cleaned images

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Image Watermark Remover — Batch Remove Logos & Stamps

Image Watermark Remover takes up to 20 public JPG, PNG, or WebP image URLs per run, detects text watermarks, logos, date stamps, and caption strips, fills them in with inpainting, and returns a download link for each cleaned image plus a before/after preview. It is built for developers and teams who need to clean their own images in bulk through an API, and it costs USD 50 per 1,000 cleaned images (USD 0.05 per image) on the FREE tier, plus a USD 0.005 start fee per run.

### How do I remove watermarks from images in bulk?

Pass a list of image URLs and the Actor processes them in parallel (two at a time by default, up to four with `maxConcurrency`), saves each cleaned file in the run's key-value store, and writes one dataset row per image with its download URL:

```json
{
  "imageUrls": [
    "https://example.com/products/mug-front.jpg",
    "https://example.com/products/mug-side.jpg"
  ],
  "detectionMode": "corner_bottom_right",
  "inpaintMethod": "hybrid",
  "maskDilation": 5,
  "outputFormat": "png",
  "createComparison": true
}
```

For more than 20 images, split them across several runs or call the Actor from a loop in your own code. Images must be publicly reachable over HTTP(S); private network addresses, localhost, URLs with credentials, and animated GIFs are rejected.

### Which detection mode should I use?

Use the mode that matches where the watermark sits; it is faster and safer than automatic detection.

- `corner_bottom_right`, `corner_bottom_left`, `corner_top_right`, `corner_top_left`, `all_corners`: logos, photographer credits, camera date stamps, and channel badges in corners.
- `bottom_banner`: caption or ticker strips along the bottom edge.
- `center`: large preview marks across the middle.
- `manual_boxes`: exact boxes in pixels (`{x, y, width, height}`) or percentages (`{xPercent, yPercent, widthPercent, heightPercent}`) when you know the position, for example a batch of images with the same stamp.
- `auto` (default when an API call omits `detectionMode`; the Console form starts on `corner_bottom_right`): scans the four corners, the bottom strip, and the center for the strongest text- or logo-like strokes and fills them.
- `full_image`: applies the same scan to the whole image.

Detection uses classical computer vision (edge, contrast, and stroke analysis), not a generative AI model, and it cannot tell whether a watermark exists. In `auto` and `full_image` modes it always marks the most contrasting strokes, so on a photo without a watermark it can still touch real detail. In a single-region mode, if nothing stands out, the whole region is filled. Check the before/after preview, and use `maskDilation` 7 or higher for watermarks with soft shadows or glow.

Three fill methods are available: `hybrid` (default; edge-preserving fill plus grain matching to avoid smooth smudges), `telea`, and `ns`.

### What does the image watermark remover return?

One dataset row per cleaned image:

| Field | What it tells you |
|---|---|
| `sourceUrl` | The input image URL |
| `cleanedImageUrl`, `cleanedImageKey` | Download URL and key of the cleaned image in the key-value store |
| `comparisonImageUrl`, `comparisonImageKey` | Side-by-side before/after JPEG, or `null` when disabled |
| `originalWidth`, `originalHeight`, `outputWidth`, `outputHeight` | Dimensions before and after the optional downscale |
| `inputBytes`, `outputBytes` | File sizes in bytes |
| `watermarkDetected`, `detectedRegionsCount` | Whether any region was filled, and how many |
| `inpaintedPixels`, `inpaintedPercentage` | How much of the image was reconstructed |
| `detectionModeUsed`, `inpaintMethodUsed`, `outputFormat` | The settings applied |
| `processingTimeMs`, `sha256` | Processing time and a hash of the cleaned file |
| `base64Data` | A `data:image/...` string when `includeBase64` is on, otherwise `null` |

An `OUTPUT` record summarizes the run: status, requested, delivered, failed, warnings, and result links.

This row is from the Store prefill run (2026-10-27): a beach photo with an orange camera date stamp in the bottom-right corner, cleaned with `corner_bottom_right`. The stamp was filled completely and nothing outside the corner was touched (8 regions, 0.67% of the pixels):

```json
{
  "sourceUrl": "https://res.cloudinary.com/demo/image/upload/w_1200/l_text:Arial_36_bold:2024-06-18,co_rgb:F57C00,g_south_east,x_28,y_22/samples/landscapes/beach-boat.jpg",
  "cleanedImageUrl": "https://api.apify.com/v2/key-value-stores/0zOFLREzJmSUeMVfL/records/cleaned-0b2fcc38c368439f.jpg",
  "comparisonImageUrl": "https://api.apify.com/v2/key-value-stores/0zOFLREzJmSUeMVfL/records/comparison-0b2fcc38c368439f.jpg",
  "cleanedImageKey": "cleaned-0b2fcc38c368439f.jpg",
  "comparisonImageKey": "comparison-0b2fcc38c368439f.jpg",
  "originalWidth": 1200,
  "originalHeight": 900,
  "outputWidth": 1200,
  "outputHeight": 900,
  "inputBytes": 173058,
  "outputBytes": 212680,
  "watermarkDetected": true,
  "detectedRegionsCount": 8,
  "inpaintedPixels": 7276,
  "inpaintedPercentage": 0.674,
  "detectionModeUsed": "corner_bottom_right",
  "inpaintMethodUsed": "hybrid",
  "outputFormat": "jpeg",
  "processingTimeMs": 336,
  "sha256": "0b2fcc38c368439f08d2d84650d2df30e94bd8f8fc96d15ebf27c2ecf060b6d1",
  "base64Data": null
}
```

### How much does it cost to remove watermarks from images?

Pay-per-event prices, active since October 6, 2026, with no change scheduled. Apify platform usage is included.

| Event | FREE | BRONZE | SILVER | GOLD | PLATINUM | DIAMOND |
|---|---:|---:|---:|---:|---:|---:|
| `apify-default-dataset-item`: one cleaned image delivered (primary) | $0.05 | $0.04875 | $0.0475 | $0.04 | $0.04 | $0.04 |
| `apify-actor-start`: run start | $0.005 | $0.005 | $0.005 | $0.005 | $0.005 | $0.005 |

The start fee is charged once per started GB of allocated memory; the default 1,024 MB run pays one start event.

- **One image, FREE:** $0.005 + 1 × $0.05 = **$0.055**.
- **A full batch of 20 images, GOLD:** $0.005 + 20 × $0.04 = **$0.805**.

1,000 images take 50 runs of 20, which is 50 × ($0.005 + 20 × $0.05) = **$50.25** on FREE. Each image that is saved to the dataset is charged once, including images where nothing was filled; images that fail to download or decode are listed as warnings in `OUTPUT` and not charged. A run with both `saveToKeyValueStore` and `includeBase64` turned off is rejected before any image is processed, so only the start fee applies. Duplicate URLs in one run are processed and charged once, and when your maximum charge covers fewer images than you sent, the extra images are skipped, listed in `OUTPUT.warnings`, and not charged.

### When should I use it, and when not?

Use it to clean your own images, or images you are licensed to edit, in bulk from code or an automation: product photos with an outdated supplier or brand stamp, your own photos with a burned-in camera date, or screenshots with a logo you are allowed to remove.

Do not use it to strip copyright notices from other people's photos, stock previews, or listings you do not own. It does not process video, animated GIFs, SVG, or PDF, and it cannot rebuild a face or intricate detail fully hidden under a large watermark. For restoring old or damaged photos use [Vintage Photo Restorer](https://apify.com/muhammadafzal/vintage-photo-restorer), and for reading text in images use [Image OCR Scraper](https://apify.com/muhammadafzal/image-ocr-scraper).

### Use it from an AI assistant

Image Watermark Remover works from Claude, ChatGPT, Cursor, or any MCP client through Apify's MCP server. Add it as a single tool with `https://mcp.apify.com/?tools=muhammadafzal/ai-image-watermark-remover`, then ask, for example: "Remove the date stamp in the bottom-right corner of these three product photos and give me PNG download links."

### How do I run it from the API?

JavaScript (`apify-client`):

```javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('muhammadafzal/ai-image-watermark-remover').call({
  imageUrls: ['https://example.com/products/mug-front.jpg'],
  detectionMode: 'corner_bottom_right',
  createComparison: true,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items[0]?.cleanedImageUrl);
```

Python (`apify-client` 3.x):

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")
run = client.actor("muhammadafzal/ai-image-watermark-remover").call(run_input={
    "imageUrls": ["https://example.com/products/mug-front.jpg"],
    "detectionMode": "corner_bottom_right",
    "outputFormat": "png",
})
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item["cleanedImageUrl"], item["comparisonImageUrl"])
```

For n8n, Make, or Zapier flows, set `includeBase64: true` to get the cleaned image inline in each row.

### Limits and reliability

- 1–20 images per run, up to 25 MB and 36 megapixels each, at least 32 × 32 pixels. Downloads time out after 30 seconds.
- `maxDimension` (512–6,000, default 4,096) downscales larger images before processing; smaller images are never upscaled.
- Results depend on the background: fills work best over sky, walls, or even texture, and marks over faces, fine text, or busy patterns can leave visible traces.
- An image that fails to download or decode does not stop the run; it is listed in `OUTPUT.warnings`. If no image is delivered at all, the run ends as failed and only the start fee is charged.

### FAQ

#### Is it legal to remove a watermark?

It depends on who owns the image. Removing a watermark from your own image, or one you are licensed to edit, is generally fine; removing copyright information from someone else's work can break copyright law and site terms. You are responsible for having the right to edit every image you submit.

#### Is this an AI watermark remover?

It is an automatic watermark remover that uses classical computer-vision detection and inpainting, not a generative AI model. That keeps it fast and predictable, but it does not invent new detail.

#### Can it remove a logo from an image?

Yes, when the logo sits in a corner, the bottom strip, or the center, or when you give its position with `manual_boxes`.

#### Will it change parts of my image without a watermark?

In `auto` and `full_image` modes it can, because it always fills the strongest strokes it finds. Use a corner mode or `manual_boxes` to limit changes to one area.

#### Does it remove watermarks from video?

No. It processes still JPG, PNG, and WebP images only.

#### Where do I download the cleaned images?

From `cleanedImageUrl` in each dataset row, or from the run's key-value store under keys starting with `cleaned-`.

### Related Actors

- [Vintage Photo Restorer](https://apify.com/muhammadafzal/vintage-photo-restorer): restore old, faded, or damaged photos.
- [Image OCR Scraper](https://apify.com/muhammadafzal/image-ocr-scraper): extract text from images.

### Legal and responsible use

Submit only images you own or are licensed to modify. Do not use this Actor to remove watermarks, signatures, or other copyright information from third-party content, and respect the terms of the sites that host your images.

Last verified: 2026-10-27

# Actor input Schema

## `imageUrls` (type: `array`):

Public HTTPS URLs of JPG, PNG, or WebP images to clean. Provide 1–20 URLs. The prefilled sample is a beach photo with a camera date stamp in the bottom-right corner. Private IP ranges, localhost, credentials, and animated GIFs are rejected.

## `detectionMode` (type: `string`):

Use a corner, bottom_banner, or center mode when you know where the watermark sits; it is faster and changes nothing else. 'auto' scans the corners, bottom strip, and center and can also alter real detail on photos without a watermark. 'manual_boxes' uses your coordinates. Example: corner_bottom_right.

## `inpaintMethod` (type: `string`):

Algorithm used to reconstruct background under watermarks. 'hybrid' combines Navier-Stokes contour continuation with texture noise synthesis to avoid blurry smudges. 'telea' uses Fast Marching method for smooth gradients. 'ns' uses Navier-Stokes fluid dynamics.

## `maskDilation` (type: `integer`):

Number of pixels to expand the watermark mask. Expanding the mask slightly ensures antialiased semi-transparent text edges and halos are completely eliminated. Enter 1–25; default is 5.

## `outputFormat` (type: `string`):

Image format of the cleaned output file. JPEG is compact, PNG is lossless, and WebP offers high compression quality; default is JPEG.

## `quality` (type: `integer`):

Encoding compression quality from 60 to 100 for JPEG or WebP output. Default is 92; ignored for PNG.

## `maxDimension` (type: `integer`):

Caps the longest image side in pixels before inpainting. Enter 512–6000; default is 4096. Smaller images are never upscaled.

## `createComparison` (type: `boolean`):

Create and save a side-by-side Before/After comparison JPEG in the Key-Value Store alongside the cleaned image.

## `includeBase64` (type: `boolean`):

Include a data:image/... base64 string directly in each dataset record for seamless low-code integration in n8n, Make, or Zapier. Keep this or 'Save images to Key-Value Store' on; a run with both off is rejected before any image is processed.

## `saveToKeyValueStore` (type: `boolean`):

Save cleaned image files and comparison previews to the Actor Key-Value Store with public download URLs. Keep this or 'Include base64 in dataset' on; a run with both off is rejected before any image is processed.

## `maxConcurrency` (type: `integer`):

Number of images to process simultaneously. Enter 1–4; default is 2.

## `manualBoxes` (type: `array`):

Custom bounding boxes when detectionMode is set to 'manual_boxes'. Enter absolute pixel coordinates ({x, y, width, height}) or percentages ({xPercent, yPercent, widthPercent, heightPercent}).

## Actor input object example

```json
{
  "imageUrls": [
    "https://res.cloudinary.com/demo/image/upload/w_1200/l_text:Arial_36_bold:2024-06-18,co_rgb:F57C00,g_south_east,x_28,y_22/samples/landscapes/beach-boat.jpg"
  ],
  "detectionMode": "corner_bottom_right",
  "inpaintMethod": "hybrid",
  "maskDilation": 5,
  "outputFormat": "jpeg",
  "quality": 92,
  "maxDimension": 4096,
  "createComparison": true,
  "includeBase64": false,
  "saveToKeyValueStore": true,
  "maxConcurrency": 2
}
```

# Actor output Schema

## `results` (type: `string`):

Schema-validated metadata and direct download URLs for every processed image.

## `cleanedImages` (type: `string`):

Key-value-store records containing the watermark-free images.

## `comparisons` (type: `string`):

Key-value-store records containing side-by-side comparison previews.

## `summary` (type: `string`):

Counts, status, warnings, and result links for this run.

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "imageUrls": [
        "https://res.cloudinary.com/demo/image/upload/w_1200/l_text:Arial_36_bold:2024-06-18,co_rgb:F57C00,g_south_east,x_28,y_22/samples/landscapes/beach-boat.jpg"
    ],
    "detectionMode": "corner_bottom_right"
};

// Run the Actor and wait for it to finish
const run = await client.actor("muhammadafzal/ai-image-watermark-remover").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "imageUrls": ["https://res.cloudinary.com/demo/image/upload/w_1200/l_text:Arial_36_bold:2024-06-18,co_rgb:F57C00,g_south_east,x_28,y_22/samples/landscapes/beach-boat.jpg"],
    "detectionMode": "corner_bottom_right",
}

# Run the Actor and wait for it to finish
run = client.actor("muhammadafzal/ai-image-watermark-remover").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "imageUrls": [
    "https://res.cloudinary.com/demo/image/upload/w_1200/l_text:Arial_36_bold:2024-06-18,co_rgb:F57C00,g_south_east,x_28,y_22/samples/landscapes/beach-boat.jpg"
  ],
  "detectionMode": "corner_bottom_right"
}' |
apify call muhammadafzal/ai-image-watermark-remover --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,muhammadafzal/ai-image-watermark-remover"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/RFu0opEedttV7RKDy/builds/kTtXXVuCy8iWoHiZc/openapi.json