ForHosting KIT · Text & AI

Paraphrase

Two sentences can carry the identical fact and share almost no words, and that's the whole craft this endpoint automates. The paraphrasing api restates what you send it sentence by sentence, so the underlying meaning survives while the exact wording doesn't repeat.

● StablePer request + per 1,000 words$0.003

Run — $0.003 + $0.0135/1,000 words How it works & API

Use it from WebAPIEmailApp soonTelegram soon

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 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

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. 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.

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

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. The output is plain text you can drop straight into a document, citation or draft.

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.

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

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.

Is it free to use?

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.

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.

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.

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.

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.

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/paraphrase

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

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": "…"
  })
});
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[&#39;KIT_KEY']}"},
    json={
    "text": "…"
},
)
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" => &#39;{"text":"…"}',
  ],
]));
$task = json_decode($res, true);

body := bytes.NewBufferString(`{"text":"…"}`)
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": "…"
}

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

Per request$0.003

Per 1,000 words$0.0135

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.

Read the full KIT documentation →