Text Case Converter
See your text in 13 case styles side by side, with the detected word boundaries shown so you can tell why a conversion split where it did. All processing happens locally in your browser.
Convert text between 13 case styles at once
Word boundaries are detected first — from separators, lower-to-upper transitions and acronym edges — then every style is built from the same token list, so results stay consistent with each other.
| Style | Result | |
|---|---|---|
| lowercase | parsehttpresponsebody v2 | |
| UPPERCASE | PARSEHTTPRESPONSEBODY V2 | |
| Title Case | Parse HTTP Response Body V2 | |
| Sentence case | Parsehttpresponsebody v2 | |
| camelCase | parseHttpResponseBodyV2 | |
| PascalCase | ParseHttpResponseBodyV2 | |
| snake_case | parse_http_response_body_v2 | |
| kebab-case | parse-http-response-body-v2 | |
| CONSTANT_CASE | PARSE_HTTP_RESPONSE_BODY_V2 | |
| dot.case | parse.http.response.body.v2 | |
| Train-Case | Parse-Http-Response-Body-V2 | |
| aLtErNaTiNg cAsE | pArSeHtTpReSpOnSeBoDy V2 | |
| iNVERTED cASE | PARSEhttprESPONSEbODY V2 |
HTTP or ID, are preserved rather than lowered to Http. In camelCase and PascalCase they are normalised to leading-capital form, which is what most style guides for those conventions prescribe.What is case conversion, and why is word splitting the hard part?
Changing text to uppercase is trivial. Changing parseHTTPResponseBody into parse_http_response_body is not, because the tool first has to work out where one word ends and the next begins.
This page splits your input into tokens before applying any style, using three signals:
- Separator characters. Spaces, underscores, hyphens, dots, slashes and most punctuation all mark a boundary.
- Lower-to-upper transitions. In
userName, the capitalNstarts a new word. - Acronym edges. In
HTTPServer, the boundary falls betweenHTTPandServer, not betweenHTTPSanderver. The rule is that a run of capitals followed by a capital-then-lowercase pair splits before that last capital.
The token list is shown next to the input so you can see the decision directly. Every style is then built from that same list, which is why camelCase and snake_case always agree with each other here.
Examples: how each style handles the same input
Input: parseHTTPResponseBody v2 → tokens: parse, HTTP, Response, Body, v, 2
| Style | Result | Typical home |
|---|---|---|
| camelCase | parseHttpResponseBodyV2 |
JavaScript and Java variables, JSON keys |
| PascalCase | ParseHttpResponseBodyV2 |
Class names, React components, C# members |
| snake_case | parse_http_response_body_v_2 |
Python, Ruby, SQL columns, Rust |
| kebab-case | parse-http-response-body-v-2 |
CSS classes, HTML attributes, URL slugs |
| CONSTANT_CASE | PARSE_HTTP_RESPONSE_BODY_V_2 |
Environment variables, exported constants |
| dot.case | parse.http.response.body.v.2 |
Java properties, i18n keys, nested config |
| Train-Case | Parse-Http-Response-Body-V-2 |
HTTP header names such as Content-Type |
| Title Case | Parse HTTP Response Body V 2 |
Headings and headlines |
Two details in that table are worth calling out.
v2 splits into v and 2. A letter-to-digit transition is treated as a boundary because version2 reads better as version_2 than version2 in snake_case. If you want the digit attached, write it without the boundary signal, such as utf8 where the digit follows a full word — that stays a single token.
Title Case keeps HTTP intact. A token that is already fully uppercase is treated as an acronym and left alone, rather than becoming Http. camelCase and PascalCase do normalise it, because those conventions overwhelmingly prefer parseHttpResponse to parseHTTPResponse.
How to use it
- Type or paste your text A sentence, a variable name, a filename, a database column, or a whole headline. Every style updates as you type.
- Check the token panel If a conversion looks wrong, the token list almost always explains it. An unexpected split means a boundary signal was present in the input.
- Copy the style you need Each row has its own Copy button, so there is no need to select text by hand.
Title Case and Sentence case work differently from the rest
The programming styles are mechanical. The prose styles involve editorial judgement, so it is worth being explicit about the rules applied here.
Title Case
Short joining words stay lowercase unless they are the first or last word. The list used is the one most style guides agree on: a, an, and, as, at, but, by, for, from, in, into, nor, of, off, on, onto, or, over, per, so, the, to, up, via, vs, with, yet.
Input: a guide to the art of naming things
Output: A Guide to the Art of Naming ThingsNote that the leading a is capitalised because it is first, while to, the and of stay lowercase. AP, Chicago and APA disagree on the details — Chicago lowercases prepositions of any length, AP capitalises those over three letters — so treat the output as a solid draft rather than a ruling.
Sentence case
Everything is lowered, then the first letter of each sentence is raised. Sentence boundaries are detected after ., !, ? and at the start of each line.
Input: THE SERVER RESTARTED. IT IS FINE NOW!
Output: The server restarted. It is fine now!Known limitation: Sentence case lowercases proper nouns, because no reliable way exists to tell London from london without understanding the text. Abbreviations such as e.g. and Dr. also create false sentence boundaries. Expect to fix a few words by hand on prose.
Punctuation, accents and what survives
| Input | snake_case | Why |
|---|---|---|
user.email@work |
user_email_work |
. and @ are both separators |
don't stop |
don_t_stop |
The apostrophe is treated as a separator, so contractions split |
café münchen |
café_münchen |
Accented letters are letters and are preserved |
ISO 8601 |
iso_8601 |
Space separates; the acronym lowercases in snake_case |
--flag-name-- |
flag_name |
Runs of separators collapse; leading and trailing ones vanish |
Accented characters are kept intact by design. If you need pure ASCII output for an identifier or a URL, transliterate first — stripping diacritics is a separate decision that depends on the target language.
Note that lowercase and UPPERCASE do not use the token list at all. They map every character directly, so punctuation and spacing are preserved exactly. Only the styles that join words together need tokenisation.
Use cases
- Renaming across a codebase. Get the same concept in camelCase for the JavaScript, snake_case for the database column, CONSTANT_CASE for the config key and kebab-case for the CSS class in one pass.
- Mapping an API to a language convention. A JSON API using snake_case keys consumed by a camelCase codebase needs both spellings of every field.
- Fixing a Caps Lock accident. The inverted-case style flips a line typed with Caps Lock on back to what you meant.
- Cleaning up pasted headings. ALL CAPS headings from a slide deck or PDF convert to Title Case or Sentence case for the web.
- Building environment variable names. A feature description becomes
ENABLE_NEW_CHECKOUT_FLOWdirectly. - Naming CSS custom properties.
Primary Button Hoverbecomes--primary-button-hoverafter adding the prefix.
If you need counts rather than conversions, the Word Counter breaks text down by sentences, paragraphs and reading time.
Privacy
Conversion is plain JavaScript string manipulation running in the page. Your text is not uploaded, and nothing is stored between visits.
Frequently Asked Questions
Why did parseHTTPResponse become parseHttpResponse and not parseHTTPResponse?
Because camelCase and PascalCase conventions in most languages treat an acronym as an ordinary word. Google's Java style guide, the .NET naming guidelines and the Swift API guidelines all prescribe Http over HTTP for exactly this reason: consecutive capitals make boundaries ambiguous. Title Case keeps the acronym, since prose conventions differ.
Why does my contraction split at the apostrophe?
Because the apostrophe is treated as a separator, so "don't" becomes don_t in snake_case. That is the right call for identifiers, where an apostrophe is never valid. For prose styles such as Title Case and Sentence case the original punctuation is preserved and contractions stay intact.
What is the difference between kebab-case and a URL slug?
kebab-case is purely a joining convention. A URL slug usually also strips accents, drops stop words, enforces lowercase ASCII and trims length. kebab-case gets you most of the way there but is not a complete slug generator, and the extra steps depend on your language and routing rules.
Is there a length limit?
No hard limit, but every style is recomputed on each keystroke, so very large documents will feel sluggish. The page is built for names, headings and paragraphs rather than whole books. For long documents, convert a section at a time.
Why is "Words" different from "Detected tokens"?
Words counts whitespace-separated groups, the way a word processor does. Detected tokens counts the units used for case conversion, which also splits on camelCase transitions, underscores and punctuation. "userName v2" is 2 words but 4 tokens.
Does Title Case follow AP or Chicago style?
Neither exactly. It uses the shortlist of joining words the major guides agree on, and always capitalises the first and last word. AP capitalises prepositions longer than three letters while Chicago lowercases them regardless of length, so if you must match a specific guide, check words such as "through" and "between" by hand.