Extract keywords
Most 'keyword tools' just count word frequency and call it a day. This keyword extraction API reads a passage the way an editor would, surfacing the phrases that carry the meaning of the text rather than the ones that simply repeat the most. Send an article, a product page or a transcript to POST /text/extract-keywords and get back a ranked list you can drop straight into a CMS field, a search index or a tagging pipeline.
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.
Built for people who tag content at volume
Content teams, SEO managers and marketplace catalogs all hit the same wall: a human can read one article and pick good keywords in thirty seconds, but nobody has thirty seconds times ten thousand articles. This endpoint exists for exactly that gap — bulk, unattended tagging of blog posts, product descriptions, support articles or scraped web pages, where consistency across thousands of documents matters more than any single perfect keyword list.
What the model actually returns
The response is a ranked array of keyword strings, each attached to a relevance score, so you can decide your own cutoff — top 5 for a meta tag, top 20 for an internal search index. The extraction favors multi-word phrases over single generic nouns whenever the phrase carries more specific meaning, because 'commercial real estate financing' is a far more useful tag than the word 'financing' on its own.
Why frequency counting was never enough
Early keyword tools, going back to the first generation of SEO software in the 1990s, worked by counting how often a word appeared and assuming frequency equaled importance. That approach reliably surfaced stopwords, brand boilerplate and repeated legal disclaimers as 'top keywords', which is why so many auto-generated tag clouds look useless. Reading for salience instead of frequency is the whole point of this endpoint.
What happens after you submit a request
Because extraction runs on a queue, the call returns a task_id immediately and the actual keyword list arrives afterward — either pushed to your signed webhook the moment it's ready, or held behind a signed link valid for 24 hours if you'd rather poll. Nothing about the shape of your source text is stored past the retention window, and it is never used to train anything.
Where it slots into a pipeline
Because the endpoint is a single stateless call, it drops cleanly into ingestion pipelines: a CMS webhook that fires on publish, a nightly batch job over a product catalog, or a queue worker that tags scraped articles before they hit a search index. You pay per request plus a small per-word rate, so a one-line product blurb costs a fraction of what a five-thousand-word report costs — there's no flat per-document tax.
What you can do with it
Auto-tagging a blog archive
Run every published post through the endpoint once to backfill a tags field that was never populated consistently by different authors.
Search index enrichment
Extract 10-15 keywords per product description and feed them into a search engine's synonym or boost fields to improve on-site search relevance.
Editorial QA before publishing
Check that a draft's extracted keywords actually match the target keyword you briefed the writer for, catching topic drift before it goes live.
Deduplicating a scraped dataset
Cluster thousands of scraped articles by their extracted keyword sets to spot near-duplicate content before it's indexed.
FAQ
How do I call the keyword extraction API?
Send a POST request to /text/extract-keywords with your text in the body; the call returns a task_id immediately and the ranked keyword list arrives by webhook or a signed link once processing finishes.
Is there a free tier?
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 keyword extraction cost?
Pricing is $0.003 per request plus $0.0135 per 1,000 words of input, billed only on tasks that actually complete — a failed task is never charged.
What languages does it support?
The endpoint processes text regardless of language and returns keywords in the language of the source, so a Spanish article yields Spanish keywords.
Can I extract keywords in bulk?
Yes — each call is a single independent task, so you queue as many documents as you need in parallel and collect the results as each webhook fires.
How many keywords does it return?
The response includes a ranked list with relevance scores rather than a fixed count, so you choose your own cutoff depending on whether you need a tight meta-tag set or a broader index.
How is this different from a frequency-based keyword tool?
Frequency counters flag whatever word repeats most, including stopwords and boilerplate; this endpoint ranks phrases by how much meaning they carry in context, which is why generic filler rarely surfaces at the top.
How long are results kept?
Results sit behind a signed link for 24 hours and are deleted after the retention window; your text is never stored for training.
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/text/extract-keywords \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"text":"…"}'const res = await fetch("https://api.kit.forhosting.com/text/extract-keywords", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"text": "…"
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/text/extract-keywords",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"text": "…"
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/text/extract-keywords", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"text":"…"}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"text":"…"}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/text/extract-keywords", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Example request
{
"text": "…"
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "text.extract_keywords",
"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_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. |