Simplify text
A legal clause, a medical instruction, a paragraph of internal jargon: some text is written for specialists and needs to reach everyone else too. The simplify text api rewrites dense material into plain language, keeping the facts intact while dropping the barriers to reading it.
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.
Who plain language actually serves
Plain language isn't about dumbing content down; it's about removing unnecessary difficulty for readers who are rushed, unfamiliar with a field's jargon, reading in a second language, or simply want the point without the padding. text.simplify targets exactly that audience, shortening sentences, replacing specialist vocabulary with everyday words, and untangling nested clauses without cutting any actual information, so the reader ends up with less effort and the same substance.
What the endpoint does with your text
Submit text to POST /text/simplify and receive a task_id right away, since the endpoint runs asynchronously rather than holding your request open while it works. The engine breaks long, compound sentences into shorter ones, swaps technical or bureaucratic terms for plainer equivalents, and flattens complicated structure into something a general reader can follow on a first pass, checking as it goes that no instruction or condition from the original gets dropped in the process.
Plain language has a real policy history
Plain-language writing became a formal movement in government and legal communication decades ago, driven by the recognition that dense official writing keeps people from understanding documents that directly affect them, from tax forms to consent notices. This endpoint applies that same discipline programmatically, wherever your content needs to clear the same bar for an ordinary reader, not just a specialist one.
How you receive the simplified version
Once the task finishes, a signed webhook delivers the result, or you can pull it from a signed link that stays valid for 24 hours. What comes back is plain text, ready to publish as-is or to sit alongside the original as an accessible alternative.
Putting it to work across content
Because each call is tracked by its own task_id, text.simplify scales across large document sets: simplify an entire help-center library in one batch, or trigger a single simplification the moment a policy document is updated. It works well paired with the shorten endpoint when a piece of content needs to be both plainer and briefer, and the signed webhook delivery means the simplified pages can go live automatically as soon as each task finishes.
What you can do with it
Accessible help documentation
Rewrite a technical support article into plain language so non-expert users can follow the steps without extra explanation.
Legal and policy summaries
Turn a dense terms-of-service clause into a plain-language version to sit alongside the original for readers who want clarity fast.
Onboarding for new users
Simplify feature descriptions written by engineers into copy a first-time user can understand without a glossary.
Content for second-language readers
Simplify sentence structure and vocabulary in public-facing content to make it easier to follow for non-native speakers.
FAQ
What does the simplify text api actually change?
It shortens sentences, replaces technical or complex vocabulary with everyday words, and simplifies structure, without removing any real information.
Is there a free trial?
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.
How is it priced?
$0.003 per request plus $0.0135 per 1,000 words processed, charged only when a task completes successfully.
Do failed tasks get billed?
No. Tasks retry automatically up to three times and are never charged on failure; you get a clear error instead of a silent charge.
How do I get the simplified text?
Via a signed webhook the moment the task completes, or a signed link valid for 24 hours if polling suits you better.
Can I simplify a whole batch of documents?
Yes, POST /text/simplify is asynchronous and returns a task_id per call, so you can process many documents in parallel.
Does simplifying lose important details?
No, the goal is clearer wording and structure while preserving every fact and instruction from the original.
Is submitted content used to train models?
No, content is retained only for the retention period needed to deliver your result, then deleted, and never used for training.
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/simplify \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"text":"…"}'const res = await fetch("https://api.kit.forhosting.com/text/simplify", {
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/simplify",
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/simplify", 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/simplify", 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.simplify",
"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. |