WebToolsPlanet
text Tools

Case Converter

Convert text between uppercase, lowercase, title case, sentence case, camelCase, PascalCase, snake_case, kebab-case, and CONSTANT_CASE instantly.

Last updated: March 25, 2026

Used 39K+ times
Client-Side Processing
Input Data Stays on Device
Instant Local Execution

What users say

“Converting snake_case database columns to camelCase for API responses used to be a mental chore. This does all 9 cases instantly — I use it multiple times a day.”
Mike L. — Full-Stack Developer
“Invaluable when switching between Python and JavaScript projects. The BEM/CSS naming convention tip in the notes was a bonus I didn't expect.”
Diana F. — Technical Writer

Find this tool useful? Support the project to keep it free!

Buy me a coffee

What is Case Converter?

Text case conventions are naming rules that define how words are capitalized or delimited in identifiers, headlines, file names, and programming constructs. Each programming language, ecosystem, and context has a dominant convention: Python variables use `snake_case`; JavaScript uses `camelCase` for variables and `PascalCase` for classes; CSS class names use `kebab-case`; environment variables use `CONSTANT_CASE`; database column names use `snake_case`; URL slugs use `kebab-case`; editorial headlines use `Title Case`.

Converting between cases manually is tedious and error-prone — especially for multi-word names where you need to split on spaces, camelCase humps, or underscores before re-joining in a new format. This tool handles the full split-transform-join pipeline: you paste any text (regardless of its current case) and click the target case to instantly get the correctly formatted output. All 9 common cases are supported: UPPERCASE, lowercase, Title Case, Sentence case, camelCase, PascalCase, snake_case, kebab-case, and CONSTANT_CASE.

How to Use Case Converter

1

Paste or type your text in the input field — it can be in any current case (space-separated, camelCase, snake_case, etc.)

2

Click any case button to convert: UPPERCASE, lowercase, Title Case, Sentence case, camelCase, PascalCase, snake_case, kebab-case, CONSTANT_CASE

3

The output updates instantly — view the result in the output panel below the buttons

4

Click "Copy" to copy the converted text to your clipboard

5

Keep clicking different case buttons to explore how the same text looks in each convention

Common Use Cases

  • Converting a space-separated product name ("User Profile Settings") to camelCase for JavaScript variable: userProfileSettings
  • Transforming a Python snake_case function name ("get_user_profile") to a React component PascalCase: GetUserProfile
  • Converting a blog post title to kebab-case for a URL slug: "how-to-use-typescript" from "How to Use TypeScript"
  • Uppercasing variable names to CONSTANT_CASE for environment variables and .env files: DATABASE_CONNECTION_STRING
  • Converting a database column name (user_created_at) to camelCase for a JSON API response field: userCreatedAt
  • Normalizing inconsistently capitalized user input (all-caps, mixed) to sentence case for storage
  • Converting a CSS class name (`.main-navigation-bar`) to a JavaScript object key in camelCase: mainNavigationBar
  • Generating file names conforming to project naming conventions: from component name to kebab-case file path

Example Input and Output

Converting "user profile settings" to all 9 case conventions:

Input text
user profile settings
All case outputs
UPPERCASE:     USER PROFILE SETTINGS
lowercase:     user profile settings
Title Case:    User Profile Settings
Sentence case: User profile settings
camelCase:     userProfileSettings
PascalCase:    UserProfileSettings
snake_case:    user_profile_settings
kebab-case:    user-profile-settings
CONSTANT_CASE: USER_PROFILE_SETTINGS

Client-Side Processing

All case conversion runs in your browser. Text is never sent to our servers.

Case Conversion in Code

For programmatic case conversion in code: JavaScript/TypeScript: use the lodash utility library (_.camelCase(), _.kebabCase(), _.snakeCase(), _.startCase()) or the change-case npm package (camelCase, pascalCase, snakeCase, kebabCase, constantCase). Python: use str.lower(), str.upper(), str.title() for basic cases; the inflection library for snake_case/camelCase conversions. These libraries handle edge cases like acronyms (HTMLParser → html_parser → htmlParser) more reliably than hand-rolled regex.

CSS Naming Conventions

CSS class names use kebab-case by universal convention (.main-nav, .hero-section, .card-grid) because CSS property names themselves use kebab-case (font-size, background-color, border-radius). BEM (Block Element Modifier) methodology extends this: .block__element--modifier pattern (.card__title--featured). CSS Modules and CSS-in-JS tools (styled-components, Emotion) often bridge the gap — component props use camelCase in JavaScript but the generated CSS class names may use kebab-case or hashed names.

Frequently Asked Questions

