Numeronym generator
Internationalization becomes i18n: the first letter i, the 18 letters in between, and the last letter n. Shorten a word or a whole phrase in one go, or take a numeronym like a11y apart to see its letter count and outline. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Worked example
- Text
- internationalization
- Result
- i18n
- Calculation mode
- Shorten
- Original
- internationalization
- Word count
- 1
Numeronyms such as i18n, l10n, a11y, and k8s compress a long word into its first letter, the count of omitted middle letters, and its last letter. Writers, developers, and localization teams use them in docs, commit messages, and UI labels when space is tight or jargon is conventional. This numeronym generator shortens Latin-letter words with a deterministic rule—no model and no dictionary guesswork—and expands simple letter-plus-digits-plus-letter tokens back into a structural skeleton that shows how many characters were abbreviated.
How numeronym shortening works
A classic tech numeronym keeps the first and last letters of a word and replaces the interior with the number of letters that sat between them. For internationalization the first letter is i, the last is n, and eighteen letters lie in the middle, so the form is i18n. Digits in the middle are written without padding, so a three-letter word such as the becomes t1e rather than t01e.
This capability applies the rule to each whitespace-separated token so a short phrase can become a space-joined list of numeronyms in one call. Non-letter characters inside a token are rejected on the shorten path because a middle count is defined only over letters; strip punctuation yourself or process pure words. Empty text and pure whitespace fail immediately.
Nothing about the transform depends on locale tables, stemming, or network lookups: the same string always yields the same numeronym.
Expanding simple numeronyms and choosing mode
Expand does not magically recover a dictionary headword from i18n alone; many different words can share the same first letter, middle count, and last letter. What expand does provide is a structural reverse of the simple letter-plus-digits-plus-letter pattern: it reports the first letter, the integer middle count, the last letter, the implied full letter length, and a skeleton string where middle positions are shown as dots.
That skeleton is enough for docs, teaching materials, and validators that need to explain why a11y stands for thirteen characters with a and y at the ends. Mode shorten always compresses; mode expand always parses; mode auto (the default) expands when every token already looks like a numeronym and otherwise shortens. If shorten receives a token shorter than three letters, the message states that the input is too short to shorten and reports the observed length—those failures are not billed.
Multi-word expand joins skeletons with spaces the same way multi-word shorten joins numeronyms, keeping the contract uniform for phrases.
Where numeronyms help in everyday work
Documentation generators can turn long feature names into conventional abbreviations before writing headings that must match community jargon. Localization dashboards can display both the full key and its numeronym when teaching i18n and l10n vocabulary to new contributors. Classroom exercises that introduce numeronyms need a deterministic oracle that marks too-short inputs as errors instead of inventing zero-middle forms.
Pair shorten with your own glossary if you need bidirectional dictionary expand; use structural expand here when you only need counts and skeletons. The response always echoes mode and original text so logs and support tickets can reproduce a call without guessing which path ran.
What you can do with it
Docs and commit jargon
Convert long product or process names into conventional numeronyms (i18n, l10n, k8s) for headings, tickets, and commit subjects.
Teaching and localization onboarding
Show learners the middle-count rule and structural skeletons so a11y and friends are transparent instead of opaque slang.
FAQ
How do you turn a word into a numeronym like i18n?
Keep the first and last Latin letters and insert the count of letters between them. internationalization becomes i18n because eighteen letters sit between i and n. Send mode shorten or leave auto when the text is a full word.
When is input too short to shorten?
Tokens need at least three Latin letters so there is a real middle count.
Does auto mode detect numeronyms?
Yes. When every whitespace-separated token matches the simple letter+digits+letter pattern, auto expands; otherwise it shortens. You can force either direction with mode expand or shorten.
Can a numeronym be turned back into the original word?
Not exactly, because many words share the same first letter, middle count and last letter. Expanding gives you the structure instead: both end letters, the number of hidden letters, the full length and an outline with dots in the middle.
Can I shorten a whole phrase at once?
Yes. Each word separated by a space becomes its own numeronym, and the results are joined with spaces. Words must contain letters only, so remove punctuation first or the word will be refused.
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/enc/numeronym \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"text":"internationalization"}'const res = await fetch("https://api.kit.forhosting.com/enc/numeronym", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"text": "internationalization"
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/enc/numeronym",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"text": "internationalization"
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/enc/numeronym", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"text":"internationalization"}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"text":"internationalization"}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/enc/numeronym", 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": "internationalization"
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "enc.numeronym",
"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.
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
Words shorter than three letters cannot form a meaningful middle count and fail with invalid_input instead of inventing a hollow result.
How numeronym shortening works
Localization becomes l10n, accessibility becomes a11y, and Kubernetes becomes K8s when you preserve the original casing of the endpoints. The same arithmetic applies to any Latin-letter token of length three or more: middle_count equals letter_count minus two, and the result is first plus that decimal count plus last.
Expanding simple numeronyms and choosing mode
Aliases such as action, op, and encode or decode map onto the same three modes so existing form habits still work. If expand receives a token that is not simple letter-digits-letter form, the task fails with invalid_input naming the bad token.
Where a numeronym API fits real work
Keep tokens to Latin letters, prefer auto mode unless you know the direction, and treat invalid_input as a client fix rather than a retry storm.
Integration use cases
CI glossary and fixture generation
Generate deterministic numeronym fixtures for tests and CMS macros without a language model or external dictionary service.
Technical questions
What does expand return if it cannot recover the original word?
Expand returns structural fields: first letter, middle_count, last letter, letter_count (middle plus two), and a skeleton with dots for omitted positions. It does not guess a dictionary headword.
What does the numeronym generator cost?
The browser tool is free. API requests use prepaid KIT balance at $0.002 per successful call; invalid input is not billed.