ForHosting KIT · Text & AI

Make text formal

A quick internal note and a client-facing document demand different levels of polish, and rewriting the former into the latter by hand is tedious and easy to get wrong. The Formal Tone API takes casual, shorthand or conversational writing and returns professional prose, contractions expanded, slang removed, structure tightened, while every fact stays exactly as written. It exists for the moment a draft has to become a deliverable.

● 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 gap between a draft and a document

Most business writing starts casual: a Slack message that becomes a policy, a voice memo transcript that becomes a report, a quick email reply that gets forwarded to a client. Each of those needs a pass toward formality before it can carry a company's name, and doing that pass manually for every piece of internal writing that eventually goes external does not scale past a handful of documents a week.

What formal actually means here

Formalizing is not about inflating vocabulary or adding jargon; it means expanding contractions, replacing colloquialisms with precise terms, correcting register-inappropriate humor or hedging, and restructuring run-on sentences into clear, complete ones. The result reads the way a careful professional writer would draft it the first time, not like a casual note with a thesaurus pass applied on top.

How the endpoint behaves

Send the source text to POST /text/formalize and receive a task_id right away while the rewrite runs asynchronously. The engine parses tone markers, contractions and informal constructions in the source, then reconstructs the passage in professional register while keeping names, figures and claims untouched. Completion triggers a signed webhook, or you can retrieve the result from a signed link that remains valid for 24 hours.

Common entry points into a workflow

Legal and compliance teams run draft clauses through it before circulating for signature, catching a stray contraction or a too-casual aside before a lawyer ever sees the document. Customer success teams formalize a quick internal explanation before it becomes a client-facing email, so the tone matches the rest of the account relationship. Documentation teams convert engineer-written notes, useful but rough around the edges, into text that belongs in a shipped manual, all without a human editor rewriting the passage from scratch every single time a feature ships.

Cost and reliability, plainly stated

Pricing is $0.003 per request plus $0.0135 per 1,000 words, charged only when a task succeeds; three automatic retries handle transient failures before a clear error is returned, and a failed task is never billed. Because there is no free tier, the endpoint stays fast for paying integrations instead of being clogged by unmetered test traffic.

What you can do with it

Internal note to client email

A support agent formalizes a quick internal explanation into polished client-facing language before hitting send.

Meeting transcript to formal minutes

An operations team runs a raw voice-to-text meeting transcript through the API to produce minutes suitable for circulation to stakeholders.

Contributor notes to shipped documentation

A docs team formalizes engineer-authored release notes so they read consistently with the rest of the professional documentation set.

Draft policy to official wording

An HR team turns a casual first draft of a new policy into the formal language required before legal review.

FAQ

How do I make text formal with an API?

Send your text to POST /text/formalize; the task runs asynchronously and returns a task_id immediately, with the rewritten result delivered by webhook or signed link.

Is the formalize endpoint 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 formalizing text cost?

$0.003 per request plus $0.0135 per 1,000 words, billed only for tasks that complete successfully.

Will formalizing change my meaning or facts?

No, it changes register, contractions and sentence structure only; names, numbers and claims are preserved exactly.

What languages are supported?

The engine formalizes text in the language it receives and returns the rewrite in that same language.

How is this different from grammar correction?

Grammar correction fixes errors; formalizing goes further, elevating register and restructuring casual phrasing into professional prose even when the original was grammatically correct.

How do I receive the formalized result?

Via a signed webhook call when the task completes, or by fetching a signed link valid for 24 hours.

Can I formalize many documents in bulk?

Yes, each call is independent and asynchronous, so you can submit as many documents as needed and track each by its own task_id.

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

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

const res = await fetch("https://api.kit.forhosting.com/text/formalize", {
  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/formalize",
    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/formalize", 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/formalize", 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.formalize",
  "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 →