Proofread
A spell checker catches 'teh'; it has no opinion on a dangling modifier or a sentence that runs three clauses too long. 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.
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.
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
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. Failed tasks are retried up to three times and never billed; you only pay for reviews that actually completed.
What you can do with it
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.
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
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.
Is there a free plan?
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.
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.
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.
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.
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.
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/proofread \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"text":"…"}'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": "…"
})
});
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": "…"
},
)
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":"…"}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"text":"…"}`)
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": "…"
}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. |