ForHosting KIT · Text & AI

Categorize products

A supplier feed rarely matches your store's category tree, and no merchandiser wants to hand-sort ten thousand SKUs against a nested taxonomy. This endpoint takes a product title, description or attribute list and returns the category path it belongs in, so new inventory is browsable and searchable the moment it lands rather than sitting in an 'uncategorized' bucket for a week.

● StablePer request + per item$0.003

Run — $0.003 + $0.0135/item How it works & API

Use it from WebAPIEmailApp soonTelegram soon

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 this solves

Catalog teams at marketplaces, distributors and retailers all inherit the same mess: a feed from Supplier A calls something 'Men's Running Shoe, Trail', Supplier B calls the same class 'Footwear - Outdoor - Trail Runner', and your storefront needs both mapped to a single node in your own category tree. Doing that by hand for a few dozen items is fine; doing it for a rolling feed of thousands is a full-time job nobody wants, and it's exactly the gap product categorization closes.

What the request looks like

You send an array of products — title, description, and optionally brand or attributes — plus your taxonomy (a flat list or a nested tree) to /text/product-categorize. The task is async: you get a task_id right away, and the categorized array arrives at your signed webhook or behind a signed link valid for 24 hours, each product tagged with the taxonomy node it best fits and, where the fit is close between two nodes, the runner-up option so a merchandiser can make the final call in seconds instead of from scratch.

How it reads a product

It weighs the title, description and any structured attributes together rather than keyword-matching a single field, which is why 'Trail Runner' and 'Zapato de trekking' can land in the same node even when the wording shares almost nothing. That's the same reasoning a category manager does mentally when scanning a supplier sheet — recognizing the product class behind inconsistent naming — just applied consistently across an entire feed instead of the first fifty rows before fatigue sets in.

Where it plugs into your pipeline

Because your taxonomy is part of the request, not a fixed built-in list, the same endpoint serves a fashion retailer's tree and a hardware distributor's tree without retraining or reconfiguring anything on your side — you simply pass the structure you already maintain. Feed ingestion jobs, PIM syncs and marketplace onboarding flows can call it as one step in a larger pipeline, with the webhook triggering the next stage automatically.

Honest limits

A genuinely ambiguous product — a multi-tool that could sit under 'Camping' or 'Hardware' — comes back with its best match plus that runner-up node rather than a false-confident single answer, so your team keeps a lightweight review step for the fraction of SKUs that need a human tiebreaker. That's a deliberate choice: category placement affects discoverability and revenue, so silent guessing on the hard cases isn't acceptable.

What you can do with it

Marketplace seller onboarding

Map a new seller's raw product feed onto your marketplace taxonomy automatically before their listings go live.

Distributor catalog syncs

Reconcile a supplier's category names with your internal tree every time a price-and-stock feed updates.

PIM cleanup projects

Re-categorize a legacy catalog against a redesigned taxonomy in one batch instead of a manual re-tagging sprint.

Cross-border catalog expansion

Fit products described in another language or convention into your existing category structure without building a translation layer first.

FAQ

How does the product categorization API map items to my taxonomy?

You include your taxonomy in the request, and each product's title, description and attributes are matched against it to return the best-fit category node, with a runner-up when the call is close.

Can I use a nested category tree, not just a flat list?

Yes, both flat lists and nested trees are supported, and the response includes the full category path for each product.

Is there a free trial?

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 does it cost to categorize a large catalog?

$0.003 per request plus $0.0135 per item, so categorizing 5,000 SKUs has a fixed, calculable cost regardless of how nested your taxonomy is.

How are results delivered?

The task runs asynchronously; you get a task_id immediately and the categorized results via your signed webhook or a signed link valid for 24 hours.

What happens with ambiguous products?

They're returned with their best-fit category and a runner-up alternative instead of a single overconfident guess, so a merchandiser can resolve the edge cases quickly.

Can I send bulk batches for a whole catalog import?

Yes, bulk feeds are the typical use case; send the full product array in one call and pricing scales per item with no arbitrary cap.

Does it work for catalogs in Spanish or other languages?

Yes, the model reads the title and description in the language you send and maps them to your taxonomy regardless of the language the category names are written in.

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/text/product-categorize

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/text/product-categorize \
  -H "Authorization: Bearer $KIT_KEY" \
  -H "Content-Type: application/json" \
  -d &#39;{"items":["valor-1","valor-2"]}'

const res = await fetch("https://api.kit.forhosting.com/text/product-categorize", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${process.env.KIT_KEY}`,
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
    "items": [
      "valor-1",
      "valor-2"
    ]
  })
});
const { task_id } = await res.json();

import os, requests

res = requests.post(
    "https://api.kit.forhosting.com/text/product-categorize",
    headers={"Authorization": f"Bearer {os.environ[&#39;KIT_KEY']}"},
    json={
    "items": [
        "valor-1",
        "valor-2"
    ]
},
)
task_id = res.json()["task_id"]

<?php
$res = file_get_contents("https://api.kit.forhosting.com/text/product-categorize", false, stream_context_create([
  "http" => [
    "method"  => "POST",
    "header"  => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
    "content" => &#39;{"items":["valor-1","valor-2"]}',
  ],
]));
$task = json_decode($res, true);

body := bytes.NewBufferString(`{"items":["valor-1","valor-2"]}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/text/product-categorize", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)

Example request

{
  "items": [
    "valor-1",
    "valor-2"
  ]
}

Example response

{
  "task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
  "type": "text.product_categorize",
  "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.003

Per item$0.0135

Published price — no tokens, no invented credits. A failed task is never charged.

Limits

max_tokens 20000

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.

Read the full KIT documentation →