Auto-tag images
Point this at a folder of untagged photos and get back a clean list of descriptive keywords for each one — the labels a human cataloger would write, minus the weeks of work. It's built for the moment a media library outgrows manual tagging.
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 problem: libraries that grow faster than anyone can label
Every product catalog, stock archive or user-generated gallery eventually hits the same wall: thousands of images arrive faster than anyone can sit down and type keywords for them. Search breaks first — customers can't find 'red leather boots' if nothing in the system says 'red' or 'leather' or 'boots'. Then internal workflows break, because editors and merchandisers can't filter what isn't described. image.tag exists for that exact moment, turning a backlog of silent images into a searchable, filterable set.
What you send and what comes back
Call POST /image/tag with an image (or a signed URL to one) and the task is queued for processing. Instead of one rigid label, you get a ranked list of tags — general keywords, notable objects, colors, settings and materials the image contains — so you can decide your own confidence cutoff per use case. There is no fixed vocabulary to learn; the tags describe what's actually in the frame.
How the result reaches you
Because tagging a real library means thousands of calls, not one, the endpoint is asynchronous: it hands back a task_id immediately and does the work in the background. Register a webhook and each result lands the moment it's ready, or fetch it yourself from a signed link valid for 24 hours — either way nothing sits waiting on an open HTTP connection.
Where it fits in a bigger pipeline
Tagging rarely runs alone. Teams typically chain it after an upload step and before indexing: tag on arrival, write the keywords into the product or DAM record, then let search and recommendation systems read from that field. Pair it with image.classify when you also need a single primary category, or with image.quality first so blurry or broken uploads never get tagged and published in the first place.
Pricing that matches how libraries actually grow
Cost is a small per-request base plus a per-image rate, both published, with no subscription tiers to negotiate and no free trial to abuse. A request that fails is retried automatically up to three times and, if it still fails, is never billed — so a corrupt file or a dead source URL costs you nothing, only a clear error you can act on.
What you can do with it
E-commerce catalogs
Auto-tag incoming product photos so shoppers can filter by color, material or style without a human ever typing a keyword.
Stock and archive libraries
Backfill decades of untagged archive images with searchable keywords in one batch instead of a manual cataloging project.
User-generated content
Tag photos the moment users upload them, feeding search and content moderation pipelines with structured data immediately.
Digital asset management
Keep a DAM's metadata fresh automatically as new creative assets land, instead of relying on inconsistent manual entry.
FAQ
How does the image tagging API decide which tags to return?
It analyzes the visual content of each image and returns a ranked list of descriptive keywords for the objects, colors, settings and materials it detects — you choose which ones to keep.
Is there a free tier for image.tag?
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.
What image formats are accepted?
Common raster formats (JPEG, PNG, WebP and similar) are accepted; send the file directly or a signed URL to it.
How is image tagging priced?
A small fixed fee per request plus a per-image rate, both published on this page — no tokens, no hidden credits.
Can I tag thousands of images at once?
Yes. Each image is its own async task, so you fire requests as fast as your pipeline allows and collect results by webhook as they finish.
What happens if a tagging request fails?
It's retried automatically up to three times; if it still fails you get a clear error and are never charged for that request.
How do I get the results back?
Register a webhook to receive each result the moment it's ready, or poll a signed link that stays valid for 24 hours.
How is image.tag different from image.classify?
Tagging returns multiple descriptive keywords per image; classification assigns the image to one of your own predefined categories.
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/tag \
-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/tag", {
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/tag",
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/tag", 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/tag", 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.tag",
"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. |