Case Converter: Free Online Text Case Changer

How the conversion works

Word-boundary formats like camelCase, PascalCase, snake_case, kebab-case, and CONSTANT_CASE all share a common first step: splitting your input into individual words. The tool looks for lowercase-to-uppercase transitions (splitting helloWorld into "hello" and "World"), and treats underscores and hyphens as word separators too. Once it has a clean list of words, it rejoins them according to the rules of the target format: no separator and each word capitalized for PascalCase, no separator with the first word lowercase for camelCase, underscores for snake_case, hyphens for kebab-case. UPPER CASE, lower case, Title Case, and Sentence case work directly on the original spacing instead, since they don't need word boundaries redrawn.

When to use each format

• 🐫camelCase — JavaScript variables, JSON keys, React props (firstName, onClick)
• 🐍snake_case — Python variables, database columns, file names (user_name)
• 🍢kebab-case — CSS classes, URL slugs, HTML attributes (btn-primary)
• 🏛️PascalCase — Class names, React components, TypeScript types (UserProfile)
• 📢CONSTANT_CASE — Environment variables, constants (API_BASE_URL)
• 🔠Title Case — headings, article titles, product names where every major word starts with a capital
• 📝Sentence case — body copy, form labels, and UI microcopy where only the first word and proper nouns are capitalized
• 📣UPPER CASE / lower case — emphasis, legal disclaimers, or normalizing user input before comparison

Common use cases

A developer renaming a Python function pastes a camelCase name copied from a JavaScript file and converts it to snake_case to match PEP 8 conventions. A designer given a list of feature names in lowercase converts them to Title Case for a marketing page in one pass instead of retyping each heading. Someone building a CSS design system takes a list of component names and converts them to kebab-case for class names, then to PascalCase for the matching React component files, keeping both naming schemes consistent without manual retyping. Content writers use Sentence case to fix text that was pasted from a source that used Title Case throughout, restoring normal reading rhythm to a paragraph.

Tips for clean results

• •If your source text mixes cases already (like "APIKey" or "user_ID"), the word-splitting logic handles most cases well, but check the output for names with unusual capitalization like acronyms.
• •Sentence case only capitalizes after periods, question marks, and exclamation points. It won't capitalize proper nouns, since it has no way to know which words those are.
• •For long lists of names, paste them one per line. Each conversion function processes the whole input as one string, so word-boundary detection works within each line independently.
• •Use the Copy button rather than manually selecting the result. It grabs the exact converted text with no extra whitespace.

What each format looks like

Given the same input, "the QUICK brown Fox jumps_over the-lazy dog," each format produces a distinct output. UPPER CASE gives you the full string in capitals with the original spacing. lower case flattens every letter down. Title Case capitalizes the first letter of every word and lowercases the rest, useful for headings but not for acronyms, since it will turn "USA" into "Usa." Sentence case treats the whole input as prose, capitalizing only the first letter of the sentence and anything following terminal punctuation. camelCase and PascalCase strip spaces, underscores, and hyphens entirely and rely on capitalization alone to mark word boundaries, differing only in whether the very first letter is capitalized. snake_case, kebab-case, and CONSTANT_CASE all keep an explicit separator between words instead of leaning on capitalization, which is part of why they're easier to read in contexts like URLs or file names where capitalization can get lost or normalized away.

Where naming conventions come from

Most of these conventions exist because different languages and platforms adopted different defaults decades ago, and the community around each one stuck with it. Python's official style guide, PEP 8, specifies snake_case for variables and functions. JavaScript's community norms settled on camelCase early on, largely following Java's lead. CSS has used kebab-case since its earliest versions because CSS doesn't allow underscores in some contexts and treats hyphens as literal characters rather than operators. Environment variables use CONSTANT_CASE by convention across nearly every shell and operating system, signaling at a glance that a name is a constant rather than a regular variable. None of these rules are enforced by a compiler in most cases; they're conventions that make code easier for other developers to read, which is exactly why consistency matters more than which format you personally prefer.

Is the Case Converter free?

Is my text uploaded anywhere?

Do I need an account?

What is the difference between camelCase and PascalCase?

What is kebab-case used for?