Paraphrase
Send a passage and get it back restated sentence by sentence: the same claims and roughly the same length, with different words and sentence construction. Every idea stays traceable, so nothing is added or dropped. You pay per use, with no subscription.
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.
The paraphrasing api restates what you send it sentence by sentence, so the underlying meaning survives while the exact wording doesn't repeat.
The same idea in different words
Two sentences can carry the identical fact and share almost no words, and that is exactly what this tool produces. It works close to the sentence level, swapping synonyms and restructuring clauses while keeping every original claim traceable, so a reader comparing both versions side by side can confirm that nothing was added or dropped. The term comes from classical rhetoric, where paraphrasis meant retelling a passage in one's own words as an exercise in comprehension and style. It is distinct from a summary, which compresses, and from a translation, which crosses languages: the result has roughly the same length and the same ideas, only with different wording.
When accuracy to the source matters
Researchers and students use it to restate a passage from a source while keeping the claim accurate, ready to be cited properly; paraphrasing does not replace the citation. Content teams use it when a product description sits too close to a competitor's public copy, or to restate several source snippets before combining them into one article, so the result is not a patchwork of quotations. Teachers can turn dense reading material into a paraphrased version that students compare with the original to check their understanding. If you want a new voice rather than faithful wording, a rewrite is the better choice.
What you can do with it
Academic and research citation
Restate a passage from a source in different words while keeping the original claim accurate, ready for proper citation.
Avoiding near-duplicate content
Paraphrase a product or category description that's too close in wording to a competitor's public copy before publishing.
Study aid generation
Turn dense reading material into a paraphrased version students can compare against the original to check comprehension.
Multi-source content assembly
Paraphrase several source snippets before combining them into one article, so the final piece isn't a patchwork of quoted text.
FAQ
Is it free to use?
There's no free tier — free tiers get abused and slow everyone down. No subscription, no tokens, no invented credits, and a failed task is never charged.
Do I pay for failed tasks?
No. Every task gets up to three automatic retries and is never charged on failure; you get a clear error instead.
Will the paraphrase change the meaning?
No, the goal is to keep every original claim intact; only the wording and sentence structure change.
Is my text stored or used for training?
It's retained only for the retention window needed to deliver your result, then deleted, and never used to train models.
How is paraphrasing different from summarizing or rewriting?
A summary compresses and a rewrite changes the tone or voice. A paraphrase keeps the same ideas and roughly the same length, and only changes the words and the way the sentences are built.
Related tools
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/text/paraphrase \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"text":"El informe trimestral cerró con 1,2 M€ de ingresos."}'const res = await fetch("https://api.kit.forhosting.com/text/paraphrase", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"text": "El informe trimestral cerró con 1,2 M€ de ingresos."
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/text/paraphrase",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"text": "El informe trimestral cerró con 1,2 M€ de ingresos."
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/text/paraphrase", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"text":"El informe trimestral cerró con 1,2 M€ de ingresos."}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"text":"El informe trimestral cerró con 1,2 M€ de ingresos."}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/text/paraphrase", 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": "El informe trimestral cerró con 1,2 M€ de ingresos."
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "text.paraphrase",
"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. |
Technical notes
Two sentences can carry the identical fact and share almost no words, and that's the whole craft this endpoint automates.
The specific gap this fills
Researchers citing a source, students summarizing reading material, and content teams adapting a competitor's public description into their own words all need the same narrow thing: the same idea, expressed with different words and sentence construction, not a summary and not a stylistic overhaul. text.paraphrase is built for that narrow, precise task rather than the broader tone work a rewrite handles, which is why it's the endpoint to reach for when accuracy to the source matters more than reinventing its voice.
How the mechanics work
Internally, the engine works close to the sentence level, swapping synonyms, restructuring clauses and changing sentence order while keeping every original claim traceable in the output, so a reader comparing the two versions side by side can confirm nothing was added or dropped. Send text to POST /text/paraphrase and get a task_id back immediately, because the endpoint is asynchronous and never makes your application wait on the response.
Paraphrase has always meant close restatement
The term goes back to classical rhetoric, where paraphrasis meant retelling a passage in one's own words as a discipline for both comprehension and style, distinct from summary, which compresses, and from translation, which crosses languages. This endpoint keeps that original, narrow definition: same length roughly, same ideas, different words.
Delivery once the task finishes
The output is plain text you can drop straight into a document, citation or draft. You'll receive the paraphrased text through a signed webhook as soon as processing completes, or you can retrieve it from a signed link that stays valid for 24 hours.
Automating it at scale
Since every call returns its own task_id, text.paraphrase fits naturally into pipelines that need many independent restatements: paraphrase a batch of source excerpts for a research tool, or generate a paraphrased version of a single passage the moment a plagiarism check flags it as too close to a source. It sits well alongside rewrite and simplify endpoints when a document needs several kinds of transformation, and since results arrive by webhook there's no polling loop to babysit while a large batch works through the queue.
Technical questions
How does the paraphrasing api differ from a summary?
Paraphrasing restates content in different words at roughly the same length; summarizing compresses it into fewer words, which this endpoint doesn't do.
What does it cost?
$0.003 per request plus $0.0135 per 1,000 words processed, and you're billed only on successfully completed tasks.
How is the result delivered?
Through a signed webhook when the task finishes, or a signed link valid for 24 hours if you'd rather poll for it.
Can I paraphrase large volumes of text?
Yes, POST /text/paraphrase is asynchronous and returns a task_id per call, so you can submit many requests at once and collect results as they arrive.