Colorize photos
A black-and-white photo carries no record of what colour anything actually was — this endpoint makes an informed, plausible guess and paints it back in: skin tones, sky, fabric, foliage. Send a monochrome image, get back a colour version built for family archives, museum digitisation, and historical media projects.
This task is not available right now, so it cannot be purchased. Nothing is charged for it.
How it works & APIThe archive that never had colour to begin with
Millions of photographs exist only in black and white, not because someone chose monochrome as a style but because colour film was expensive, unreliable, or simply hadn't reached ordinary use yet at the time they were taken. Family archives, newspaper morgues, and municipal records are full of these images, and for decades the only way to add colour was tedious manual hand-tinting, one photo, one brushstroke at a time. This endpoint does the equivalent job automatically, at the pace an archive actually needs.
How the guess gets made
The task reads the grayscale image and infers colour from context — skin reads as skin tone, sky reads as sky blue, foliage reads as green — the same kind of visual reasoning a skilled colourist uses, applied consistently and quickly. You send the black-and-white photo, the task returns a coloured version, and because it's a plausible reconstruction rather than a record of the true original colours, results are best treated as an enhancement for viewing and sharing, not as historical proof of what something actually looked like.
A century of trying to solve this by hand
Hand-tinting black-and-white photographs dates back to the earliest days of photography itself, well before colour film existed, and colourization of old film and photos has remained a recognisable craft ever since — practiced by specialists for historical restoration, film remastering, and personal archives. Automating that judgment call is what turns a slow, specialist skill into something an archive of any size can apply consistently.
Where this actually gets used
Genealogy platforms use it to make century-old family portraits feel present rather than distant. Museums and local history projects use it to make archival photography more approachable to a general audience. Media and publishing use it to refresh archival photography for retrospective features without commissioning new hand-tinting work for every image.
Working it into a digitisation pipeline
The endpoint runs asynchronously: submit the scanned or digitised photo, get a task_id, and the coloured result arrives by signed webhook the moment it's ready, or through a signed link if that fits your flow better. It pairs naturally with a preceding scan or upscale step and a following export step, so a physical photo can move from scan to sharp, coloured, publish-ready image without manual handling in between.
What you can do with it
Family archive digitisation
A genealogy service colourizes scanned family portraits from the early twentieth century as part of building an interactive family tree.
Museum and local history exhibits
A historical society colourizes archival street photography to make an exhibit feel immediate to visitors who didn't live through the period.
Editorial retrospectives
A publisher colourizes archival press photos for an anniversary feature, giving old newsroom images new visual life without a re-shoot.
Restoration studio workflow
A photo restoration studio colourizes a batch of client-submitted heirloom photos as one stage in a full restoration and reprint job.
FAQ
How do I colorize a black-and-white photo through the api?
POST to /image/colorize with the grayscale image; you get a task_id back and the colourized version arrives by webhook or signed link.
Is the added colour historically accurate?
It's a plausible, context-based reconstruction, not a record of the true original colours, so treat results as an enhancement for viewing rather than historical proof.
What photo formats does it accept?
Common raster formats are accepted on input, and you choose the output format for the colourized result.
Can it colorize old film scans, not just photographs?
Yes, any digitised grayscale image works the same way, including scanned film frames, provided it's submitted as an image file.
Is there a free tier for the photo colorizer 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 colorize a photo?
$0.062 per request plus $0.004 per image, charged only on tasks that complete successfully.
Is the photo colorizer 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 colorize a large batch of archive photos at once?
Yes, pair this endpoint with the Batch Processing API to colourize an entire archive in one call, with each photo 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/colorize \
-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/colorize", {
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/colorize",
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/colorize", 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/colorize", 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.colorize",
"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. |
501 | coming_soon | Capability being deployed (Phase 1b). Its page exists; it doesn't accept executions yet. |