Translate formal or informal
The same sentence written for a teenager's app and for a bank's legal notice needs two completely different registers, and 'translate this' alone doesn't tell a model which one to pick. This endpoint takes an explicit formality setting alongside the text, so the output lands on the tone you actually intended instead of whatever default a general translation happens to favor.
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.
Why one language can say the same thing two ways
Spanish, like French, German and many other languages, carries a grammatical distinction English mostly lost: tú versus usted, du versus Sie, tu versus vous. Address a customer as tú in a country where usted is expected for formal correspondence and the message reads as presumptuous or careless; do the reverse in a youth-focused app and it reads as stiff and out of touch. English has its own version of the same problem even without a pronoun switch — 'Hey, quick heads up' and 'We are writing to inform you' translate the same underlying fact at completely different registers, and a translation that ignores that distinction gets the words right and the tone wrong.
What the endpoint expects and returns
POST /translate/formality with the source text, target language, and a formality setting — formal or informal — and a task_id comes back immediately while translation runs in the background, the same asynchronous pattern as every other translation endpoint. The result respects the requested register throughout, not just in an opening greeting, so a long document doesn't drift from usted in paragraph one to tú by paragraph five.
Where formality decisions actually get made today
Style guides at banks, hospitals, government agencies and B2B software vendors already specify a formality register as a matter of policy, often after real customer complaints about a tone that felt wrong for the relationship. Consumer apps aimed at younger users go the other direction deliberately, choosing tú or casual English because formality there reads as distance. Neither choice is universally correct — it depends entirely on audience, country and brand voice — which is exactly why the setting has to be explicit rather than guessed.
Using it as a repeatable setting, not a one-off choice
Because the formality flag is part of every request, a company can standardize it once per audience — informal for app push notifications, formal for legal correspondence — and apply that decision consistently across thousands of translated strings without a translator having to remember the house style each time. At $0.003 per request plus $0.0135 per 1000 words, running the same content through both settings to A/B test tone, or maintaining separate formal and informal versions of the same notice for different markets, stays cheap enough to do routinely instead of once during a big localization project.
What you can do with it
Banking and legal correspondence
A bank translates account notices using the formal usted register consistently, matching the tone customers expect from official financial communication.
Youth-focused app notifications
A consumer app translates push notifications with an informal tú register to match its casual, friendly brand voice in Spanish-speaking markets.
B2B software documentation
A software vendor translates onboarding emails formally for enterprise customers while keeping community forum replies casual and approachable.
Regional tone testing
A marketing team translates the same campaign copy in both formal and informal registers to test which resonates better with a specific market segment.
FAQ
How do I control formality when translating with the API?
POST your text, target language and a formality setting of formal or informal to /translate/formality, then retrieve the result by webhook or a signed link valid for 24 hours.
Is the formality-controlled translation API free?
No, there is no free tier or trial; it costs $0.003 per request plus $0.0135 per 1000 words, and a failed job is never charged.
Which languages support a tú-versus-usted style formality setting?
Languages with a grammatical formality distinction, like Spanish, French and German, apply the setting directly to pronoun and verb choice; other languages adjust register through word choice and phrasing instead.
Does formality apply consistently through a long document?
Yes, the requested register is maintained throughout the translated text rather than only in the opening lines.
Can I get both a formal and an informal version of the same text?
Yes, submit two requests with the same source text and different formality settings to get both versions.
How is this different from tone-preserving translation?
Formality control sets an explicit register you choose; tone-preserving translation instead detects and carries over the tone already present in your source text.
Can I run formality-controlled translation in bulk?
Yes, submit one asynchronous task per text with the desired formality setting attached, and collect each result by webhook as it completes.
Is my text stored after translation?
No, submitted text is deleted after the retention window and is 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/translate/formality \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"text":"…"}'const res = await fetch("https://api.kit.forhosting.com/translate/formality", {
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/translate/formality",
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/translate/formality", 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/translate/formality", 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": "translate.formality",
"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. |