Free Text Case Converter Online
Convert text between UPPER CASE, lower case, Title Case, camelCase, snake_case, kebab-case, and more. 100% client-side — your text stays private.
What is case conversion? Case conversion rewrites the capitalization and the word separators of a string without changing the letters themselves, so user profile name becomes userProfileName in camelCase, user_profile_name in snake_case, or user-profile-name in kebab-case. Programming languages, style guides and URL conventions each expect a particular form, which makes conversion a routine step whenever text moves between prose, code, filenames and databases.
How to Use the Case Converter
- Paste your text — Type or paste into the input box. Conversion runs on every keystroke inside the page, so there is no submit button and nothing is sent to a server.
- Pick a case style — Twelve buttons cover UPPER CASE, lower case, Title Case, Sentence case, camelCase, PascalCase, snake_case, kebab-case, dot.case, path/case, CONSTANT_CASE and aLtErNaTe CaSe.
- Set line-break handling — Leave Preserve line breaks checked to convert each line on its own — useful for lists. Uncheck it to treat the whole block as one string, which is what identifier styles need.
- Read the output panel — The result appears below the buttons. Delimiter styles such as snake_case and camelCase discard every character that is not a letter or digit, so punctuation will not survive the round trip.
- Copy the result — Copy writes the output to your clipboard through the browser Clipboard API and confirms with a checkmark for two seconds.
- Chain two conversions with Swap — Swap moves the output back into the input so you can apply a second style — for example clean a heading with Title Case, then run it through kebab-case.
How Case Conversion Works
A case converter does two separate jobs: it decides which letters are capitalized, and it decides how words are joined together. The simple styles only do the first job. UPPER CASE and lower case pass the whole string through the Unicode case-mapping tables that JavaScript exposes as toUpperCase() and toLowerCase(), so accented and non-Latin letters are handled according to the Unicode standard rather than being limited to A–Z.
Identifier styles do both jobs, and they start by breaking the text into words. Every run of characters that is not a letter or a digit counts as a boundary and is thrown away, so the input Order #12 — shipped! reduces to the three words Order, 12 and shipped. Those words are lowercased and then rejoined with whatever separator the style calls for.
That single rule explains most of the surprises people hit. Apostrophes, commas and em dashes vanish from camelCase and snake_case output because they are boundaries, not letters. Accented characters such as é and ü are also outside the A–Z0–9 range, so they are dropped rather than transliterated — run the text through the Diacritics Remover first if you need café menu to become cafeMenu instead of cafMenu.
Title Case and Sentence case
Title Case lowercases the whole string, capitalizes the first letter of every word, and then puts a fixed list of short words back to lowercase when they are not the opening word: a, an, the, and, but, or, for, nor, on, at, to, from, by, in, of. This matches the common newsroom convention closely but not perfectly — most style guides also capitalize the final word of a title regardless of length, and that final-word rule is not applied here, so check the last word yourself.
Sentence case lowercases everything and then capitalizes the first letter of the text. With Preserve line breaks enabled, each line is treated as its own text, so every line gets one capital. It does not scan for full stops inside a paragraph and it has no way of knowing which words are proper nouns, so names, brand names and the pronoun "I" come back lowercased and need a manual pass.
Case Style Reference
All twelve styles are shown below with the same source phrase, User Profile ID, so you can compare the output side by side and pick the convention your target language or platform expects.
| Style | Result | Where it is normally used |
|---|---|---|
| UPPER CASE | USER PROFILE ID | Headings, acronyms, legal notices |
| lower case | user profile id | Normalizing data before comparison |
| Title Case | User Profile Id | Article headlines, page titles |
| Sentence case | User profile id | Body copy, UI labels, button text |
| camelCase | userProfileId | JavaScript, Java and C# variables; JSON keys |
| PascalCase | UserProfileId | Class, type and component names |
| snake_case | user_profile_id | Python, Ruby, SQL columns, Rust |
| kebab-case | user-profile-id | URLs, CSS classes, HTML attributes |
| dot.case | user.profile.id | Config keys, namespaces, i18n message ids |
| path/case | user/profile/id | Route segments and folder paths |
| CONSTANT_CASE | USER_PROFILE_ID | Environment variables and constants |
| aLtErNaTe CaSe | uSeR PrOfIlE Id | Informal emphasis in chat and memes |
aLtErNaTe CaSe flips only ASCII letters and leaves every other character, including spaces and digits, exactly where it is. That is why the alternation pattern appears to skip a beat across word boundaries.
Choosing the Right Case for the Job
The choice is rarely about taste. Hyphens are legal in URLs and CSS identifiers but are read as a minus sign inside most programming languages, which is why kebab-case dominates on the web and snake_case dominates in Python, Ruby and SQL. Underscores are safe in identifiers everywhere but are easy to lose visually when a URL is underlined, so they are a poor fit for public links. Dots imply a hierarchy, which is why configuration systems and translation files use dot.case for nested keys.
Within a codebase, consistency matters more than the specific rule. Most linters can enforce a naming convention automatically, and the usual convention is to keep one style per layer: PascalCase for types, camelCase for values, CONSTANT_CASE for module-level constants that never change, and kebab-case for anything that ends up in a URL or a stylesheet. When you are converting a batch of names to match an existing project, paste them as separate lines and leave Preserve line breaks checked so each name is converted independently instead of collapsing into one long identifier.
Frequently Asked Questions
Both remove the spaces and capitalize the start of each word; they differ only in the first letter. camelCase begins lowercase (myVariableName) and PascalCase begins uppercase (MyVariableName). The usual split is PascalCase for classes, types and React components, camelCase for variables, function names and JSON keys. PascalCase is also called UpperCamelCase, which is why the two are so often confused.
The whole string is lowercased, every word is capitalized, and then fifteen short words are put back to lowercase when they are not the opening word: a, an, the, and, but, or, for, nor, on, at, to, from, by, in, of. Note that most published style guides also capitalize the last word of a title no matter how short it is, and that rule is not applied automatically — check the final word before you publish.
Sentence case capitalizes the first letter of the text rather than the first letter after each full stop. With Preserve line breaks checked, each line counts as its own text and gets one capital, which is the behavior most people want for lists and headings. It also cannot detect proper nouns, so names, brands, and the pronoun "I" come back lowercased and need a manual fix.
It depends on the style. UPPER CASE and lower case use Unicode case mapping, so é becomes É and scripts without case distinctions — Chinese, Japanese, Arabic, Hebrew — pass through unchanged. The identifier styles are stricter: they keep only A–Z and 0–9, so accented letters are dropped rather than converted. Strip the accents first with the Diacritics Remover if you need them preserved as base letters.
camelCase, PascalCase, snake_case, kebab-case, dot.case, path/case and CONSTANT_CASE all split the text on anything that is not a letter or a digit, then rejoin the pieces with their own separator. Apostrophes, commas, slashes and em dashes are boundaries under that rule, so they are consumed. If you need punctuation intact, use UPPER CASE, lower case, Title Case or Sentence case, which only remap letters.
Use kebab-case for anything that appears in a URL, a CSS class, an HTML attribute or a static filename — hyphens are valid there and search engines treat them as word separators. Use snake_case inside code, because a hyphen is parsed as subtraction in almost every language, making user-id an expression rather than a name. Python, Ruby and SQL conventions all favor snake_case for this reason.
No. The conversion is plain JavaScript running in your own tab, and there is no upload step or server round trip at any point. The only thing that leaves the page is whatever you choose to put on your clipboard with the Copy button. Your current text and the line-break option are also written into the page URL so you can bookmark or share a working state — keep that in mind before sharing a link containing sensitive text.
Yes, though the whole document is held in memory as a single string and reconverted on every keystroke, so very large pastes can feel sluggish while you type. If you hit that, paste the text, then switch styles instead of editing in place. There is no imposed character limit; the practical ceiling is the memory your browser tab is allowed to use.
Use Cases
Porting an API Between Languages
A Python service returns created_at and user_id; paste the field list and run camelCase to produce the JavaScript client property names in one pass.
Fixing a Headline Written in Caps
An author submits a post title in ALL CAPS. Title Case restores normal capitalization while keeping articles and short prepositions lowercase, so the headline matches the rest of the blog.
Building an .env File
Turn a list of settings written in plain English — "database read replica host" — into CONSTANT_CASE environment variable names that a deployment config can consume directly.
Cleaning Up Imported Spreadsheet Data
A CSV export arrives with mixed capitalization across rows. Lower case normalizes the column so duplicate detection and lookups stop treating "Acme" and "ACME" as different values.
Renaming a Folder of Design Assets
Paste the exported filenames and apply kebab-case so every asset becomes web-safe, lowercase and hyphenated before it is committed or uploaded to a CDN.