Upscale an image
Enlarge a picture 2x or 4x so a small file fits a layout built for a bigger one. The existing pixels are spread over a larger canvas, so the result is bigger but softer, never sharper. Not accepting images yet, and nothing is charged while it cannot run.
This task is not available right now, so it cannot be purchased. Nothing is charged for it.
How it works & API2x and 4x, coming soon
What enlarging an image really does
Enlarging an image means resampling it: the existing pixels are spread across a bigger canvas and the gaps between them are filled by interpolation. That is enough to make a small picture reach a required size, but interpolation cannot add information the original never recorded. Fine edges soften, small text blurs and textures flatten as the factor grows, so a 4x enlargement shows this more than a 2x one. The result looks like the original at a larger scale, which is exactly what many layout and print jobs need, but it will not rescue a blurry photo.
When a softer, larger image is the right answer
A plain enlargement is useful whenever the size change is the goal: a listing template demands a minimum pixel size and your source image is smaller, a small logo has to print at a fixed physical size, a batch of pictures at mixed sizes needs one common resolution before layout, or a small avatar has to fill a bigger frame. The typical mistake is expecting new detail; choose 2x when you can, since the softening grows with the factor. The tool is not accepting images at the moment, and no job is charged while it cannot run.
What a plain enlargement can and cannot do
Enlarging an image means resampling it: the existing pixels are spread across a bigger canvas and the gaps are filled by interpolation. That is enough to make a small picture reach a required size, but interpolation cannot add information the source never recorded. Fine edges soften, small text blurs, and texture flattens as the factor grows — a 4x enlargement shows this more than a 2x one.
When a plain enlargement is still useful
Resampling to a larger size has real uses even without added detail: meeting a template's minimum pixel dimensions, printing a small graphic at a fixed physical size, or standardising a mixed set of images to one resolution. In each case the value is the size change, not new sharpness — the result will look like the original at a larger scale, which for many layout and print tasks is exactly what is needed.
What you can do with it
Meeting a template's minimum size
A listing template requires a minimum pixel size and a smaller source image is enlarged to fit it, accepting that the result is softer rather than sharper.
Fixed-size printing
A small logo or graphic is enlarged to the pixel dimensions a print layout expects at a set physical size.
Standardising a mixed set
A batch of images at different sizes is resampled to one common resolution before layout, without claiming to add detail.
Filling a larger frame
A small avatar is enlarged to reuse in a bigger frame in the cases where a softer result is acceptable.
FAQ
What is the difference between 2x and 4x?
2x doubles width and height, 4x quadruples them. Because a plain enlargement cannot add detail, the higher the factor the softer the result looks.
Will this make a blurry photo sharp?
No. A plain enlargement resamples the image to a larger size; it cannot recover detail that was never captured, so a blurry or heavily compressed source stays soft — larger, not sharper.
Is there a free tier for the image enlarger api?
There's no free tier — free tiers get abused and slow everyone down. No subscription, no tokens, no invented credits, and a failed task is never charged.
Is the image enlarger api live yet?
No. It is temporarily withdrawn while it is reworked so that it does not promise detail a CPU resample cannot deliver.
What image formats could I enlarge?
Common raster formats would be accepted on input, and you would choose the output format for the enlarged result.
Related tools
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
One authenticated POST creates the task; the result comes back by webhook or a signed link. This capability is currently available through the API, not as an interactive Web tool.
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://example.com/photo.jpg"}'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://example.com/photo.jpg"
})
});
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://example.com/photo.jpg"
},
)
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://example.com/photo.jpg"}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"image":"https://example.com/photo.jpg"}`)
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://example.com/photo.jpg"
}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. |
Technical notes
This endpoint takes an image and resamples it to larger pixel dimensions — for the times a small file has to fit a layout built for a bigger one. It is a plain, high-quality enlargement, not a detail-rebuilding upscaler: it does not add information that was never in the original, so an enlarged photo looks softer than one shot at that size. It is currently unavailable and not accepting jobs; the note below explains why, and the endpoint and price shown here are what it would use if it returns.
What a plain enlargement can and cannot do
Any tool that claims to 'restore' lost detail is describing a heavier, GPU-based model, which this endpoint does not run.
Why this tool is not available right now
An enlarger that genuinely rebuilds detail needs a neural super-resolution model, and those need a GPU to run at a sensible cost. The platform behind this endpoint offers CPU only, so the honest version of this tool — one that does not oversell what a CPU resample can deliver — is still being reworked. Until then the endpoint does not accept jobs, and nothing is charged for a task that cannot run.
Formats and how it would run
Common raster formats would be accepted on input, and you would choose the output format. When the tool returns it would run asynchronously: submit the image and a target factor, receive a task_id, and get the enlarged file by signed link the moment it is ready — useful when enlargement is one stage of a larger job, such as preparing a mixed catalogue to a common minimum size.
Technical questions
How would I enlarge an image through the api?
This tool is not available yet. When it returns you would POST to /image/upscale with the source image and a target factor, 2x or 4x, and receive a task_id plus the enlarged image by webhook or signed link.
How much does it cost to enlarge an image?
$0.061 per request plus $0.0041 per image, and only completed tasks are charged.
Could I enlarge a large batch of images at once?
Yes, you would combine this endpoint with the Batch Processing API to enlarge many images in one call, each priced separately.