Upscale an image
Old product shots, thumbnail-sized archive photos, low-res screenshots that need to fill a hero banner — this endpoint takes a small image and rebuilds it larger, at 2x or 4x, without the soft, waxy look of a simple pixel stretch. You send the file, you get back a bigger one that still looks like a photo.
This task is not available right now, so it cannot be purchased. Nothing is charged for it.
How it works & APIWhy 'just make it bigger' usually goes wrong
Stretching an image is trivial; stretching it well is not. Classic interpolation methods — the kind built into most image libraries — invent new pixels by averaging neighbours, and averaging is exactly what produces the mushy, blurred look everyone recognises from a badly enlarged photo. Fine edges soften, text turns to smudge, and skin or fabric texture flattens into plastic. The problem gets worse the more you enlarge, which is why a naive 4x stretch looks noticeably worse than a naive 2x one.
What upscaling actually does differently
Rather than just spreading existing pixels across a bigger canvas, the task reconstructs plausible detail as it enlarges — sharpening edges, preserving texture, and avoiding the halo and ringing artifacts that come from over-aggressive sharpening after the fact. You choose 2x or 4x, submit the source image, and receive back a larger file that holds up at the new size instead of just looking like the same photo, stretched.
A problem as old as digital images
Super-resolution — recovering detail that a low-resolution capture never recorded — has been a research problem since the earliest digital cameras produced images smaller than the displays meant to show them. Every generation of upscaling technique has chased the same goal: add believable detail without inventing something that wasn't there. This endpoint applies that lineage of work as a single API call instead of a research pipeline.
Where a small image becomes a real problem
It shows up constantly: a supplier sends a 400px product photo for a listing template that wants 1600px, an old archive only has thumbnail-resolution scans, a user avatar looks fine as a small circle but pixelates the moment it's used as a profile banner. Upscaling turns each of those from a dead end into a usable asset, without re-shooting or re-scanning the original.
Dropping it into a pipeline
The task runs asynchronously: submit the image and target factor, get a task_id, and receive the enlarged file by signed webhook the instant it's ready — useful when upscaling is one stage in a larger job, such as archive digitisation or a bulk catalogue refresh where every source photo needs to hit a minimum resolution before publishing.
What you can do with it
Legacy product catalogue refresh
A retailer inherits a decade of product photos at low resolution and upscales the whole set to meet a modern listing template's minimum size.
Archive and scan restoration
A digitisation project holds only small scanned thumbnails of old documents or photos and upscales them before display or print.
Avatar-to-banner reuse
A small user-uploaded avatar gets upscaled 4x so it can be reused as a sharp header image instead of asking the user to re-upload.
Thumbnail-only source assets
A design team only has a thumbnail-sized reference image from a client and upscales it to a usable working resolution before layout.
FAQ
How do I upscale an image through the api?
POST to /image/upscale with the source image and your target factor, 2x or 4x; you get a task_id and the enlarged image arrives by webhook or signed link.
What's the difference between 2x and 4x upscaling?
2x doubles both width and height, 4x quadruples them; larger factors take a bit longer and are more visible on very small or heavily compressed sources.
Will upscaling make a blurry photo sharp?
It enlarges while preserving edges and texture far better than a simple stretch, but it can't recover detail that was never captured; very blurry or heavily compressed sources will still show their original softness at a larger size.
Is there a free tier for the image upscaler 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 upscale an image?
$0.061 per request plus $0.0041 per image, and only completed tasks are charged.
Is the image upscaler api live yet?
It's currently in deployment and not yet accepting jobs; the endpoint and pricing here are final and will open shortly.
What image formats can I upscale?
Common raster formats are accepted on input, and you choose the output format for the enlarged result.
Can I upscale a large batch of images at once?
Yes, combine this endpoint with the Batch Processing API to run upscaling across many images in one call, each priced 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/upscale \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"image":"https://ejemplo.com/foto.jpg","scale":2}'const res = await fetch("https://api.kit.forhosting.com/image/upscale", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"image": "https://ejemplo.com/foto.jpg",
"scale": 2
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/image/upscale",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"image": "https://ejemplo.com/foto.jpg",
"scale": 2
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/image/upscale", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"image":"https://ejemplo.com/foto.jpg","scale":2}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"image":"https://ejemplo.com/foto.jpg","scale":2}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/image/upscale", 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/foto.jpg",
"scale": 2
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "image.upscale",
"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. |