Image variations
The first version of an image is rarely the last word — it's a starting point you want explored in five directions at once. This endpoint takes a source image and returns a set of alternatives that keep its spirit while shifting details, giving you options instead of a single fixed output.
Run it online
Run this on our servers with your account. Free tools run in your browser; this one bills your KIT balance per the price above.
The real problem: picking, not producing, one image
Most creative work isn't stuck on producing a single image, it's stuck on not knowing which single image is right. A designer likes the composition of a generated banner but wants to see it with warmer light, or a slightly different angle, or a busier background, and re-typing a prompt from scratch loses the parts that were already working. This endpoint solves that specific bottleneck: it keeps what's working in the source image and lets the rest shift, so you're choosing between real options instead of guessing blind at a new prompt.
What you send and what comes back
You submit a source image, by URL or upload, along with how many variations you want, and the task returns that many alternative images once generation finishes. Each variation shares the visual DNA of the source, subject, palette, general composition, while differing in the specific details a fresh generation would naturally change, and results are delivered by webhook or a signed link as an asynchronous task.
Why variation is a distinct capability from generation
Generating fresh images from a text prompt and generating variations of an existing image are different technical problems: one starts from language, the other starts from a visual reference and reinterprets it while staying anchored to it. That anchoring is what makes variations useful in a way that regenerating from a rewritten prompt usually isn't, because a prompt can only describe what you can put into words, while an image reference carries visual nuance no sentence fully captures.
Where it slots into a workflow
Because it's asynchronous, this endpoint fits naturally after a first generation or upload step: generate or receive a base image, request variations, and let the webhook deliver the set once ready, without a person waiting on a spinner. Teams use it for A/B creative testing, for giving end users a choose-your-favorite step in a personalization flow, or for exploring a client's mood board direction before committing to a final asset.
What variations will and won't do
Variations reinterpret an image; they do not guarantee a specific requested change, so if you need a precise edit, like removing an object or changing exact text, a targeted editing tool is the better fit. Treat this endpoint as a way to widen your options quickly from a single starting point, not as a controlled way to make one exact modification.
What you can do with it
Creative A/B testing
A marketing team generates several variations of a hero banner from one approved base image and tests which version performs best in a campaign.
Client mood exploration
A design studio shows a client a handful of variations on a single approved concept image instead of starting the entire brief over for each round of feedback.
User-facing pick-your-favorite flows
A print-on-demand app lets a shopper generate several variations of a design and choose the one they like best before ordering.
Expanding a limited asset set
A small team stretches one licensed or generated hero image into a family of related visuals for use across different pages and formats.
FAQ
How do I generate variations of an image through the api?
Send a POST to /image/variations with the source image and the number of variations you want; you get a task_id back and the results arrive by webhook or a signed link.
How similar are the variations to the original?
They share the source's subject, palette and general composition while varying specific details, so expect a family of related images rather than near-duplicates or unrelated new scenes.
Can I request an exact number of variations?
Yes, you specify how many variations you want in the request and receive that many results in the completed task.
Is this the same as generating an image from a prompt?
No, image.generate creates a new image from text, while this endpoint reinterprets an existing image you supply, keeping it anchored to the source.
Is there a free tier for the image variations 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 do image variations cost?
$0.002 per request plus $0.0065 per image, and you're only billed for variations that are actually delivered.
What if the variation task fails?
It retries automatically up to three times; if it still can't complete, you get a clear error and are never charged for the failed attempt.
Can I use this to make a precise edit, like removing an object?
Not reliably — variations reinterpret an image broadly rather than applying a targeted change, so a precise edit needs a dedicated editing tool instead.
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/variations \
-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/variations", {
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/variations",
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/variations", 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/variations", 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.variations",
"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. |
422 | task_failed | The task failed after 3 retries. You are never charged for it. |