Convert image format
Turn a designer's TIFF, an old tool's BMP or a camera JPG into the format your next system accepts: JPG, PNG, GIF, BMP, TIFF or WebP. One file goes in, the same picture comes out in the new format. You pay per use, with no subscription.
This task is not available right now, so it cannot be purchased. Nothing is charged for it.
How it works & APIEvery pipeline eventually hits a format it doesn't understand: a designer hands over a TIFF, a CMS demands WebP, a legacy importer chokes on BMP.
The mismatch problem
Teams rarely control every format that arrives in their pipeline. Cameras still export TIFF, scanners still love BMP, older CMS platforms still expect GIF, and modern frontends increasingly demand WebP for speed. Rather than bundling a graphics library into every service that touches an upload, you send the file once to /image/convert and get back exactly the container format you asked for.
A short note on the formats themselves
JPG remains the default for photographs because its lossy compression suits continuous tones; PNG and GIF preserve exact pixels and support transparency or simple animation; BMP is the oldest of the group, a raw, uncompressed format still produced by some Windows tools; TIFF is the archival choice for print and scanning workflows; WebP is the newest, built for the web, and typically produces smaller files than JPG or PNG at comparable quality. Knowing which one your destination actually needs avoids a lot of wasted bandwidth.
What you can do with it
CMS ingestion pipeline
A publishing platform accepts uploads in whatever format a contributor's camera produced and converts everything to WebP before it ever reaches the content database.
Legacy asset migration
An agency inherits thousands of BMP and TIFF files from a client's old file server and batch-converts them to PNG ahead of a website relaunch.
Print-to-web handoff
A print shop's high-resolution TIFF proofs get converted to JPG automatically so the sales team can preview them in a browser without downloading gigabytes.
Cross-platform consistency
A mobile app backend normalizes photos from iOS and Android uploads into a single JPG format before running them through further processing.
FAQ
Is there a free tier for image conversion?
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.
What happens if a conversion fails?
The system retries automatically up to three times; if it still fails, you get a clear error and you are never charged for that task.
Can I convert transparent PNGs to JPG?
Yes, though JPG has no alpha channel, so transparent areas are flattened; if you need to keep transparency, convert to PNG or WebP instead.
How long is the converted file available for download?
The signed download link is valid for 24 hours, after which the file is deleted from our systems along with the original upload.
Which image format should I convert to?
JPG suits photographs, PNG and GIF keep exact pixels with transparency or simple animation, TIFF is the archival choice for print and scanning, and WebP is built for the web, usually with smaller files than JPG or PNG at comparable quality.
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/convert \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"image":"https://ejemplo.com/imagen.jpg","format":"image/webp"}'const res = await fetch("https://api.kit.forhosting.com/image/convert", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"image": "https://ejemplo.com/imagen.jpg",
"format": "image/webp"
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/image/convert",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"image": "https://ejemplo.com/imagen.jpg",
"format": "image/webp"
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/image/convert", 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","format":"image/webp"}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"image":"https://ejemplo.com/imagen.jpg","format":"image/webp"}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/image/convert", 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",
"format": "image/webp"
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "image.convert",
"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. |
Technical notes
This endpoint takes one image in and hands back another, in the format your next system actually accepts, without you touching an image library or a server.
What happens after you call it
Either way, the original upload and the converted output are deleted once the retention window passes, and nothing is ever used to train models. The request is accepted immediately and returns a task_id — conversion itself runs asynchronously so your calling service never blocks on image processing. When the job finishes, you're notified through a signed webhook, or you fetch the output from a signed link that stays valid for 24 hours.
Where it fits in automation
Because the call is a single POST with a predictable JSON response, it drops cleanly into upload handlers, batch migration scripts, or scheduled jobs that walk a media library and normalize everything to one target format. You describe the source and target formats in the request body; the task queue handles concurrency, retries failed conversions up to three times automatically, and never charges you for a task that ultimately fails.
Who reaches for this
It's built for the engineer who doesn't want image codecs as a dependency, the agency migrating a client's asset library overnight, and the SaaS product that accepts arbitrary uploads and must normalize them before storage or display.
Technical questions
Which formats does the image format converter API support?
JPG, PNG, GIF, BMP, TIFF and WebP, in any direction between them.
How much does converting an image cost?
$0.002 per request plus $0.005 per image, billed only for tasks that actually complete.
Is the conversion synchronous?
No, it's asynchronous. You get a task_id immediately and the result arrives via signed webhook or a signed link valid for 24 hours.
Is there a bulk option for converting many images at once?
You call the endpoint per image, but nothing stops you from firing many requests concurrently or scripting a batch job against the API — the queue is built to handle volume.