ForHosting KIT · Images

Blur license plates

A license plate is a direct line to a person's identity in most jurisdictions, and it turns up in the background of far more photos than anyone plans for — parking lots, street scenes, dashcam frames, real estate driveways. This endpoint finds every plate in an image on its own and blurs it, so the vehicle can stay in the shot and the owner can't be traced from it.

● 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.

The plate nobody meant to photograph

Most exposed license plates aren't the subject of the photo — they're incidental, sitting in a driveway, a parking lot or a street behind whatever was actually being photographed. That incidental nature is exactly why manual redaction fails at any volume: nobody reviews a thousand real estate photos looking for a plate in the corner of a driveway shot, so it either gets missed or the whole workflow slows to a crawl. Automated detection removes that tradeoff.

Who needs plates out of the frame

Real estate platforms publishing exterior and driveway photos where a neighbor's or the seller's car happens to be parked, dashcam and insurance claim processors preparing footage for a report that shouldn't expose other drivers, mapping and street-view operators anonymising vehicles captured incidentally at ground level, marketplaces for used cars that need to blur the plate of the specific vehicle being sold before the listing photo goes live.

How the detection behaves

You submit the image, get a task_id immediately, and the job scans for plates regardless of how many vehicles appear or where in the frame they sit, blurring each one it finds strongly enough to make the characters unreadable, while returning the rest of the photo exactly as it was submitted.

Slotting into an upload or listing pipeline

Because it's asynchronous and billed per image, it works well as an automatic step right after a photo is uploaded and right before it's shown publicly: a real estate agent uploads exterior shots, this endpoint runs on each one, and only the redacted versions ever reach the live listing — no photo reviewer has to go looking for plates by eye.

A narrow rule with broad reach

Plate-privacy requirements differ by jurisdiction — some regions treat a plate as personal data outright, others leave it to platform policy — but the practical answer converges on the same thing almost everywhere: don't publish a readable plate you don't need visible, and automating that check is far more reliable, and far cheaper at scale, than hoping a tired reviewer catches every single one.

What you can do with it

Real estate exterior photos

A listings platform blurs any license plate visible in driveway or street-view photos before the exterior shots go live.

Insurance and dashcam claims

An insurer redacts plates of other vehicles in dashcam footage submitted as evidence before it's shared with a third party.

Street-level mapping imagery

A mapping operator blurs plates captured incidentally in street-level photography before the imagery is published.

Used car marketplace listings

A car marketplace blurs the seller's own plate in listing photos automatically before the ad is published.

FAQ

How does the license plate blur API work?

Send a POST to /image/blur-plates with the image; every plate is detected automatically and the redacted photo comes back by webhook or signed link, no coordinates required.

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 no matter how many plates appear in the photo.

Does it handle multiple vehicles in one photo?

Yes, every plate detected in the image is blurred in the same pass, whether there's one vehicle or a full parking lot.

Can it miss a plate?

Detection quality depends on angle, distance and image resolution, so spot-checking output is worth it for high-volume or high-stakes publishing.

Does it also blur faces in the same image?

No, this endpoint targets plates specifically; pair it with the Face Blur API in the same pipeline if a photo needs both anonymised.

Is the redaction reversible?

No, the blur is applied directly to the returned pixels, so the original plate characters are not recoverable from the output.

Am I charged if the request fails?

No. A failed task is retried automatically up to three times and is never billed; you get 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-plates

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-plates \
  -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-plates", {
  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-plates",
    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-plates", 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-plates", 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_plates",
  "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 →