Proofread
A spell checker catches 'teh'; this review also flags the dangling modifier and the sentence that runs three clauses too long. Grammar, spelling, punctuation, style and clarity are checked together, and every suggested edit comes with its reason. 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 spell checker catches 'teh'; it has no opinion on a dangling modifier or a sentence that runs three clauses too long.
What a spell checker cannot see
A spell checker catches 'teh', but it has no opinion on a dangling modifier or a sentence that runs three clauses too long. Traditional editing stacks tools: a spell checker here, a grammar plugin there, a style guide someone half-remembers and a final human read for clarity. This review brings those layers together, looking at grammar, spelling, punctuation, style and clarity at once. It reads sentences and paragraphs as units, so it catches subject-verb disagreement, awkward passive voice, redundant phrasing and pronouns whose reference is unclear, which word-by-word checkers miss entirely.
Edits you can accept, adjust or ignore
Each suggestion is tied to its exact place in the text and comes with a short reason, so you decide what to keep. Good proofreading has always looked at the writer's intent, not only at surface correctness: a sentence can be technically correct and still bury its point in a subordinate clause. Teams use it to give colleagues writing in a second language an itemized list of grammar and clarity issues before a report or client email goes out, to polish translated copy that is grammatical but does not read naturally, and to review long documents and knowledge-base articles on a schedule so quality does not drift as many people edit them.
What you can do with it
Non-native writer support
Give team members writing in a second language a clear, itemized list of grammar and clarity issues before they submit a report or client-facing email.
Translated content polish
Run machine- or human-translated copy through proofreading to catch awkward phrasing that's grammatically valid but doesn't read naturally in the target language.
Long-form document QA
Batch-proofread whitepapers, documentation, or knowledge-base articles on a schedule so quality doesn't quietly drift as multiple contributors edit over time.
FAQ
Is there a free plan?
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.
Does it rewrite my text automatically?
No, it returns suggested edits with their location and rationale so you decide what to apply; it does not silently overwrite your original content.
What if a proofreading task fails?
It's retried automatically up to three times; if it still can't complete you get a clear error and no charge for that task.
Should I run spell check first or proofreading first?
Either works, but many teams run spell check as a fast, cheap first pass and reserve full proofreading for drafts that are closer to final, since it evaluates deeper structural and style issues.
Is it useful for translated text?
Yes. It catches awkward phrasing that is grammatically valid but does not read naturally in the target language, whether the translation was done by a person or by a machine.
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/proofread \
-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/proofread", {
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/proofread",
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/proofread", 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/proofread", 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.proofread",
"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 Proofreading API reviews grammar, spelling, punctuation, style and clarity together, returning specific edits and the reasoning behind each one so you can accept, adjust, or ignore them.
One pass instead of five separate checks
Traditional editing workflows stack tools: a spell checker here, a grammar plugin there, a style guide someone half-remembers, and a final human read-through for clarity. This endpoint collapses that into a single request. It doesn't just flag isolated word-level errors — it looks at sentences and paragraphs as units, catching subject-verb disagreement, awkward passive voice, redundant phrasing, and unclear pronoun references that word-by-word checkers miss entirely.
How a request becomes a set of edits
You submit text to POST /text/proofread, the task queues, and the engine parses the document for grammatical structure, compares phrasing against clarity and concision norms, and produces a set of suggested edits, each anchored to its exact location with a short rationale. Results are delivered to your signed webhook or a signed link valid for 24 hours, structured so you can render them as inline suggestions or apply them programmatically.
Proofreading as a craft, not a checklist
Professional proofreading has always distinguished itself from copyediting and spell checking by looking at the writer's intent, not just surface correctness — a technically correct sentence can still be a bad one if it buries the point in a subordinate clause. That's the standard this endpoint aims for: fixes come with enough context that you can tell the difference between a genuine error and a stylistic choice worth keeping.
Fitting proofreading into a real pipeline
Teams typically run this after a first draft is generated or translated and before publication, treating it as the quality gate rather than the first filter — lighter, cheaper checks like spelling or punctuation restoration can run earlier to catch obvious issues before the fuller proofreading pass. Because it's async and webhook-driven, you can trigger it automatically whenever a document status changes in your CMS, without a human needing to remember to run it.
Pricing tied to actual review depth
Failed tasks are retried up to three times and never billed; you only pay for reviews that actually completed. The cost is $0.003 per request plus $0.0135 per 1,000 words, the same transparent structure across text tasks in the catalog, so budgeting a large content review is a matter of multiplying word count rather than guessing at token consumption.
Integration use cases
Pre-publish editorial gate
Route every draft through the API before it goes to a human editor, so reviewers spend their time on judgment calls instead of catching comma splices.
Technical questions
How is proofreading different from a spell checker?
Spell checking flags misspelled words in isolation; the proofreading API also evaluates grammar, punctuation, sentence structure, and clarity, catching issues that are grammatically correct but poorly phrased.
What languages does the proofreading API support?
It supports major languages with dedicated grammar and style handling per language rather than applying English rules to translated text.
How much does it cost to proofread a full document?
It's $0.003 per request plus $0.0135 per 1,000 words, so a 2,000-word document costs a small, predictable amount regardless of how many issues it contains.
Can I proofread hundreds of documents at once?
Yes, the async design supports bulk batches; queue as many requests as needed and collect results via webhook as each one finishes.