ForHosting KIT · Images

Upscale an image

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.

Temporarily withdrawnPer request + per image$0.061

This task is not available right now, so it cannot be purchased. Nothing is charged for it.

How it works & API

Use it from Web API onlyAPIEmailTelegramApp soon

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

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

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.

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.

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

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.

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. 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 enlarge an image?

$0.061 per request plus $0.0041 per image, and only completed tasks are 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. The endpoint and pricing shown here are what it would use if it returns.

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.

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.

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

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

Per request$0.061

Per image$0.0041

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.

Read the full KIT documentation →