ForHosting KIT · Images

Blur faces

A street photo, a crowd shot, a dashcam frame — the moment a bystander's face is in it, the image carries a person who never agreed to be identifiable. This endpoint finds every face in a photo on its own and blurs each one, so the scene stays but the people in it don't.

● StablePer request + per image$0.010

Run — $0.010 + $0.0625/image How it works & API

Use it from WebAPIEmailApp soonTelegram soon

Run it online

Run this on our servers with your account. Free tools run in your browser; this one bills your KIT balance per the price above.

Why faces are a category of their own

A face isn't just another detail in a photo — in most places it's personal data, and publishing an identifiable stranger's face carries real consent and privacy weight that a blurred logo or license plate doesn't. That's why face anonymisation gets its own detection step rather than a manual coordinate box: faces move, vary in size, tilt at odd angles, and appear in numbers a person can't reliably mark one by one across thousands of photos on a deadline.

Who is anonymising faces at volume

Journalism and documentary outlets protecting bystanders and sources in street and crowd photography, dashcam and security footage processors preparing frames for public release, urban mapping and mobility companies anonymising pedestrians captured incidentally in street-level imagery, event platforms publishing crowd photos without needing consent from every single attendee who happened to be caught in frame that day.

What the detection actually does

You submit the image, receive a task_id right away, and the job locates every face it detects regardless of count or size, applying a blur strong enough that the person is no longer identifiable, while the rest of the photo — the scene, the setting, the composition, the colors — comes back exactly as it went in, untouched.

Where it belongs in a publishing pipeline

Because it runs asynchronously and is billed per image, it fits naturally as a mandatory step before any street, event or crowd photo goes public: an image is captured or uploaded, this endpoint anonymises every face in it, and only the processed version ever reaches a public bucket or a published article — nothing unprocessed slips through by accident.

An old obligation, an old idea done automatically

Blurring faces for publication predates digital photography — newsrooms have obscured identities in print for decades, usually by hand, one photo at a time, with a grease pencil or a darkroom trick. What changes here isn't the idea but the throughput: a job that used to mean a person circling faces in an editing tool now happens automatically, at the scale a photo feed or a live camera actually produces.

What you can do with it

Street and documentary photography

A newsroom anonymises every bystander's face in a street photo before publication, without manually marking each one.

Dashcam and security footage

A fleet operator blurs faces in dashcam frames pulled for an incident report before sharing them outside the company.

Urban mapping imagery

A mapping company anonymises pedestrians caught incidentally in street-level photos before the imagery is published.

Event and crowd photography

An event platform blurs faces in crowd shots so photos can be published without collecting consent from every attendee.

FAQ

How does the face blur API work?

Send a POST to /image/blur-faces with the image; the endpoint detects every face automatically and returns the blurred result by webhook or signed link, no coordinates needed.

Is there a free trial?

There's no free tier — free tiers get abused and slow everyone down. Access runs on a prepaid ForHosting KIT balance: top up from $10.00 (it never expires) and each request is charged at its published price, so a call with no balance returns HTTP 402. No subscription, no tokens, no invented credits, and a failed task is never charged.

How is it priced?

$0.010 per request plus $0.0625 per image, published and flat regardless of how many faces appear in the photo.

Does it work on crowds with many faces?

Yes, detection isn't limited to a fixed number of faces; every face found in the image is blurred in the same pass.

Can it miss a face?

Detection quality depends on image conditions like angle, lighting and resolution, so it's worth spot-checking output for critical, high-stakes publications.

Is the blur reversible?

No, the blur is applied directly to the returned pixels; the original faces cannot be recovered from the output image.

How is this different from Blur Region?

Blur Region redacts coordinates you specify manually; Face Blur detects and blurs every face automatically, with no coordinates required.

Am I charged if the request fails?

No. A failed task is retried automatically up to three times and is never billed; you receive a clear error instead.

For developers — API access

Everything on this page is available programmatically. This section is for teams who want to wire it into their own systems; everyone else can just use the tool above.

API endpoint

POSThttps://api.kit.forhosting.com/image/blur-faces

Prefer to automate it? One authenticated POST creates the task; the result comes back by webhook or a signed link. The same capability also runs here on the web, and soon from our app, email and Telegram.

Call it from your stack

curl -X POST https://api.kit.forhosting.com/image/blur-faces \
  -H "Authorization: Bearer $KIT_KEY" \
  -H "Content-Type: application/json" \
  -d &#39;{"image":"https://ejemplo.com/imagen.jpg"}'

const res = await fetch("https://api.kit.forhosting.com/image/blur-faces", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${process.env.KIT_KEY}`,
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
    "image": "https://ejemplo.com/imagen.jpg"
  })
});
const { task_id } = await res.json();

import os, requests

res = requests.post(
    "https://api.kit.forhosting.com/image/blur-faces",
    headers={"Authorization": f"Bearer {os.environ[&#39;KIT_KEY']}"},
    json={
    "image": "https://ejemplo.com/imagen.jpg"
},
)
task_id = res.json()["task_id"]

<?php
$res = file_get_contents("https://api.kit.forhosting.com/image/blur-faces", false, stream_context_create([
  "http" => [
    "method"  => "POST",
    "header"  => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
    "content" => &#39;{"image":"https://ejemplo.com/imagen.jpg"}',
  ],
]));
$task = json_decode($res, true);

body := bytes.NewBufferString(`{"image":"https://ejemplo.com/imagen.jpg"}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/image/blur-faces", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)

Example request

{
  "image": "https://ejemplo.com/imagen.jpg"
}

Example response

{
  "task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
  "type": "image.blur_faces",
  "status": "queued",
  "_links": {
    "result": "/tasks/tsk_…/result"
  }
}

The API is asynchronous: the call returns a task_id immediately and the result arrives by webhook. Polling is capped at 1 req/s per task.

Pricing

Per request$0.010

Per image$0.0625

Published price — no tokens, no invented credits. A failed task is never charged.

Limits

`max_mb`	15
`max_megapixels`	12

Errors

HTTP	Code	Meaning
`401`	`unauthorized`	Missing or invalid API key.
`402`	`insufficient_balance`	Your balance doesn't cover the task price.
`404`	`unknown_type`	That task type doesn't exist.
`429`	`rate_limited`	Too many requests. Use the webhook instead of polling.
`422`	`task_failed`	The task failed after 3 retries. You are never charged for it.

Read the full KIT documentation →