Extract entities
Raw text is full of facts that never make it into a database — who was mentioned, which companies came up, what dates and places anchored the conversation. This named entity recognition API pulls those facts out as structured data, turning a pile of unread documents into something you can filter, join and search.
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 gap between text and structured data
A support transcript, a news article or a contract mentions dozens of specific things — a person's name, an organization, a city, a date — but none of that is queryable until someone or something extracts it. Reading every document by hand doesn't scale past a few dozen; a database query can't search inside free text at all. text.extract-entities sits exactly in that gap, converting unstructured writing into a list of typed, structured mentions.
What comes back
You submit text to POST /text/extract-entities, the task runs asynchronously, and the result is a list of entities grouped by type — people, organizations, locations, dates, and other standard categories — each with its position in the source text. That positional detail is what makes the output useful beyond a simple word list: you can highlight the exact mention in the original document, link it to a database record, or count how often a specific company or person comes up across a whole archive.
A field with real history behind it
Named entity recognition has been a core natural language processing task since the 1990s, originally built for tasks like scanning newswire for company names and stock tickers. What's changed since then isn't the goal — pull out the people, places and organizations — but the accuracy and the range of text it can handle: informal writing, mixed languages within one document, and entities that only make sense given surrounding context rather than fixed capitalization rules. That evolution is why modern extraction handles a casual chat log about as well as a formal press release.
Where it plugs into other tools
Entity extraction rarely stands alone — it's usually the step that feeds a search index, a knowledge graph, or a deduplication pipeline that needs to know two mentions of a company name refer to the same entity. Combined with something like text.detect-pii, it can also separate business-relevant entities from personal ones inside the same document, which matters when only part of what's mentioned should end up in an analytics system.
Running it at scale
Results are delivered by signed webhook by default, so a pipeline can extract entities from every new document the moment it lands, or by signed link valid for 24 hours for batch and one-off runs. Pricing is $0.003 per request plus $0.0135 per 1000 words processed. There's no free tier or trial balance — prepaid balance is required, requests without either return HTTP 402 — and a task that ultimately fails after three automatic retries is never charged.
What you can do with it
Building a searchable archive
Extract people, companies and locations from years of documents to power filtering and search beyond plain keyword matching.
Media and content monitoring
Pull out which organizations and people are mentioned across articles or transcripts to track coverage over time.
Contract and document review
Automatically identify parties, dates and locations named across a batch of contracts before a manual review pass.
Knowledge graph construction
Feed extracted entities and their positions into a graph structure that links mentions of the same person or organization across documents.
FAQ
What does named entity recognition actually extract?
It pulls typed mentions out of text — people, organizations, locations, dates and similar categories — along with each entity's position in the source document.
How do I use the entity extraction API?
Submit text to POST /text/extract-entities, receive a task_id, and get back the structured list of entities via webhook or signed link once processing completes.
Is there a free tier for entity extraction?
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 is entity extraction priced?
It costs $0.003 per request plus $0.0135 per 1000 words processed, and a task that fails after its automatic retries is never charged.
Can it process a large batch of documents at once?
Yes, submissions run asynchronously, so bulk batches of documents or transcripts are processed in the background and results arrive as they finish.
What entity types does it recognize?
Standard categories including people, organizations, locations and dates, extracted from context rather than fixed capitalization or formatting rules.
How is this different from PII detection?
Entity extraction surfaces all named mentions for structuring and search, while text.detect-pii specifically flags personal data for compliance and privacy purposes.
Does it work on informal or non-English text?
It reads surrounding context rather than relying on strict grammar or capitalization, which lets it handle informal writing and multiple languages.
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-entities \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"text":"…"}'const res = await fetch("https://api.kit.forhosting.com/text/extract-entities", {
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-entities",
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-entities", 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-entities", 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_entities",
"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. |