Check spelling
A single sentence with three typos can quietly undermine an entire landing page or product listing. The Spell Check API scans raw text in dozens of languages and returns every suspected misspelling with ranked suggestions, so you can fix it before a human ever sees it.
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 pipelines, not just proofreaders
Most spell checkers assume a person is sitting in front of a document. This one assumes the opposite: a script, a CMS, a translation pipeline, or a support-ticket queue is submitting thousands of strings a day and needs a structured answer, not a red squiggly underline. Each request returns machine-readable offsets and candidates, so downstream code can auto-apply a fix, flag it for review, or silently log it.
What actually happens to your text
You send text in a request to POST /text/spellcheck, the task queues, and the engine tokenizes the content, checks each word against language-specific dictionaries and statistical models, and scores likely errors versus intentional brand names, slang, or code fragments. The result lists each flagged token, its position, and up to a handful of ranked corrections, delivered to your signed webhook or a signed link that stays valid for 24 hours.
Spelling has never been static
Dictionaries are living documents: new loanwords, product names, and internet shorthand enter usage constantly, and regional spelling diverges even within the same language, as anyone who has argued about 'color' versus 'colour' knows. Good automated spell checking has to balance strict dictionary matching against the reality that language keeps moving, which is why suggestions are ranked rather than absolute.
Where it fits in a larger workflow
Spell checking rarely runs alone. Teams chain it before a proofreading pass for lighter-weight, faster triage, or after OCR and transcription jobs where recognition errors look exactly like typos. Because every call is async with a task_id, you can fire off a batch of thousands of documents overnight and collect results in one pass instead of polling a synchronous endpoint one string at a time.
Pricing that matches the work done
You're charged $0.003 per request plus $0.0135 per 1,000 words processed, calculated only on text actually analyzed. A request that fails outright — malformed payload, unsupported encoding — is never billed; the system retries transiently failed jobs up to three times before returning a clear error, so you're never paying for a task that produced nothing. That transparent, per-word structure makes it easy to forecast the cost of checking an entire archive of documents before you even start the batch, rather than discovering the bill after the fact.
What you can do with it
Pre-publish content gate
Run every blog post or product description through the API before it goes live, auto-blocking publication when flagged-word density crosses a threshold you set.
Support ticket cleanup
Scrub incoming customer messages before they're indexed into a knowledge base, so search and analytics aren't thrown off by 'recieve' matching nothing.
Multilingual catalog QA
Batch-check product titles and descriptions across a dozen storefront languages after a bulk import, catching typos a single-language reviewer would miss.
User-generated content moderation
Flag comments or reviews with unusually high misspelling rates as a low-cost signal for spam or bot-generated text alongside your other checks.
FAQ
How do I call the spell check API?
Send a POST request to /text/spellcheck with your text and language hint if known; the task runs asynchronously and returns a task_id you use to fetch results by webhook or signed link.
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.
Which languages are supported?
The engine covers dozens of major languages with dedicated dictionaries; mixed-language text is handled per detected segment rather than forcing one language for the whole document.
Does it also fix grammar?
No — spell check focuses purely on misspelled words and suggested corrections. For grammar, style, and clarity together, use the proofreading endpoint instead.
How is pricing calculated?
It's $0.003 per request plus $0.0135 per 1,000 words analyzed, billed only on completed tasks, with pricing published and predictable for budgeting bulk jobs.
What happens if a request fails?
Failed tasks are retried automatically up to three times; if all retries fail you get a clear error and are never charged for that task.
Can I run this on thousands of documents at once?
Yes — the async design with webhook delivery is built exactly for bulk batches; queue as many requests as you need and collect results as they complete.
How long are results available?
Signed result links stay valid for 24 hours, and webhook delivery is recommended for anything you need to process immediately or store on your side; data is deleted after retention and never used 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/spellcheck \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"text":"…"}'const res = await fetch("https://api.kit.forhosting.com/text/spellcheck", {
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/spellcheck",
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/spellcheck", 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/spellcheck", 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.spellcheck",
"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. |