ForHosting KIT · Translation

Explain slang

Literal translation breaks the moment someone writes 'it's raining cats and dogs' or 'échale ganas'. The Slang Explanation API reads the phrase in context and hands back what it actually means, plus a plain-language equivalent your users will recognize. It's built for support tickets, chat logs, reviews and social captions where idioms show up constantly and machine translation quietly mangles them.

● BetaPer 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 problem with word-for-word translation

Standard translation engines are trained to preserve structure, so idioms come out as nonsense: 'break a leg' becomes an injury warning, 'estar en las nubes' becomes literal weather talk. Anyone processing user-generated content at scale — support queues, forum threads, product reviews — eventually hits a wall of phrases that translate correctly on paper and mean nothing in practice. This endpoint exists for that exact wall, and it exists because fixing it manually, phrase by phrase, doesn't scale past a handful of languages.

What the endpoint actually returns

Send a piece of text and we detect the colloquial expressions inside it, then return each one with its plain meaning, an equivalent phrase in the target register, and a short note on tone (playful, rude, regional, dated). You get the explanation, not just a swapped-in synonym, so a human reviewer or a downstream model can decide how to phrase the final output.

How it fits an automated pipeline

Because the call is asynchronous, you submit the text, receive a task_id immediately, and keep your workers free while we process it. The result lands via signed webhook — the recommended path for pipelines — or through a signed link valid for 24 hours if you prefer to poll. Either way, nothing sits in a queue waiting on a synchronous timeout.

A brief note on where slang comes from

Idiomatic language accumulates from trades, sports, migration and media in ways formal grammar never predicts — 'ghosting' comes from dating culture, 'tirar la toalla' from boxing. That messy, living history is exactly why static dictionaries fail and why this task benefits from a model that reasons about usage rather than looking up fixed translations.

Where it saves the most time

Teams localizing customer support macros, marketing copy with regional flavor, or moderation systems that need to understand intent behind slang (including euphemisms) all use this instead of hand-annotating phrase lists that go stale within a year. The savings compound as content volume grows, since each new batch of text is checked automatically instead of waiting on a bilingual reviewer to flag what a dictionary would miss.

What you can do with it

Support ticket triage

A customer writes 'this app is buggy as heck, total dumpster fire' — the endpoint flags the frustration-coded slang so your routing logic treats it as a high-severity complaint instead of literal garbage-related feedback.

Regional marketing review

Before publishing a campaign in five Spanish-speaking markets, run the copy through the endpoint to catch phrases like 'está chida' or 'qué bacán' that read as slang in some countries and as neutral in others.

Chat moderation context

A moderation model needs to know that 'she's a snake' is an accusation of betrayal, not a literal claim, before deciding whether the message violates policy.

Subtitling and captions

Caption generators pass dialogue through first so idioms get explained rather than transcribed literally, giving human editors a starting point instead of a blank guess.

FAQ

What does the slang translator API actually do?

It identifies idiomatic or colloquial expressions in a text and returns their real meaning plus a plain-language equivalent, instead of translating each word literally.

Is there a free tier?

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 the request priced?

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

What happens if a task fails?

We retry automatically up to three times; if it still fails you get a clear error and you are never charged for it.

How do I get the result?

Via a signed webhook, which we recommend for pipelines, or through a signed link that stays valid for 24 hours if you'd rather poll.

Does it handle regional slang differences?

Yes — the explanation includes a tone and register note, which is where regional flavor (Mexican, Argentine, Caribbean, etc.) typically shows up.

Can I send bulk text with many idioms at once?

Yes, submit longer text in a single call; pricing scales with word count so batching is efficient rather than penalized.

Is my data used to train models?

No. Results are deleted after the retention window and are 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

POSThttps://api.kit.forhosting.com/translate/slang

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

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