Convert text to leetspeak
Turn text into 1337 speak and decide how much changes: at medium, 16 of the 31 eligible letters in the sample sentence become digits, while light touches every third one and extreme all of them. Same text, same result, every time. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Worked example
- Text
- Leetspeak replaces letters with look-alike digits.
- Intensity
- Medium
- Output
- 1e3t5pe4k rep1ac3s 1e7t3rs w1th 1o0k-a1ik3 dig1t5.
- Eligible
- 31
- Replaced
- 16
The leetspeak converter rewrites any text by swapping letters for their classic 1337 look-alikes — a becomes 4, e becomes 3, t becomes 7 — but unlike an all-or-nothing translator it lets you dial in how much of the text is converted. Choose light to touch roughly a third of the eligible letters, medium for half, or extreme to convert every single one. The substitution is fully deterministic, so the same input and intensity always produce the same output, which makes it safe to use in pipelines, tests and generated content.
What leetspeak is and why intensity matters
Leetspeak, also written 1337 or leet, is the alphabet of substitutions that grew out of early bulletin board culture: letters are replaced by digits and symbols that resemble them, so 'elite' becomes '3l1t3'. Most converters treat this as binary — either a letter is replaced everywhere or nowhere — which produces output that is either unreadable or indistinguishable from the original. Real-world uses rarely sit at those extremes.
A gamer tag wants full conversion to look the part; a password hint or a stylized headline wants just a sprinkle, enough to signal the style without sacrificing legibility. The leetspeak converter exposes that middle ground through a single intensity parameter. Light intensity substitutes every third letter that has a leet equivalent, medium substitutes every second one, and extreme substitutes all of them.
Because the decision is based on the position of each letter among the eligible ones, the result is stable: run it twice with the same text and intensity and you get exactly the same string, byte for byte, with no randomness involved anywhere in the process.
How the substitution engine works
The converter walks the input string once, character by character, with a fixed classic table: a to 4, e to 3, i and l to 1, o to 0, s to 5, t to 7, b to 8. Matching is case-insensitive, so 'A' and 'a' are both candidates, and every character without an entry in the table — digits, punctuation, spaces, accents, emoji — passes through untouched.
Each candidate letter is counted as it appears, and the intensity decides which of them are replaced: with light, only candidates at positions zero, three, six and so on; with medium, every even-positioned candidate; with extreme, all of them. This positional rule is what makes the output reproducible without any random source, which matters when you compare outputs across environments or store them for later.
The response includes the converted string along with the intensity used, the number of eligible letters found and how many were actually replaced, so automated callers can verify the effect.
Where people actually use it
The most common use is naming: gamer tags, clan names, forum handles and Wi-Fi network names that need to read as plain words to humans while looking distinctive at a glance, where a medium intensity usually hits the sweet spot between style and legibility. Community managers and content creators use light intensity to give a headline or a social post a retro hacker flavor without making it unreadable to a general audience.
Unsupported intensity values fail fast with an explicit error, which keeps misconfigured integrations visible during development rather than silently producing unexpected output in production.
What you can do with it
Style a gamer tag or handle
Convert a nickname at medium intensity so it stays readable but unmistakably leet, like turning 'ShadowMaster' into a stylized variant you can reuse consistently.
Build password-audit wordlists
Apply extreme intensity to dictionary terms to generate the systematic leet mutations that security tools test against during credential audits.
Add retro flavor to a headline
Run a title at light intensity to sprinkle in a few 1337 substitutions — enough to signal the style without hurting legibility for a general audience.
FAQ
What are the intensity levels?
Light substitutes every 3rd eligible letter, medium every 2nd, and extreme substitutes all of them. The default is medium.
Which letters get replaced?
A fixed classic table: a→4, e→3, i→1, o→0, s→5, t→7, l→1 and b→8. Matching is case-insensitive; everything else passes through unchanged.
Is the output the same every time?
Yes. Substitution is position-based with no randomness, so the same text and intensity always produce the identical output.
Can it convert leetspeak back to plain text?
No. This capability converts plain text to leetspeak only; for decoding an existing leet string use the leetspeak translator capability instead.
Are capital letters and accented letters converted too?
Capital letters are: matching ignores case, so A and a are both candidates. Accented letters, digits, punctuation, spaces and emoji have no entry in the table, so they pass through untouched.
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/leetspeak-convert \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"text":"Leetspeak replaces letters with look-alike digits."}'const res = await fetch("https://api.kit.forhosting.com/text/leetspeak-convert", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"text": "Leetspeak replaces letters with look-alike digits."
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/text/leetspeak-convert",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"text": "Leetspeak replaces letters with look-alike digits."
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/text/leetspeak-convert", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"text":"Leetspeak replaces letters with look-alike digits."}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"text":"Leetspeak replaces letters with look-alike digits."}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/text/leetspeak-convert", 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": "Leetspeak replaces letters with look-alike digits."
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "text.leetspeak_convert",
"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_mb | 1 |
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. |
Technical notes
It runs free in your browser on this page and via API at $0.002 per call.
How the substitution engine works
Text is required and must be a non-empty string up to the published size limit, and an unrecognized intensity value is rejected with a clear invalid_input error instead of a silent fallback.
Where people actually use it
Because the algorithm is deterministic and has no dependencies, the same conversion runs identically in the free browser tool on this page and through the paid API, so you can prototype by pasting text and only pay at $0.002 per call when you wire it into an automated flow.
Technical questions
What does it cost?
$0.002 per API call. It is also free to run in your browser on this page — the same code produces both results.
What happens with an invalid intensity?
The call is rejected with an invalid_input error naming the supported values (light, medium, extreme) and nothing is charged.