Convert to dot.case
Hello World, HelloWorld and hello-world all become hello.world: every word in lowercase, joined by a single period, with no leading, trailing or doubled dots. Handy for configuration keys, feature flags and package paths. 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
- hello.world
- Length
- 11
- Original length
- 11
- Word count
- 2
Dot.case is a naming style common in configuration keys, Java package fragments, CSS-adjacent tokens, and nested object path notation: every word in lower case, separated by a single period. This tool takes the phrase or identifier you enter, normalizes separators and camelCase boundaries, lowercases every letter with Unicode-aware mapping, and returns a clean dot.case string plus word count and change metadata. Spaces, hyphens, underscores, and other non-alphanumeric characters become separators; HelloWorld and hello-world both become hello.world. 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 dot.case conversion works
The converter first inserts period boundaries at camelCase and PascalCase edges: 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 acronyms such as XMLHttp become xml.http. After those structural splits, every run of non-alphanumeric characters—spaces, hyphens, underscores, punctuation, symbols—is replaced by a single period. The whole string is then lowercased with the host Unicode toLowerCase mapping so accented Latin letters fold correctly without stripping diacritics.
Leading and trailing periods are stripped and internal runs collapse to one period, which keeps messy free-text phrases from producing double separators. Digits stay attached to neighboring word segments unless a letter-digit case edge already forced a split. 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 can do with it
Normalize config and feature-flag keys
Turn human labels and mixed identifiers into stable dot.case keys for environment maps, feature flags, and nested settings.
Package and module path segments
Map product names into lowercased dotted path fragments for packages, modules, and document store field paths.
Code generators and scaffolds
Feed phrases into a deterministic dot.case step when scaffolding config keys, event properties, and nested object paths.
FAQ
What does convert to dot.case do?
It lowercases your phrase or identifier and joins words with periods, splitting camelCase and normalizing spaces, hyphens, underscores, and other separators into a single dot.case 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.
How are acronyms like XMLHttp handled?
They are split where a run of capitals meets a capital followed by lowercase letters, so XMLHttp becomes xml.http. Ordinary camelCase edges, where a lowercase letter or digit meets a capital, split the same way.
What happens if my text is already in dot.case?
It comes back unchanged, so already.dot stays already.dot and the result notes that nothing changed. That makes it safe to run the converter over a list where some names are already correct.
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/dot-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/dot-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/dot-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/dot-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/dot-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.dot_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
No network round-trips inside the engine, no random seeds, and no clock dependence—identical text always produces identical JSON.
How dot.case 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
Send a single required field named text containing the non-empty phrase or identifier you want in dot.case. 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 rename config keys, generate package path segments, or normalize nested field paths in bulk. 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 dot.case result, the result length, the original length, a word_count of period-separated segments, a boolean changed flag, and operation set to dot_case. Classic checks include Hello World becoming hello.world, HelloWorld becoming hello.world, kebab-case-name becoming kebab.case.name, snake_case_name becoming snake.case.name, and already.dot staying already.dot with changed false when the input was already perfect dot.case. Pricing for successful API calls is the published base of $0.002 per item; validation failures including empty text do not consume prepaid balance. If your pipeline later needs pure lowercase without separators, URL slug hyphens, snake_case with underscores, or camelCase, treat those as separate tools rather than overloading this convert-to-dot-case landing.
Where dot.case tools show up in real work
Backend and platform teams rename human labels from spreadsheets and design docs into stable dotted config keys before feature flags and environment maps. Java and Kotlin teams map product names into package or module path fragments that use lowercased dotted segments. Product and growth teams paste experiment labels into a dot.case box before filing them into analytics property dictionaries that assume a single naming style. ETL and schema jobs that ingest mixed headers often force every key through dot.case so nested object paths and document stores stay consistent across vendors. 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. Prefer this page when the search intent is literally convert to dot case or dot.case converter; if you need underscores between words, use the dedicated snake_case tool instead of stretching this capability beyond its contract.
Technical questions
Does it handle camelCase, kebab-case, and snake_case?
Yes. HelloWorld becomes hello.world, kebab-case-name becomes kebab.case.name, and snake_case_name becomes snake.case.name. Acronym-style PascalCase such as XMLHttpRequest becomes xml.http.request.
Is this the same as snake_case or a URL slug?
No. Dot.case uses periods between lowercased words. Snake_case uses underscores; URL slugs typically use hyphens. Use the dedicated tools for those intents.