Denoise an image
A photo shot in a dim room or at a high ISO carries speckled noise baked into every pixel, and that noise is the difference between a usable photo and one that looks cheap. This endpoint strips that grain out while keeping edges and detail intact, so a phone photo taken after dark can still hold up next to a studio shot.
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 low light always costs you something
Every camera sensor faces the same trade-off: gather more light and the exposure is clean but the shot might blur from motion, or gather less light and boost the sensitivity, and the image comes out speckled with noise. This is true of a phone camera in a dim restaurant, a security camera at night, or a scanner working from a faded print — anywhere the source signal is weak, the sensor compensates by amplifying, and amplifying noise is what amplifying signal always drags along with it.
What denoising actually removes and preserves
The task analyses the image and separates real detail — edges, texture, fine lines — from the random speckle pattern that noise produces, then removes the speckle while leaving the real detail alone. That distinction matters: a naive blur would also remove noise, but it would take the sharpness of the photo down with it. Effective denoising is precise about which pixels are signal and which are noise, and treats them differently.
A well-worn problem in image processing
Noise reduction has been a core problem in image processing since the earliest digital sensors, because every generation of camera has pushed into lower light and higher sensitivity, and every generation of low-light shot has needed cleanup afterward. The engineering challenge has always been the same: remove the grain without also removing the picture. This endpoint applies that established discipline as a single, fast API call.
Where noisy photos pile up
User-generated content platforms receive a constant stream of dim, noisy phone photos that need cleanup before they're presentable in a feed or listing. Security and surveillance footage exported as stills is often grainy by nature of the low-light hardware involved. Document and archive scanning from faded or poorly lit originals introduces its own kind of noise that a denoise pass can meaningfully clean up before OCR or publishing.
Slotting it into a processing pipeline
The endpoint is asynchronous: submit the noisy image, get a task_id back immediately, and receive the cleaned file by signed webhook once it's ready. It works well as an early step in a pipeline — denoise, then resize or colour-correct, then publish — cleaning up the source before every downstream step compounds the noise into visible artifacts.
What you can do with it
User-uploaded photo cleanup
A marketplace or social app automatically denoises photos submitted from phone cameras in dim indoor lighting before they're shown in a public feed.
Security footage stills
A security platform denoises still frames pulled from grainy night-vision or low-light camera footage before including them in an incident report.
Faded document and photo scans
An archive digitisation project denoises scans of old, faded prints and documents as a cleanup pass before running OCR or display.
Event photography triage
A photography service denoises the small share of low-light shots from an event shoot instead of discarding usable frames outright.
FAQ
How do I remove noise from an image through the api?
POST to /image/denoise with the source image; you get a task_id and the cleaned image arrives by webhook or signed link.
Will denoising blur my photo?
No, the task is built to separate real detail from noise and remove only the noise, unlike a naive blur that softens everything including sharp edges.
Does it work on very dark or very grainy photos?
Yes, it's specifically built for low-light and high-ISO grain, though extremely underexposed photos will still show some of their original softness after cleanup.
What image formats does it accept?
Common raster formats are accepted on input, and you choose the output format for the cleaned result.
Is there a free tier for the image denoise 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 it cost to denoise an image?
$0.062 per request plus $0.004 per image, and you're only charged for tasks that complete successfully.
Is the image denoise api available now?
It's in deployment and not yet accepting jobs; the endpoint and pricing described here are final and will go live shortly.
Can I denoise a large batch of photos at once?
Yes, pair this endpoint with the Batch Processing API to clean up an entire set of images in one call, each priced and metered separately.
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
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/denoise \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"image":"https://ejemplo.com/imagen.jpg"}'const res = await fetch("https://api.kit.forhosting.com/image/denoise", {
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/denoise",
headers={"Authorization": f"Bearer {os.environ['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/denoise", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"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/denoise", 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.denoise",
"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
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. |