Convert to flatcase
Hello World and HelloWorld both become helloworld, and kebab-case-name becomes kebabcasename. Every letter is lowercased and every separator disappears, leaving one continuous label for tags, keys and fields that forbid spaces or punctuation. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Worked example
- Text
- Hello World
- Result
- helloworld
- Length
- 10
- Original length
- 11
- Word count
- 2
Flatcase (also written flat case) is the compact naming style where every letter is lowercased and every separator disappears, leaving one continuous alphanumeric string. Developers reach for it when they need dense identifiers, machine labels without spaces or punctuation, or a deterministic normalization step before hashing, comparing, or packing names into tight fields. This tool takes the phrase or identifier you enter, detects camelCase and PascalCase word edges for accurate word counting, strips spaces, hyphens, underscores, dots, and other non-alphanumeric characters, lowercases every remaining letter with Unicode-aware mapping, and returns the flatcase string plus length and change metadata. Empty input is rejected with a clear validation error instead of silently returning an empty string, which protects clients that forgot to bind a form field.
How flatcase conversion works
The converter first inserts temporary boundaries at camelCase and PascalCase edges so acronyms and multi-word identifiers are counted correctly: a lowercase or digit character followed by an uppercase letter splits, and runs of uppercase letters followed by a capital-plus-lowercase sequence split so patterns such as XMLHttp become three logical words. After those structural splits, every non-alphanumeric character—spaces, hyphens, underscores, dots, punctuation, symbols—is discarded entirely rather than replaced with another separator.
The surviving letter and digit characters are lowercased with the host Unicode toLowerCase mapping so accented Latin letters fold correctly without stripping diacritics, then concatenated into a single continuous string. Digits stay attached to neighboring segments once separators are gone, which keeps product codes and version fragments readable as one compact token. Empty strings and inputs that contain only separators fail validation before a result is returned.
Because the path is pure parse work over strings, latency stays sub-millisecond for typical form sizes and the published cost model is analytic rather than model-token based.
What you send and what you get back
Send a single required field named text containing the non-empty phrase or identifier you want in flatcase. Numbers and booleans are coerced to their decimal or true/false text forms; objects, arrays, NaN, and Infinity are rejected. Wire the free browser form for quick paste-and-copy work, then call the identical contract from scripts when you normalize labels for compact keys, build dense machine identifiers, or strip separators before comparison.
If your pipeline later needs underscores, hyphens, camelCase capitals, or title case, treat those as separate tools rather than overloading this convert-to-flat-case landing.
What you can do with it
Build compact machine identifiers
Turn human phrases and mixed identifiers into continuous lowercase tokens for dense keys, tags, and fixed-width fields.
Code generators and scaffolds
Feed phrases into a deterministic flatcase step when scaffolding labels that must be all lowercase with no separators.
FAQ
What does convert to flatcase do?
It lowercases your phrase or identifier and removes every separator—spaces, hyphens, underscores, punctuation—so the result is one continuous alphanumeric string.
What happens if I send empty text?
Empty strings and separator-only input are rejected so clients notice missing fields instead of receiving a silent empty result.
What does it cost?
The browser tool is free and runs locally.
Are accents removed from letters?
No. Accented letters are lowercased but keep their accent, so an É becomes é rather than a plain e. Only separators and punctuation are dropped, never the letters themselves.
What happens to digits?
They stay and join the letters next to them once the separators are gone. That keeps product codes and version fragments readable as one compact token instead of losing their numbers.
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/flat-case \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"text":"Hello World"}'const res = await fetch("https://api.kit.forhosting.com/str/flat-case", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"text": "Hello World"
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/str/flat-case",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"text": "Hello World"
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/str/flat-case", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"text":"Hello World"}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"text":"Hello World"}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/str/flat-case", 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": "Hello World"
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "str.flat_case",
"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
Hello World, hello_world, and HelloWorld all become helloworld. No network round-trips inside the engine, no random seeds, and no clock dependence—identical text always produces identical JSON.
How flatcase conversion works
Extremely long payloads above the documented character cap also fail with invalid_input so a single request cannot monopolize Worker memory.
What you send and what you get back
Aliases such as input, value, data, s, message, string, content, body, and phrase are accepted for convenience when wiring older clients. On success the response echoes the original text, the flatcase result, the result length, the original length, a word_count of the segments that were joined, a boolean changed flag, and operation set to flat_case. Classic checks include Hello World becoming helloworld, HelloWorld becoming helloworld, kebab-case-name becoming kebabcasename, snake_case_name becoming snakecasename, and a string that is already pure lowercase alphanumeric staying identical with changed false. Pricing for successful API calls is the published base of $0.002 per item; validation failures including empty text do not consume prepaid balance.
Where flatcase tools show up in real work
Mobile and web clients map marketing phrases into compact machine tags for analytics dictionaries that forbid spaces and punctuation. Product and growth teams paste experiment names into a flatcase box before filing them into systems that only accept continuous identifiers. Prefer this page when the search intent is literally convert to flat case or flatcase converter; if you need underscores, hyphens, or camelCase capitals, use the dedicated sibling tools instead of stretching this capability beyond its contract. Backend and data teams sometimes need a denser form than snake_case when packing labels into fixed-width fields, legacy systems, or comparison keys that must ignore separator style. ETL jobs that reconcile names across vendors often strip every separator so hello-world, hello_world, and HelloWorld hash to the same flat token before deduplication. Because this capability is a pure parse engine, API pricing is the published base of $0.002 per successful item and failed validation does not consume balance.
Integration use cases
Normalize names before comparison
Strip separators so hello-world, hello_world, and HelloWorld collapse to the same flat string for deduplication and joins.
Technical questions
Does it handle camelCase, snake_case, and kebab-case?
Yes. HelloWorld, hello_world, and kebab-case-name all become continuous lowercase forms such as helloworld and kebabcasename. Word boundaries still count toward word_count.
Is this the same as snake_case or a URL slug?
No. Flatcase has no separators at all. Snake_case uses underscores and URL slugs typically use hyphens; use the dedicated tools for those intents.