Free Case Converter Online

What is a case converter?

A case converter transforms text between different capitalization formats instantly. It handles everything from simple uppercase/lowercase conversion to developer-specific naming conventions like camelCase, snake_case, and kebab-case — in one click, with no manual editing.

Developers use case converters to reformat variable names when switching languages, normalize database column names, or convert copy from content teams into code-safe identifiers. Writers use them to fix accidental caps lock, apply consistent headline capitalization, and prepare text for different publishing platforms.

How to use the case converter

1. 1
   Type or paste your text

   Enter any text in the left input field. The converter handles multi-line input, mixed cases, and text with numbers or symbols.

2. 2
   Select a conversion format

   Click any format button — Text group (Sentence, lower, UPPER, Title, Capitalized), Code group (camelCase, PascalCase, snake_case, kebab-case, CONSTANT_CASE), or Fun group (aLtErNaTiNg, iNVERSE).

3. 3
   View the result

   The converted text appears instantly in the right panel. Code formats (camelCase, snake_case, etc.) use a monospace font for better readability.

4. 4
   Copy the output

   Click Copy to grab the converted text. Switch between formats without re-entering your text.

Naming convention guide for developers

Different programming languages and contexts have established naming conventions. Following them makes code more readable and consistent with the ecosystem:

Real-world case conversion scenarios

These are the most common situations where you need a case converter — each requires a specific transformation:

Title case rules — which words to capitalize

Title case is more complex than simply capitalizing every word. Different style guides disagree on edge cases, but the most widely followed rules (AP Style, Chicago Manual) agree on the basics:

Naming conventions across popular tech stacks

Each ecosystem has community-wide conventions baked into linters, code review expectations, and standard library design. Following them makes your code feel native to the stack and avoids friction during code review:

Automating case transformations in your codebase

Manual case conversion does not scale. When you are building APIs, transforming database schemas to JavaScript objects, or processing user-generated content, you need programmatic solutions. Here are the standard approaches:

API response normalization is one of the most common use cases. REST APIs from different backends use different conventions — a Python/Django API returns snake_case keys, a Java API returns camelCase or PascalCase, and some legacy APIs return UPPER_CASE. Libraries like camelcase-keys (npm) automatically convert all keys in a JSON response to camelCase, preventing inconsistent property names in your frontend codebase.

Linters enforce naming conventions automatically during development. ESLint's camelcase and @typescript-eslint/naming-convention rules report violations in your IDE as you type. Python's Flake8 and Pylint enforce PEP 8 naming. Setting these up once ensures all team members follow the same conventions without code review comments about naming.

Database-to-code mapping is another friction point. SQL tables and columns use snake_case by convention, but JavaScript objects typically use camelCase. ORMs like Prisma handle this automatically (a column created_at becomes createdAt in the Prisma client). If you write raw SQL, consider a lightweight mapping utility to keep both layers idiomatic.

File rename migrations occasionally require batch case conversion. Renaming a directory of React components from kebab-case to PascalCase, or standardizing a Python package's module files to snake_case, can be done with a shell script using rename (Linux/macOS) or the rename-cli npm package. Always run these with a dry-run flag first and update your import statements with a global find-and-replace afterward.

Choosing the right case for different contexts

The correct case convention is not just a style preference — it communicates intent and context to anyone reading your code. Using the wrong case creates cognitive friction and can even introduce bugs (for example, CSS class names with uppercase letters will not match, and Linux file paths are case-sensitive while Windows ones are not).

For UI copy (buttons, labels, navigation): Use sentence case as the default. Modern UI guidelines from Apple (Human Interface Guidelines), Google (Material Design), and Microsoft (Fluent Design) all recommend sentence case for labels and buttons because it reads more naturally and feels less formal. Reserve Title Case for page headings and dialog titles that function like document titles.

For API design: Choose one convention and apply it consistently across all endpoints. The most common REST API convention is camelCase for JSON property names (matching JavaScript object conventions) and kebab-case for URL path segments (/user-profiles not /userProfiles). GraphQL schemas use camelCase for field names and PascalCase for type names.

For file and folder naming: kebab-case is the safest choice for web projects because it is URL-safe, works consistently across Linux, macOS, and Windows, and avoids case collision issues when files are moved between operating systems. Component files in React projects are a common exception — PascalCase.tsx matches the component name and makes imports readable.