ForHosting KIT · SEO

SEO readability score

Search engines don't grade readability directly, but readers do, and they leave when a page fights them. This endpoint scores a piece of text for how easily it reads — sentence length, structural density, plain-language use — and returns a clear number plus the sections dragging it down.

● StableFree · in your browser

Run — free How it works & API

Use it from WebAPIEmailApp soonTelegram soon

Why readability quietly affects rankings

Nobody optimizes a page and then watches half the visitors bounce within ten seconds on purpose, but that's what a dense, jargon-heavy page does. Time on page and bounce behavior feed back into how a page performs in search over time, even though readability itself isn't a stated ranking factor — it's an input to the outcomes that are. This endpoint exists for the writer, editor or reviewer who wants a number to point to instead of a vague feeling that a paragraph is 'too much.'

What actually gets measured

The score is built from sentence length distribution, paragraph density, passive construction frequency and word complexity — the same underlying signals readability formulas have used since Rudolf Flesch first published his reading-ease work in 1948. What's different here is that the response doesn't just hand you one number; it flags the specific sentences and sections pulling the score down, so the fix is obvious instead of a guessing game across a thousand words.

Who this is actually for

Technical writers translating dense subject matter for a general audience use it to check they haven't smuggled jargon past themselves. Editors reviewing freelance submissions use it as one more objective checkpoint alongside tone and accuracy. Legal, medical and financial content teams — where clarity has real consequences — use it to catch sentences that are technically correct but functionally unreadable before publication.

What a good score doesn't guarantee

A high readability score means the sentences are easy to parse; it says nothing about whether the content is accurate, complete or genuinely useful — those still require a human read-through. Treat the score as a filter for one specific failure mode, not a stamp of overall quality.

Fitting it into review workflows

Because the request is lightweight and asynchronous, it's cheap enough to run on every draft before it goes to an editor, catching dense paragraphs before a human ever has to flag them by hand. Results arrive by signed webhook or a 24-hour signed link, and submitted text is deleted after the retention window and never used for training.

What you can do with it

Pre-publish editorial gate

A CMS runs every draft through the readability check automatically and flags anything scoring below a set threshold before it reaches an editor.

Simplifying technical documentation

A software company scores its help-center articles and finds the three guides written by engineers are the hardest to read — and rewrites them first.

Auditing an existing content library

A marketing team batches its 200 highest-traffic blog posts through the endpoint to find which older articles need a plain-language pass.

Freelance submission review

An editor runs a contributor's draft through the check before reading it in full, to know upfront whether dense passages need a rewrite request.

FAQ

How does the SEO readability score API calculate its score?

It analyzes sentence length, paragraph density, passive voice frequency and word complexity to produce a single readability score plus the specific sections dragging it down.

Is readability actually a Google ranking factor?

Not directly, but it influences behavior signals like time on page and bounce rate that do affect how content performs, which is why it's worth measuring honestly.

Is there a free version?

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.

What does it cost?

A flat $0.002 per request, regardless of text length.

What languages does it work with?

It analyzes the text you submit as written; submit content in the language you want scored.

Can I check a whole batch of articles at once?

Yes, since requests are async and lightweight, you can queue as many texts as you have and collect results as they complete.

Does a good score guarantee good content?

No, it only measures how easy the text is to parse — accuracy, completeness and usefulness still require human judgment.

How fast do I get results?

Results are delivered asynchronously by signed webhook or a signed link valid for 24 hours after the task completes.

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

const res = await fetch("https://api.kit.forhosting.com/seo/readability", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${process.env.KIT_KEY}`,
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
    "input": "…"
  })
});
const { task_id } = await res.json();

import os, requests

res = requests.post(
    "https://api.kit.forhosting.com/seo/readability",
    headers={"Authorization": f"Bearer {os.environ[&#39;KIT_KEY']}"},
    json={
    "input": "…"
},
)
task_id = res.json()["task_id"]

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

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

{
  "input": "…"
}

Example response

{
  "task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
  "type": "seo.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.

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.
`413`	`input_too_large`	The file exceeds the size limit.

Read the full KIT documentation →

Run — free