What is camelCase vs PascalCase?
camelCase (lowerCamelCase): the first word is fully lowercase, subsequent words are capitalized — no separators: userProfileSettings, onClick, firstName. Uses: JavaScript/TypeScript variables, functions, and class properties; Java variables; JSON keys; React props. PascalCase (UpperCamelCase): every word including the first is capitalized: UserProfileSettings, OnClick, FirstName. Uses: TypeScript/Java class names; React component names; C# class and method names; .NET types. The "camel" in camelCase refers to the humped shape of the mid-capital letters.
When should I use snake_case vs kebab-case?
snake_case (words joined by underscores): Python variables, functions, and module names (pep8_style); Ruby variables and methods; database column names (user_created_at); GraphQL field names; file names in Python projects (my_module.py). kebab-case (words joined by hyphens): CSS class names (.main-navigation); HTML data attributes (data-user-id); URL slugs and route paths (/blog/my-article); npm package names (react-query); file names in JavaScript projects (user-profile.tsx). Note: kebab-case cannot be used for JS variable names — hyphens are subtraction operators.
What is Title Case and how does it differ from Sentence case?
Title Case: every major word is capitalized (nouns, verbs, adjectives, adverbs) while minor words (articles: a/an/the, short prepositions: in/of/at, conjunctions: and/but/or) stay lowercase unless they're the first or last word: "The Quick Brown Fox Jumps Over the Lazy Dog". Rules vary slightly between AP Style, Chicago Manual of Style, and APA. Sentence case: only the first word and proper nouns are capitalized — exactly as you'd write a sentence: "The quick brown fox jumps over the lazy dog". Blog post titles typically use Title Case; body text, button labels, and UI labels often use sentence case for more conversational tone.
What is CONSTANT_CASE and when is it used?
CONSTANT_CASE (SCREAMING_SNAKE_CASE): all letters uppercase, words separated by underscores: DATABASE_URL, MAX_RETRY_COUNT, API_KEY. Used for: environment variables (in .env files and shell scripts), compile-time constants in C/Java/C++ (#define MAX_BUFFER_SIZE 1024), globally scoped immutable values in JavaScript/TypeScript (const API_URL = ""), Python module-level constants (PEP 8 convention: MAX_CONNECTIONS = 100), and configuration keys in systems like AWS CloudFormation and Kubernetes ConfigMaps.
How does the converter handle text that is already in camelCase?
The converter first normalizes the input by splitting it into individual words regardless of the input case format. For camelCase/PascalCase input: it splits on uppercase letter boundaries (insertBefore → ["insert", "Before"]). For snake_case/kebab-case: it splits on underscores/hyphens. For space-separated text: it splits on spaces. After word extraction, it applies the target case transformation to the normalized word array. This means converting "userProfileSettings" (camelCase) to snake_case correctly produces "user_profile_settings".
Does this work with non-English characters and accented letters?
Basic uppercase/lowercase conversion works with most Unicode characters — JavaScript's String.prototype.toUpperCase() and toLowerCase() are Unicode-aware and handle: accented characters (é → É), German ß → (SS in uppercase), Greek letters, and most Latin-extended characters. However, programming cases (camelCase, snake_case, kebab-case) work best with ASCII text — the word-boundary detection logic splits on common separators and capital letters, which may not correctly identify word boundaries in non-Latin scripts (e.g., Arabic, Chinese, Japanese have no concept of letter case).

How This Tool Works

Input text is first tokenized into an array of words by (1) splitting for space-separated words, (2) splitting on underscore or hyphen delimiters for snake_case/kebab-case, and (3) splitting camelCase/PascalCase on uppercase letter boundaries using a regex (/[A-Z]?[a-z]+|[A-Z]+(?=[A-Z]|$)/g). All words are then lowercased to normalize. The target case transformation is applied: for camelCase, the first word stays lowercase and subsequent words are capitalized; for snake_case, words are joined by underscores in lowercase; etc. The transformed word array is joined and returned.

Technical Stack

JavaScript String APIsRegex word boundary splittingUnicode-aware toUpperCase/toLowerCaseClient-side only

Related Tools

Lorem Ipsum Generator
Generate placeholder text for your designs and mockups — by paragraph, sentence, or word count, with classic or random variation.
Word Counter
Count words, characters, sentences, paragraphs, and reading time — with keyword density analysis and platform-specific character limit indicators.
Text Diff Checker
Compare two text blocks and see additions, deletions, and changes highlighted line-by-line using the Myers diff algorithm — like Git diff in a browser.
Regex Tester
Test and debug regular expressions with live match highlighting, capture group display, and flag explanations — using JavaScript's native RegExp engine.
HTML Entity Encoder / Decoder
Convert special characters to HTML entities (& → &) and decode them back — for safe, valid HTML.
Text Sorter
Sort lines alphabetically, numerically, by length, or randomly — with case-sensitive and reverse order options.