Check readability for a target audience by grade level
A readability score is useful only when it is interpreted for the people expected to read the material.
Run — free
This checker takes a computed grade level and a target audience, then compares that number with a clear expected range. It tells you whether the text matches, is too easy, or is too difficult. Use it after any grade-level calculator to turn an abstract score into a consistent editorial decision for public information, technical documentation, or material written for children.
Start with a computed grade level
This capability evaluates a grade level that you already have; it does not analyze raw prose or calculate a readability formula. Supply the numeric result from a tool such as Flesch-Kincaid, together with one supported audience identifier. Fractional values are welcome because readability formulas commonly produce results such as 7.4 rather than whole school grades. The checker preserves that value and compares it against inclusive lower and upper bounds. Children are expected to fit grades 1 through 5, general-public writing grades 6 through 8, and technical material grades 9 through 14. These bands are editorial targets, not claims about an individual reader's education or ability. A score inside the selected band returns a matching assessment. A lower score is marked too easy, while a higher score is marked too difficult. Keeping calculation and audience evaluation separate makes the decision reusable with different scoring systems, provided their output represents a conventional grade level. It also lets a workflow store the original score alongside the policy decision for later review.
Choose the audience that reflects the document's job
Select children when the material is intentionally written for young independent readers, such as classroom instructions, museum activities, or basic safety explanations. Select general_public for services, announcements, help pages, and consumer information that should be understandable without specialist training. Select technical when the reader is expected to know a professional vocabulary and tolerate denser sentence structures, as in engineering notes, API concepts, or research operations. The audience names are exact: children, general_public, and technical. An unfamiliar value produces an input error instead of guessing, because a silent fallback could approve content against the wrong standard. Audience choice should follow the document's purpose, not merely the identity of its author. A software company can publish general-public billing guidance and technical integration documentation, for example, and those pieces deserve different checks. Likewise, a low grade is not automatically better. Text that falls far below a technical range may omit necessary precision, while text above a children's range can prevent the intended readers from acting confidently.
Use the assessment as an editorial signal
The output includes the supplied grade, the selected audience, the exact expected range, a Boolean match, and a compact assessment. A matching result means the number is inside the policy band, including either boundary. Too difficult means editors should look for long sentences, nested clauses, uncommon words, or unexplained terminology before scoring the revision again. Too easy means the text is below the selected band; for technical work, check whether simplification removed distinctions, constraints, or domain terms that readers need. The result is deliberately deterministic: identical inputs always produce identical outputs, with no model judgment, network request, randomness, or changing reference data. That makes it suitable for publishing gates, content-management checks, and repeatable audits. Still, grade level measures surface difficulty rather than factual accuracy, tone, accessibility, or cultural suitability. Treat a match as one piece of evidence, not final approval. Human review remains important for high-impact instructions and for children. When automating, retain the score and assessment so reviewers can see why an item passed or was flagged and can apply a documented exception when necessary.
What you can do with it
Gate public-service content
Flag notices above the general-public range before publication so an editor can simplify them.
Review children's learning material
Check a computed grade against the children's band and identify passages that need revision.
Standardize technical documentation
Apply one explicit reading-level policy across manuals, knowledge bases, and release documentation.
FAQ
Does this calculate a grade level from text?
No. Provide a grade level already computed by a readability formula or another scoring tool.
What ranges are used?
Children use grades 1–5, the general public uses grades 6–8, and technical readers use grades 9–14. Bounds are inclusive.
Can the grade level include decimals?
Yes. Any finite numeric grade from 0 through 20 is accepted and preserved in the result.
What happens with an unknown audience?
The request fails with an invalid-input error rather than choosing a range automatically.
How much does the API check cost?
Each API request costs $0.002. The same deterministic check can run free in the browser.
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/write/readability-by-audience \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"grade_level":7.4,"audience":"general_public"}'const res = await fetch("https://api.kit.forhosting.com/write/readability-by-audience", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"grade_level": 7.4,
"audience": "general_public"
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/write/readability-by-audience",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"grade_level": 7.4,
"audience": "general_public"
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/write/readability-by-audience", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"grade_level":7.4,"audience":"general_public"}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"grade_level":7.4,"audience":"general_public"}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/write/readability-by-audience", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Example request
{
"grade_level": 7.4,
"audience": "general_public"
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "write.readability_by_audience",
"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. |