ForHosting KIT · Images

Blur part of an image

Not every part of a photo is meant to be seen — a whiteboard with someone else's notes, a screen in the background, an address on an envelope. This endpoint takes the coordinates of a region you specify and blurs exactly that area, leaving the rest of the image untouched.

● StablePer request + per image$0.002

Run — $0.002 + $0.005/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 problem of the accidental detail

Most privacy issues in images aren't the whole photo — they're one corner of it: a laptop screen visible through a window, a document left on a desk, a license plate that happens to be in frame. Cropping loses the rest of the shot, and manual retouching in an editor doesn't scale past a handful of images once the volume climbs into the hundreds. This endpoint lets you draw a box, in coordinates, around exactly the part that shouldn't be legible, and blurs only that, leaving the composition and everything else in the frame untouched.

Who needs to redact a specific area

Real estate listings blurring a homeowner's family photos visible through a doorway, e-commerce platforms hiding a competitor's logo that slipped into a product photo, publishers obscuring a whiteboard or a screen in a workplace photo before it runs in an article, support teams redacting a fixed region of a screenshot — like a sidebar with account details — before it's shared externally with a vendor or a client who shouldn't see internal data.

What the region actually needs

You submit the image along with the coordinates of one or more rectangular regions, receive a task_id immediately, and the job applies a blur strong enough to make the content unreadable inside that region, returning an image identical to the original everywhere else — same dimensions, same format, same everything outside the box you drew.

Fitting it into a review or moderation flow

Because it's billed per image and returns asynchronously, it works well right after a detection step — automated or manual — that identifies where sensitive content sits in a photo: the coordinates get passed straight into this endpoint, and the redacted image comes back ready for publication without anyone opening an image editor or touching the file by hand.

A targeted tool, not a blunt one

Full-image blurring is easy and rarely what anyone actually wants; the useful case is almost always partial, and that's exactly the gap between blurring an entire photo and blurring the one part of it that matters, which is what a coordinate-based region blur is built to close, precisely and repeatably, one rectangle at a time.

What you can do with it

Real estate photo privacy

A listings platform blurs a homeowner's personal photos or documents visible through an open doorway before publishing the tour.

Screenshot redaction

A support team blurs a fixed sidebar region containing account details in every screenshot before it's shared with an external vendor.

Competitor logo removal

An e-commerce catalog blurs a rival brand's logo that appears in the background of a user-submitted product photo.

Workplace and editorial photos

A publisher blurs a whiteboard or a visible screen in a background before a workplace feature photo runs in an article.

FAQ

How do I blur part of an image with this API?

Send a POST to /image/blur-region with the image and the coordinates of the rectangle to redact; you get a task_id and the redacted image back by webhook or signed link.

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.002 per request plus $0.005 per image, a flat published rate regardless of how many regions are blurred.

Can I blur more than one region in the same image?

Yes, you can specify multiple rectangular regions in a single call and each is blurred independently.

Does it detect what to blur automatically?

No, you provide the coordinates. For automatic detection of faces or license plates, use the dedicated Face Blur or License Plate Blur endpoints instead.

Is the blur reversible?

No, the blur is baked into the returned pixels; the original detail is not recoverable from the output image.

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.

Can I process many images at once?

Each call handles one image and returns its own task_id, so processing many images is just parallel requests collected by webhook.

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-region

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-region \
  -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-region", {
  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-region",
    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-region", 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-region", 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_region",
  "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.002

Per image$0.005

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.

Read the full KIT documentation →