# Image & Video Anonymizer — Blur Faces & License Plates (GDPR) (`adorable_partial/image-anonymizer`) Actor

Automatically blur faces and license plates in photos and videos for GDPR/LGPD compliance. Bulk image or video URLs in, anonymized JPEG/MP4 out. Removes EXIF/GPS metadata. Files are never sent to third-party AI services.

- **URL**: https://apify.com/adorable\_partial/image-anonymizer.md
- **Developed by:** [Leandro Zanatta](https://apify.com/adorable_partial) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.50 / 1,000 image anonymizeds

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 & Video Anonymizer — Blur Faces & License Plates (GDPR / LGPD)

Automatically **blur faces and license plates** in photos **and videos**, in bulk. Paste image or video links and get back anonymized files, ready to publish, share or use for AI training. **EXIF, GPS and device metadata is always removed.**

![Before and after: license plate blurred in a street video](https://api.apify.com/v2/key-value-stores/ZFfzEl3aKqo5Yfkga/records/demo.png?signature=v6hzPQIwULAh9UHuMyqX)

▶️ [Watch the animated video demo](https://api.apify.com/v2/key-value-stores/ZFfzEl3aKqo5Yfkga/records/demo.gif?signature=1p14ArafECkWoVwnMxhVt)

*Demo footage: "Roncesvalles Ave crossing at Galley Ave, PXO Type A lights flashing, July 2026" by [Qviri](https://commons.wikimedia.org/wiki/File:Roncesvalles_Ave_crossing_at_Galley_Ave,_PXO_Type_A_lights_flashing,_July_2026.webm), [CC BY-SA 4.0](https://creativecommons.org/licenses/by-sa/4.0/), via Wikimedia Commons. Edited: anonymized with this Actor; the demo image and GIF are shared under the same license.*

- 🙂 **Face blurring**: detects frontal and slightly turned faces, including small faces in crowds
- 🚗 **License plate blurring**: tuned on real Brazilian (Mercosur) road-camera footage, including night/infrared images
- 🎨 **Blur, pixelate or black box**, with adjustable padding
- 🧹 **Strips EXIF/GPS metadata** from every output image
- 🔒 **Privacy by design**: plates are only located, never read or stored, and images are processed inside the Actor and never sent to third-party AI services
- 🎥 **Video**: every frame anonymized, output as H.264 MP4 that plays everywhere, original audio kept (or removed)
- 📦 **Bulk**: thousands of images or hours of video per run, with Google Drive and Dropbox links supported
- 💸 **Pay per image or per video minute**, and failed files are free

### Who is this for?

- **Real estate and property listings**: street photos with neighbours, passers-by and parked cars
- **Drone, dashcam, bodycam and CCTV footage**: inspections, mapping, fleet, insurance and security video shared with third parties
- **AI and computer-vision teams**: anonymize datasets before training or sharing them (GDPR/LGPD data minimisation)
- **Media, events and research**: publish crowd photos without identifiable bystanders
- **Marketplaces and classifieds**: hide plates on vehicle listings automatically

### How to anonymize images

1. Paste image URLs into **Image URLs** (JPEG, PNG, WebP, BMP, TIFF).
2. Choose what to hide (**faces**, **license plates**, or both) and how (**blur**, **pixelate** or **solid box**).
3. Click **Start**. The **Output** tab shows the anonymized images with counts of faces and plates hidden.

### How video works

Faces and plates are detected several times per second, and boxes are carried between detections so moving people and cars stay covered.

| Video mode | Detections per second | Price per started minute | Best for |
|---|---|---|---|
| Standard (default) | 5 | $0.25 | Street, real estate, drone and CCTV footage |
| Thorough | 10 | $0.45 | Fast motion, dashcams, night footage |

Use **Max minutes per video** to cap cost on long files. The output keeps the source resolution and frame rate.

### Input example

```json
{
  "imageUrls": ["https://example.com/street.jpg", "https://example.com/team.png"],
  "videoUrls": ["https://example.com/dashcam.mp4"],
  "videoQuality": "standard",
  "keepAudio": true,
  "blurFaces": true,
  "blurPlates": true,
  "method": "blur",
  "detectSmallFaces": false,
  "paddingPercent": 20,
  "outputFormat": "jpeg"
}
```

### Output example

```json
{
  "sourceUrl": "https://example.com/street.jpg",
  "outputUrl": "https://api.apify.com/v2/key-value-stores/.../records/anonymized-00001.jpg",
  "width": 1920,
  "height": 1080,
  "facesBlurred": 3,
  "platesBlurred": 2,
  "metadataRemoved": true,
  "faces": [{ "x1": 812, "y1": 240, "x2": 870, "y2": 312, "score": 0.93 }],
  "plates": [{ "x1": 1210, "y1": 760, "x2": 1290, "y2": 790, "score": 0.97 }]
}
```

Turn off **Include detection boxes** if you only need the images.

### Use it from your code or AI agent

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")
run = client.actor("adorable_partial/image-anonymizer").call(
    run_input={"imageUrls": ["https://example.com/street.jpg"], "method": "pixelate"}
)
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["outputUrl"], item["facesBlurred"], item["platesBlurred"])
```

It also works with **Make, Zapier, n8n**, webhooks and schedules, and as a tool for **AI agents** through the Apify MCP server.

### FAQ

**Is the blur reversible?**
No. Regions are heavily downsampled before blurring, so the original pixels cannot be recovered. For maximum safety, use **solid**.

**Does it read license plate numbers?**
No. It only finds where plates are. Nothing is read, logged or stored.

**Which plates are supported?**
The plate model was fine-tuned on Brazilian Mercosur and older Brazilian plates from road cameras. It also detects many other rectangular plates, but accuracy on other countries' formats has not been measured yet, so review critical images.

**Will it catch every face?**
It catches most visible faces, including small ones with **Detect small / distant faces** on. Faces in strong profile, heavily occluded or very blurry may be missed. Review images where a miss would be critical.

**Which video formats are supported?**
MP4, MOV, WebM, MKV, AVI and most other common formats, up to 4 GB per file. The output is always an H.264 MP4.

**Can something be missed in video?**
Plates heavily blurred by fast motion can slip through in single frames, even in Thorough mode. For critical footage, review a sample.

**Where are my images processed?**
Inside the Actor on the Apify platform. Images are not sent to any external AI API.

# Actor input Schema

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

Direct links to images (JPEG, PNG, WebP, BMP, TIFF). Public Google Drive and Dropbox share links are supported.

## `videoUrls` (type: `array`):

Direct links to videos (MP4, MOV, WebM, MKV, AVI...). Output is an H.264 MP4 with faces and plates blurred in every frame. Billed per started minute of video.

## `blurFaces` (type: `boolean`):

Detect and anonymize human faces.

## `blurPlates` (type: `boolean`):

Detect and anonymize vehicle license plates. Beta: some plates, especially non-European/Asian formats or plates at sharp angles, may be missed.

## `method` (type: `string`):

blur = strong irreversible blur, pixelate = mosaic blocks, solid = black box.

## `detectSmallFaces` (type: `boolean`):

Also scan an upscaled copy to catch tiny faces in crowds. Slower.

## `paddingPercent` (type: `integer`):

Enlarge each detected region by this percentage so hair, ears and plate frames are covered too.

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

Format of the anonymized images. All EXIF/GPS metadata is always removed.

## `jpegQuality` (type: `integer`):

Compression quality for JPEG and WebP output (higher = better quality, larger files).

## `includeDetections` (type: `boolean`):

Add the coordinates of every blurred face and plate to the results.

## `videoQuality` (type: `string`):

How often faces and plates are detected in videos. Boxes are carried between detections. Thorough catches fast-moving cars and people better and costs more.

## `keepAudio` (type: `boolean`):

Keep the original audio track (re-encoded to AAC). Turn off to remove voices and sounds.

## `maxVideoMinutes` (type: `integer`):

Only the first N minutes of each video are processed and billed.

## Actor input object example

```json
{
  "imageUrls": [
    "https://upload.wikimedia.org/wikipedia/commons/thumb/5/52/Car_from_Sankt_Gallen.jpg/1280px-Car_from_Sankt_Gallen.jpg"
  ],
  "blurFaces": true,
  "blurPlates": true,
  "method": "blur",
  "detectSmallFaces": false,
  "paddingPercent": 20,
  "outputFormat": "jpeg",
  "jpegQuality": 92,
  "includeDetections": true,
  "videoQuality": "standard",
  "keepAudio": true,
  "maxVideoMinutes": 60
}
```

# Actor output Schema

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

One item per image: link to the anonymized image and counts of blurred faces and plates.

## `images` (type: `string`):

The anonymized image files.

# 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://upload.wikimedia.org/wikipedia/commons/thumb/5/52/Car_from_Sankt_Gallen.jpg/1280px-Car_from_Sankt_Gallen.jpg"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("adorable_partial/image-anonymizer").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://upload.wikimedia.org/wikipedia/commons/thumb/5/52/Car_from_Sankt_Gallen.jpg/1280px-Car_from_Sankt_Gallen.jpg"] }

# Run the Actor and wait for it to finish
run = client.actor("adorable_partial/image-anonymizer").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://upload.wikimedia.org/wikipedia/commons/thumb/5/52/Car_from_Sankt_Gallen.jpg/1280px-Car_from_Sankt_Gallen.jpg"
  ]
}' |
apify call adorable_partial/image-anonymizer --silent --output-dataset

```

## MCP server setup

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

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/XHwUSrbOILFQfZhm6/builds/1gRD8Nlfp4B1ZiOQe/openapi.json