Check spelling
A product title that says «recieve» gets flagged with its exact position and ranked corrections, while brand names and slang are weighed before being called errors. It checks text in dozens of languages, in large batches. You pay per use, with no subscription.
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.
A single sentence with three typos can quietly undermine an entire landing page or product listing.
Built for text that arrives in bulk
Most spell checkers assume a person is sitting in front of a document. This one assumes the opposite: a content system, a translation pipeline or a support queue is sending thousands of strings a day and needs a clear answer, not a red squiggly underline. Each word is checked against language-specific dictionaries and statistical models, and every suspected misspelling comes back with its position and a handful of ranked corrections. That lets you apply a fix automatically, flag it for a person to review or simply log it, so a single sentence with three typos no longer slips onto a landing page.
Why suggestions are ranked, not absolute
Dictionaries are living documents. New loanwords, product names and internet shorthand enter use constantly, and spelling differs by region even within one language, as anyone who has argued about color versus colour knows. Good automated checking balances strict dictionary matching against a language that keeps moving, which is why suggestions are ranked. Spell checking rarely runs alone: teams use it as a fast first pass before a fuller proofread, or right after scanning and transcription, where recognition errors look exactly like typos. A high misspelling rate in comments can also be a cheap extra signal of spam or bot-generated text.
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.
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.
What you can do with it
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
Is there a free tier?
There's no free tier — free tiers get abused and slow everyone down. 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.
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.
Will it flag brand names and slang as mistakes?
It tries not to. Each word is checked against language-specific dictionaries and statistical models that weigh likely errors against intentional brand names, slang or code fragments, and suggestions come ranked rather than as one forced fix, so you decide.
Related tools
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, by email and from Telegram — and soon from our app too.
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":"El informe trimestral cerró con 1,2 M€ de ingresos."}'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": "El informe trimestral cerró con 1,2 M€ de ingresos."
})
});
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": "El informe trimestral cerró con 1,2 M€ de ingresos."
},
)
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":"El informe trimestral cerró con 1,2 M€ de ingresos."}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"text":"El informe trimestral cerró con 1,2 M€ de ingresos."}`)
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": "El informe trimestral cerró con 1,2 M€ de ingresos."
}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. |
Technical notes
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.
Built for pipelines, not just proofreaders
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.
Where it fits in a larger workflow
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.
Integration use cases
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.
Technical questions
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.
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.
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.