9 min read · updated August 2, 2026
Case converter guide: Title Case, camelCase, and more
Case Converter
Convert text between cases — free, no signup
A case converter rewrites text into a different capitalization style, turning an all-caps heading into readable sentence case or a spaced phrase into camelCase in one click. The mechanical part is easy; the useful knowledge is the map of conventions, since UPPERCASE, lowercase, Title Case, Sentence case, camelCase, snake_case, and kebab-case each belong to a specific context, and using the wrong one reads as sloppiness to anyone who works in that context.
The need shows up in small, recurring emergencies: a paragraph typed with Caps Lock on, a CSV of customer names shouting in uppercase before a CRM import, a blog headline that must match the site's title style, a Python identifier that needs to become JavaScript. Retyping is error-prone and slow, and spreadsheet formulas handle only the simple cases.
This guide covers where each style belongs, how conversion works at the Unicode level, why Title Case is the genuinely hard style, and the cleanup passes worth running after any bulk conversion.
The seven styles and where each one belongs
Every case style is a signal about context. Prose styles carry tone, and code styles carry meaning that compilers and teammates both read. Knowing the map keeps you from signaling the wrong thing.
- UPPERCASE: warnings, legal boilerplate, and short labels like DRAFT. In sentences it reads as shouting, and studies of reading speed consistently find all-caps prose slower to scan, which is exactly why it draws attention in small doses.
- lowercase: the reset state. Most useful as step one before applying another style, and as a deliberate stylistic choice in casual branding.
- Sentence case: first letter capitalized, everything else down except proper nouns. The default for UI copy and headings in most modern product style guides, including the major tech companies' own documentation.
- Title Case: principal words capitalized, minor words down. The convention for book titles, news headlines in some outlets, and blog titles that follow AP or Chicago style.
- camelCase: first word lowercase, later words capitalized, no separators. The variable and function convention in JavaScript, Java, and Swift. Its sibling PascalCase, with the first letter capitalized, marks class and type names.
- snake_case: lowercase with underscores. The Python and Ruby convention for variables and functions, and a common choice for database columns and file names.
- kebab-case: lowercase with hyphens. The style for URL slugs and CSS class names, chosen because hyphens are safe in URLs and search engines treat them as word separators, which underscores are not.
What actually happens when text changes case
Case conversion looks like a lookup table, and for the 26 ASCII letters it is. Beyond ASCII, it becomes a rules engine. Unicode defines case mappings for every letter that has case, and some mappings are not one-to-one: the German sharp s uppercases to the two letters SS, so a word can get longer when capitalized, and lowercasing that SS cannot know whether to restore the original. Case conversion is lossy in both directions, which is why converting a column of names to uppercase and back does not always round-trip.
Locale rules add another layer. In Turkish, the lowercase of I is a dotless i, and the uppercase of i carries a dot, so the same byte sequence converts differently depending on the language in effect. Greek sigma lowercases to a different form at the end of a word than in the middle. A converter built on the platform's Unicode library inherits these rules; a naive add-32-to-the-byte implementation mangles them, which is the difference you notice the first time a non-English name goes through a cheap script.
The programming cases involve segmentation as well as mapping. Turning user profile settings into camelCase means tokenizing the phrase into words, lowercasing the first, capitalizing the initial letter of the rest, and joining without separators. Converting back out of camelCase requires detecting word boundaries from the capital letters, with special handling for acronym runs: parseHTTPResponse should split as parse, HTTP, Response, not parse, H, T, T, P. Boundary detection quality is most of what separates a good converter from a find-and-replace.
Title Case is the hard one
Uppercase and lowercase are mechanical, but Title Case requires editorial judgment encoded as rules, and the major style guides disagree on the rules. All of them capitalize the first and last word and all principal words: nouns, verbs, adjectives, adverbs, pronouns. They diverge on the minor words. AP style capitalizes any word of four or more letters, so With and From get capitals. Chicago keeps prepositions lowercase regardless of length, so a Chicago title reads Through the Looking Glass while an AP headline capitalizes Through. APA capitalizes anything of four letters or more, including prepositions.
The traps concentrate in the short words. Is is a verb and always capitalized despite being two letters; the same goes for Be and Am. A and The are articles and stay down unless they open the title. In can be a preposition (lowercase in Chicago) or part of a phrasal verb like Log In (capitalized). Hyphenated compounds split the guides again: most capitalize both halves of Well-Known, but treatment of the second element varies with what part of speech it is.
Acronyms and brand names are the final hazard, because pure rule-following breaks them. NASA must not become Nasa, iPhone must not become IPhone, and a converter has no dictionary of the world's trademarks. The professional workflow is therefore convert, then scan: run the mechanical conversion for the 95 percent it gets right, then eyeball the result for acronyms, brand names, and phrasal verbs. On a list of 50 headlines this takes two minutes and produces copy-desk-grade output.
Everyday scenarios, from spreadsheets to slugs
The single most common rescue is the Caps Lock paragraph: an address block, an email draft, or a form entry typed entirely in capitals. Converting to lowercase and then to sentence case restores it in two clicks, with only proper nouns to fix by hand. The reverse emergency is legacy data: exports from older CRM, ERP, and point-of-sale systems frequently arrive with names and addresses in full uppercase, and a pass through sentence-case conversion before the import saves a mail merge from greeting DEAR MR SMITH.
Content work leans on Title Case and kebab-case. A site that mixes title-cased and sentence-cased headlines looks unedited, so converting each new headline to the house style is a small habit with visible payoff. The same headline then needs a URL slug, which means lowercasing, hyphenating, and stripping punctuation: How to Renew a U.S. Passport becomes how-to-renew-a-us-passport. Doing that by hand invites the inconsistent slugs that make analytics reports annoying to read.
Developers convert between the code cases constantly at language boundaries. Porting a Python module to TypeScript means user_id becomes userId across the whole surface; a JSON API that emits snake_case keys meets a frontend that wants camelCase; an environment variable list needs CONSTANT_CASE versions of a config file's kebab-case keys. Batch-converting the identifier list and pasting it back beats renaming by hand, and it never misspells anything on the way through.
Cleanup passes that make bulk conversion safe
Mechanical conversion plus a short manual pass beats either alone. After any sentence-case or Title Case run over real-world data, sweep for three families of words the rules cannot know: proper nouns with internal capitals (McDonald, iPhone, LaTeX), acronyms (NASA, FAQ, USB), and names with particles where convention varies (van der Berg, D'Angelo). The converter gets the structure right; you supply the dictionary.
For spreadsheet data, convert a copy of the column rather than the original, then compare before replacing. Ten seconds of diffing catches the surprises, like a product SKU column that was never meant to be prose, before they propagate into an import. Spreadsheets do offer built-in helpers, UPPER, LOWER, and PROPER in Excel, but PROPER capitalizes every word including the minor ones and mangles McDonald into Mcdonald, which is why a converter with real Title Case rules plus a manual sweep produces better lists.
Finally, standardize once and write it down. Deciding that headlines are Chicago Title Case, UI strings are sentence case, slugs are kebab-case, and database columns are snake_case takes five minutes, and it converts every future capitalization debate into a lookup. Consistency is the actual product; the converter is just the fastest way to get there.
Common questions
Case Converter FAQs
- How do I convert all caps text to normal text?
- Paste the text into a case converter and apply sentence case, which lowercases everything and recapitalizes the first letter of each sentence. You will then need to restore capitals on proper nouns like names and places by hand. This is far faster than retyping and avoids introducing typos into text that was already correct.
- What is the difference between camelCase and snake_case?
- camelCase joins words without separators and capitalizes each word after the first, like userProfileSettings, while snake_case joins lowercase words with underscores, like user_profile_settings. camelCase is the convention in JavaScript and Java; snake_case is standard in Python and common for database columns. They carry the same information, and which to use is dictated by the language or codebase you are working in.
- Which words are not capitalized in a title?
- Short conjunctions, articles, and prepositions stay lowercase in Title Case: and, or, but, a, an, the, in, on, at, to, of. The first and last words are always capitalized regardless. Style guides differ on longer prepositions, with AP capitalizing words of four or more letters while Chicago keeps prepositions lowercase at any length, so check which guide your publication follows.
- How do I change capitalization in Excel or Word?
- Excel offers UPPER, LOWER, and PROPER functions, and Word cycles selected text through cases with Shift+F3. Both handle the basic styles but neither produces true Title Case, since PROPER capitalizes every word including articles and prepositions and breaks names like McDonald. For real Title Case, or for code styles like camelCase and snake_case, a dedicated case converter does the segmentation these built-ins lack.
- Does converting case change my text in any other way?
- A well-behaved converter changes only the letters' case and, for code styles, the separators between words; wording, punctuation, and spacing are untouched. One genuine edge case is that case mapping is lossy: certain characters, like the German sharp s, do not round-trip through uppercase and back. Keep the original text until you have checked the output, especially with non-English names.
- Is it safe to paste sensitive text into an online case converter?
- It is safe when the conversion happens in your browser, since the text never travels to a server. Case conversion is simple string processing, so there is no technical reason for a converter to upload anything. ToolDoor's case converter runs client-side, meaning the text stays on your device throughout.
Capitalization is a system of small conventions, and the payoff for respecting them is that your headlines look edited, your data imports cleanly, and your identifiers compile. The workflow that gets you there is consistent: convert mechanically, sweep for the acronyms and proper nouns no rule can know, and keep a house standard so the same decision never gets made twice.
For the mechanical step, the Case Converter on ToolDoor handles UPPERCASE, lowercase, Title Case, Sentence case, camelCase, snake_case, and kebab-case in one click, with the processing done in your browser. It is free and requires no signup, so the all-caps paragraph or messy CSV column in front of you can be fixed right now.
Nearby doors