ForHosting KIT · Text & AI

Readability score

Whether a paragraph reads like a technical manual or a friendly email isn't a matter of opinion — it's measurable. The Readability Score API runs your text through established formulas like Flesch Reading Ease and Gunning Fog Index and returns the numbers, so you know exactly who can comfortably read what you wrote.

● StableFree · in your browser

Run — free How it works & API

Use it from WebAPIEmailApp soonTelegram soon

Turning a gut feeling into a number

'This feels too dense' is a hard thing to act on; 'this scores at a graduate reading level when your audience reads at a ninth-grade level' is not. This endpoint exists for that gap — teams writing for a general audience, a specific age group, or a regulatory reading-level requirement need an objective measure they can track over time and enforce as a standard, not a subjective read-through every time.

What a request returns

You send text to POST /text/readability, the task queues, and the engine computes multiple established metrics on the same content — Flesch Reading Ease, Flesch-Kincaid Grade Level, Gunning Fog Index, and related scores that weigh sentence length and syllable or word complexity differently. Results, delivered by signed webhook or a signed link, include each score plus the underlying counts like average sentence length and syllables per word, so you can see why a score landed where it did, not just the final number.

Decades-old formulas, still relevant

Readability formulas date back to the mid-twentieth century, when researchers like Rudolf Flesch and Robert Gunning built them for newspapers, government forms, and military manuals that needed to be understood by readers with varying education levels. The math is simple by design — sentence length and word length as proxies for cognitive load — which is exactly why it has held up as a fast, consistent benchmark decades later, even as the writing it measures has moved from print to web and app copy.

Where readability scoring fits in automation

Readability checks slot naturally after content is drafted or translated and before it ships, often as an automated gate: reject or flag any page that scores above a grade-level threshold for your audience. It also pairs well with proofreading — a paragraph can be grammatically flawless and still score too dense for its intended reader, and only a readability check will catch that.

A flat, predictable price

This endpoint costs $0.002 per request regardless of document length, since the calculation itself is lightweight compared to generative text tasks. There's no per-word component to track, which makes it easy to run readability checks liberally across an entire content library without needing to estimate word counts in advance. As with every task, failed requests are retried up to three times and never billed.

What you can do with it

Content style guide enforcement

Automatically flag any published page that exceeds your target grade level, keeping a large content library consistent as new writers join the team.

Plain-language compliance

Check public-facing forms, notices, or healthcare information against a required reading level before publishing, supporting plain-language requirements.

Email and marketing copy tuning

Score subject lines and body copy before a campaign send to confirm they match the reading level your audience actually responds to.

Educational material grading

Verify that lesson text, quizzes, or worksheets match the intended grade level before they reach students.

FAQ

What readability formulas does the API return?

It returns Flesch Reading Ease, Flesch-Kincaid Grade Level, Gunning Fog Index, and related established metrics computed from the same submitted text.

Is the readability score API free?

The tool above runs free in your browser. The API is paid — each call draws from your prepaid ForHosting KIT balance: top up from $10.00 (it never expires), pay each request's published price, and a call with no balance returns HTTP 402. No subscription, no tokens, and a failed task is never charged.

How is pricing calculated for readability checks?

It's a flat $0.002 per request with no per-word charge, since scoring is computationally lighter than tasks that generate or rewrite text.

What's a good Flesch Reading Ease score?

Higher scores mean easier reading, roughly 90-100 for very simple text and below 30 for dense academic or legal writing; what counts as 'good' depends entirely on your target audience.

Can I check readability in languages other than English?

The core formulas were designed around English syllable and sentence patterns, so results are most reliable for English text; check documentation for current language coverage.

Does it also fix or rewrite my text?

No, it only scores the text you send; pair it with the proofreading endpoint if you also want suggested edits to improve the score.

Can I run readability checks in bulk?

Yes, requests are async with webhook delivery, so you can score an entire site or document library in one batch instead of one page at a time.

What happens if a readability request fails?

It's retried automatically up to three times; if it still fails you get a clear error and are never charged for that request.

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

POSThttps://api.kit.forhosting.com/text/readability

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/readability \
  -H "Authorization: Bearer $KIT_KEY" \
  -H "Content-Type: application/json" \
  -d &#39;{"text":"…"}'

const res = await fetch("https://api.kit.forhosting.com/text/readability", {
  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/readability",
    headers={"Authorization": f"Bearer {os.environ[&#39;KIT_KEY']}"},
    json={
    "text": "…"
},
)
task_id = res.json()["task_id"]

<?php
$res = file_get_contents("https://api.kit.forhosting.com/text/readability", false, stream_context_create([
  "http" => [
    "method"  => "POST",
    "header"  => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
    "content" => &#39;{"text":"…"}',
  ],
]));
$task = json_decode($res, true);

body := bytes.NewBufferString(`{"text":"…"}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/text/readability", 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.readability",
  "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

Per request$0.002

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.

Read the full KIT documentation →

Run — free