Remove letters from text
Take the 12 letters out of Order AB-2048: ready @ 09:30! and you are left with -2048:, the @ and 09:30!, each in its original place. Letters from any alphabet go; digits, punctuation, spaces and emoji stay. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Worked example
- Text
- Order AB-2048: ready @ 09:30!
- Result
- -2048: @ 09:30!
- Letters removed
- 12
Remove Letters keeps everything in your text except alphabetic letters. It is a focused way to isolate order numbers, reference codes, punctuation, separators, emoji, currency marks, and layout without manually constructing a fragile character list. The operation recognizes Unicode letters rather than only English A through Z, so Latin, Greek, Cyrillic, Arabic, CJK, and other letter scripts are handled consistently. Characters that are not letters remain exactly where they appeared, and the response reports both the filtered result and the number of letters removed.
Remove letters without disturbing the rest of the text
Paste or send a string in the required text field. The capability scans it by Unicode code point and removes characters classified in a Unicode Letter category. Everything else is copied to the result in its original order.
That means decimal digits remain digits, punctuation such as commas, colons, dashes, quotes, and brackets stays in place, whitespace and line breaks are retained, and symbols such as currency signs, mathematical operators, emoji, and pictographs are preserved. For example, an input containing an order label, an identifier, and a time can lose the descriptive words while retaining the identifier separators and clock punctuation.
This is intentionally different from extracting numbers alone: a number extractor may normalize signs, decimals, or grouping, whereas this operation makes only one decision for each character—whether it is a letter. An empty string is valid and produces an empty result with a zero count, because it is real text with nothing to remove.
Unicode-aware behavior across languages and scripts
The definition of a letter is based on the Unicode Letter general category, not a hand-written English alphabet range. As a result, accented Latin letters, Greek and Cyrillic characters, Arabic letters, Hebrew letters, East Asian ideographs, and letters from many other writing systems are removed. Uppercase, lowercase, titlecase, modifier letters, and other Unicode letter subcategories are all included.
This avoids the common failure of an A–Z regular expression that leaves non-English words behind. At the same time, the algorithm does not normalize the input before filtering. A combining accent stored as its own code point is a Unicode mark rather than a letter, so it is preserved when its base letter is removed; a precomposed accented character such as é is itself a letter and is removed as one character.
That literal code-point policy best matches the promise to keep non-letters unchanged, and it prevents invisible normalization from rewriting punctuation or symbols. If your workflow needs diacritic cleanup, ASCII transliteration, or normalization, apply a dedicated capability before or after this operation. The filter never changes the order of retained characters and never collapses repeated spaces or separators.
Use the retained structure in codes and data pipelines
This tool is most useful when letters are noise but the structure surrounding numbers matters. A support team can strip prose from copied ticket references and retain digits, hashes, slashes, and dashes for downstream inspection. Finance and operations pipelines can expose amounts, percent signs, decimal punctuation, and currency symbols while removing nearby labels, making a later purpose-built parser easier to configure.
Because spaces and line breaks remain, the result may contain empty-looking regions where words were removed; that is deliberate evidence of the original layout, not accidental padding. If you want compact output, pass the result to a whitespace normalization capability afterward rather than combining unrelated behavior here. Likewise, this capability does not validate whether retained digits form a phone number, date, price, or account code.
It only removes letters and reports how many it removed. Keeping that contract narrow makes the output predictable and composable. Validate the semantic meaning of any retained code separately, especially where leading zeros, decimal separators, or signs are significant.
What you can do with it
Isolate reference-code structure
Remove labels and letter prefixes while preserving digits, dashes, slashes, hashes, and spacing from copied references.
Prepare numeric parsing
Keep amounts, decimal punctuation, percent signs, and currency symbols before sending the result to a specialized parser.
FAQ
Which letters are removed?
All characters in a Unicode Letter category are removed, including letters from non-English scripts and uppercase, lowercase, titlecase, modifier, and other letter forms.
Are numbers and punctuation preserved?
Yes. Digits, punctuation, separators, whitespace, emoji, and symbols remain in their original order because they are not Unicode letters.
Does it normalize whitespace after removing words?
No. Spaces, tabs, and line breaks are kept exactly as provided. Use a separate whitespace tool if you want to collapse or trim them.
How is this different from extracting the numbers from a text?
It keeps everything that is not a letter, not only the numbers. A number extractor may tidy signs, decimals or grouping, while this tool leaves dashes, colons, spaces and line breaks exactly where they were.
Why is an accent left behind after removing the letters?
Because that accent was stored as a separate mark, not as part of the letter. A precomposed é is one letter and disappears, but a base letter followed by a combining accent leaves the accent. Clean up accents first if you want those marks gone too.
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/str/remove-letters \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"text":"Order AB-2048: ready @ 09:30!"}'const res = await fetch("https://api.kit.forhosting.com/str/remove-letters", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"text": "Order AB-2048: ready @ 09:30!"
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/str/remove-letters",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"text": "Order AB-2048: ready @ 09:30!"
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/str/remove-letters", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"text":"Order AB-2048: ready @ 09:30!"}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"text":"Order AB-2048: ready @ 09:30!"}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/str/remove-letters", 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": "Order AB-2048: ready @ 09:30!"
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "str.remove_letters",
"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
The same deterministic code powers browser and API execution.
Remove letters without disturbing the rest of the text
The response contains result, the resulting string, and letters_removed, the count of removed Unicode letter code points. Missing text, non-string values, arrays, and objects fail with invalid_input instead of being silently coerced into surprising strings. API processing costs $0.002 per item, while the browser path uses the same pure function for consistent output.
Unicode-aware behavior across languages and scripts
It has no locale switch, network dependency, random choice, or time-based behavior, so identical input produces identical JSON in every region and at every execution time.
Use the retained structure in codes and data pipelines
Browser execution is convenient for one-off cleanup, and repeatable API calls are charged at $0.002 per successful item.
Integration use cases
Inspect mixed-character data
Reveal every non-letter character in logs, identifiers, fixtures, or imported fields without changing their order.
Technical questions
What happens with an empty string?
An empty string is accepted and returns an empty result with letters_removed set to zero. A missing or non-string text field returns invalid_input.
What does the API operation cost?
Each successful API item costs $0.002. The browser version runs the same deterministic filtering logic locally for free.