ForHosting KIT · Images

Apply a filter

Applying a photo filter by hand is fine for one image and unworkable for ten thousand. This endpoint applies named effects, sepia, gaussian blur, sharpen and several more, to any supported image through a single call, so a catalog, a moderation queue or a content pipeline can transform images the same way every time.

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

One endpoint, several distinct effects

Sepia shifts an image toward warm amber tones reminiscent of early 20th-century prints, blur softens edges using a gaussian kernel to hide detail or reduce noise, and sharpen does the opposite, boosting local contrast so edges read crisply. Each filter is a distinct algorithm, not a preset stacked on top of another, which is why the results stay predictable when you automate them.

Who actually reaches for a filter API

Marketplaces apply a consistent style across seller-submitted photos, media archives use blur to protect faces or license plates before publishing, photography apps offer sharpen as a one-tap fix for slightly soft shots, and nostalgia or memorial products lean on sepia to signal 'old photograph' without needing an actual antique print. None of that scales as a manual task once volume passes a few dozen images a day.

Calling it and getting a result

Send the source image and the filter name to POST /image/filter; the call returns a task_id right away because every filter job runs asynchronously in the queue. The finished image arrives through a signed webhook, the reliable choice for pipelines, or through a signed link valid for 24 hours when a human just needs to grab the file.

Where these effects come from

Sepia dates back to actual sepia ink used in 19th-century photographic prints, which is why the color name stuck even in fully digital form, while blur and sharpen are direct descendants of convolution kernels developed for image processing decades before consumer software made them a button. Knowing the lineage matters less than knowing each filter behaves consistently, which is the whole point of moving it into an API instead of a manual editing step.

Automation without surprises

A failed filter job is never charged; the platform retries up to three times automatically and only returns an error once those retries are exhausted, so a flaky upload doesn't turn into a wasted charge. There's no free tier and no trial queue to wait behind, prepaid balance get your job running immediately, and a 402 response is the honest signal when that's not the case rather than a silent failure.

What you can do with it

Marketplace photo consistency

A marketplace applies a uniform sharpen pass to every seller-uploaded photo so listings look professional regardless of the original camera quality.

Privacy blurring before publication

A news archive runs blur over faces and plates in historical street photography before making the collection public.

Nostalgia and memorial products

A print-on-demand service applies sepia to recent photos on request so customers can order a keepsake with a vintage look.

Batch photo touch-ups

A photo storage app offers one-tap sharpen for slightly out-of-focus uploads, processed in the background without blocking the user.

FAQ

What filters does the image filter API support?

The endpoint currently supports sepia, blur and sharpen, applied through POST /image/filter with the filter name specified in the request.

Is there a free trial for the image filter API?

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 much does applying a filter cost?

Each call costs $0.002 per request plus $0.005 per image, and you're only billed when the filter is applied successfully.

Can I apply more than one filter in a single call?

Each call applies one named filter; chain calls in sequence if you need to combine effects, and each step is billed independently on success.

What happens if a filter request fails?

It's never charged. The system retries automatically up to three times before returning a clear error.

Is blur strong enough to anonymize faces?

The blur filter is a gaussian blur suited to softening detail; for strict anonymization requirements, test the intensity against your specific compliance needs before relying on it in production.

How do I process a large batch of images?

Submit one asynchronous call per image; since every job runs independently, you can fan out hundreds of calls without waiting on earlier ones to finish.

How do I retrieve the filtered image?

Through a signed webhook, recommended for automated pipelines, or a signed link that stays valid for 24 hours before the file is deleted.

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/filter

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/filter \
  -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/filter", {
  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/filter",
    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/filter", 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/filter", 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.filter",
  "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 →