Home›Converters›Numbers›Case Converter

Case Converter

Numbers

Convert text between letter cases: UPPER, lower, Title, camelCase, PascalCase, snake_case, kebab-case, CONSTANT_CASE, and more. Free online tool for developers.

Reviewed by the thecalcu.com team · Last updated June 15, 2026

Input Text
19 chars · 3 words
UPPER CASE
HELLO WORLD EXAMPLE
lower case
hello world example
Title Case
Hello World Example
Sentence case
Hello world example
camelCase
helloWorldExample
PascalCase
HelloWorldExample
snake_case
hello_world_example
kebab-case
hello-world-example
CONSTANT_CASE
HELLO_WORLD_EXAMPLE
dot.case
hello.world.example

What is a Case?

A Case Converter transforms text between different letter case formats used in programming, writing, and URL design. Each case format encodes word boundaries differently, through capitalisation, underscores, hyphens, or dots, and different contexts demand different conventions.

This tool converts any input text into ten standard formats simultaneously:

Case Example
UPPER CASE HELLO WORLD EXAMPLE
lower case hello world example
Title Case Hello World Example
Sentence case Hello world example
camelCase helloWorldExample
PascalCase HelloWorldExample
snake_case hello_world_example
kebab-case hello-world-example
CONSTANT_CASE HELLO_WORLD_EXAMPLE
dot.case hello.world.example

For Indian developers and writers, switching between these formats is a daily task, JavaScript variables use camelCase, Python functions use snake_case, database columns use snake_case, class names use PascalCase, URL slugs use kebab-case, and environment variables use CONSTANT_CASE. Moving code between layers (frontend → API → database) means constant renaming that this converter automates in a single step.

Use alongside the Number Base Converter and Word Count Calculator for complete text and number tooling.

Why Use a Case Converter?

Manually reformatting variable names is error-prone and tedious. The most common mistake is accidentally keeping a hyphen in a JavaScript variable (user-name instead of userName), which causes a syntax error. Similarly, forgetting to convert userId to user_id when writing a SQL query is a frequent source of runtime errors that TypeScript and Python type checkers cannot catch.

Two concrete developer use cases:

  1. API response to database column mapping: A backend developer at a Bangalore startup receives a JSON API with userFirstName, userLastName, emailAddress (camelCase). The PostgreSQL database uses user_first_name, user_last_name, email_address (snake_case). Pasting all three field names and clicking snake_case instantly produces the correct database column names.

  2. URL slug generation: A content team in Chennai needs URL-safe slugs for 50 blog article titles. Titles like "How to File ITR in India" must become how-to-file-itr-in-india. Pasting the title and clicking kebab-case produces the correct slug in one step, ready to paste into the CMS.

Who Should Use This Converter?

Frontend and backend developers who move data between layers with different naming conventions, camelCase in JavaScript, snake_case in Python/databases, PascalCase for class names.

Database administrators and data engineers who need to convert API field names to PostgreSQL/MySQL column names (camelCase → snake_case) or generate CONSTANT_CASE environment variable names from readable descriptions.

Content writers and editors who need to standardise heading case across articles, distinguish Title Case from Sentence case, or generate URL-safe slugs from article titles in kebab-case.

DevOps and cloud engineers who generate CONSTANT_CASE configuration keys for .env files, Kubernetes ConfigMaps, AWS Parameter Store, and environment variables in CI/CD pipelines.

SEO specialists who generate kebab-case URL slugs from page titles to ensure search engine-friendly URLs. See the Number to Words Converter for number formatting in content.

What Insights Does the Case Converter Give You?

The 10 case output cards show every variant of your input simultaneously, paste once and get all formats at once, eliminating multiple reformatting steps.

Each card has a Copy button that puts the result directly on your clipboard, ready to paste into your IDE, CMS, database schema tool, or terminal.

Practical interpretation guide:

  • If your result in camelCase, snake_case, and kebab-case is the same single token (no separators), your input was likely a single word, check if you intended a multi-word phrase.
  • If the Title Case result has too many capitals, your input may contain abbreviations (like "API" or "ITR") that the splitter treats as sequences of single-letter words.
  • CONSTANT_CASE and snake_case produce the same separator pattern; they differ only in capitalisation.

How to use this Case calculator

  1. The converter loads with "Hello World Example" as the default input to demonstrate all 10 output formats.
  2. Click inside the Input Text area and type or paste your text. All 10 case variants update instantly.
  3. The character count and word count below the textarea update as you type, useful for verifying that the word splitter detected the correct number of words in your input.
  4. Click Copy on the card for your target case format to copy it to clipboard.
  5. Use the Clear button (bottom-right of the input area) to reset the input and start fresh.
  6. The URL updates as you type, share the URL with a pre-filled input by copying it from your browser's address bar.
  7. For mixed inputs like getUserProfileData or get-user-profile-data, check the snake_case output: if it shows get_user_profile_data, the word splitting worked correctly.

Formula & Methodology

The converter splits input into words before applying case rules. Word boundaries are detected by:

1. camelCase/PascalCase boundaries, a lowercase letter followed by an uppercase letter (e.g. helloWorld → hello, World)
2. Consecutive capitals followed by a lowercase letter, ABCDef → ABC, Def
3. Separator characters, hyphens, underscores, and dots are treated as word separators and removed
4. Whitespace, spaces and tabs split words as expected

After splitting, each target case is applied:

UPPER CASE:    words → joined with spaces → .toUpperCase() lower case:    words → joined with spaces → .toLowerCase() Title Case:    words → each word capitalised → joined with spaces Sentence case: full text → .toLowerCase() → first char capitalised camelCase:     words → first word lowercase, rest capitalised → joined PascalCase:    words → each word capitalised → joined snake_case:    words → all lowercase → joined with '_' kebab-case:    words → all lowercase → joined with '-' CONSTANT_CASE: words → all uppercase → joined with '_' dot.case:      words → all lowercase → joined with '.'

Example, "getUserProfileData":

| Step | Result |
|---|---|
| Detect boundaries | get, User, Profile, Data |
| Normalise | get, user, profile, data |
| camelCase | getUserProfileData |
| snake_case | get_user_profile_data |
| kebab-case | get-user-profile-data |
| CONSTANT_CASE | GET_USER_PROFILE_DATA |

Edge case: abbreviations like "ITR", "API", "GST" are treated as sequences of single letters by the camelCase detector. "fileITROnline" splits as file, I, T, R, Online, which may not be the intended result. For abbreviation-heavy text, consider adding spaces manually before converting.

Frequently Asked Questions

A Case Converter transforms text between different letter case formats, such as UPPER CASE, lower case, camelCase, snake_case, PascalCase, and kebab-case. Each case format serves a specific purpose in programming, content writing, database design, and URL structuring. This tool converts any input text into all ten standard cases simultaneously, with one-click copy for each result.
camelCase writes the first word in lowercase and capitalises the first letter of each subsequent word, with no spaces or separators, for example, 'helloWorldExample'. It is the dominant convention for variable and function names in JavaScript, TypeScript, Java, Swift, and Kotlin. In Indian software development contexts, camelCase is standard in most Node.js and React projects, which make up a large share of the Indian startup technology stack.
snake_case uses all lowercase letters with underscores separating words, for example, 'hello_world_example'. Python's PEP 8 style guide mandates snake_case for variable names, function names, and module names. PostgreSQL and MySQL database column names conventionally use snake_case since SQL is case-insensitive and underscores avoid quoting requirements. In Indian data engineering projects built on Python and PostgreSQL, snake_case is the most common naming convention.
PascalCase capitalises the first letter of every word with no separators, for example, 'HelloWorldExample'. It is the standard for class names in Java, C#, TypeScript, Python, and most object-oriented languages. Component names in React and Angular also use PascalCase (e.g., UserProfileCard). In Indian enterprise Java and .NET development, PascalCase is universally used for class and interface names.
kebab-case uses all lowercase letters with hyphens separating words, for example, 'hello-world-example'. It is the standard for URL slugs, CSS class names, HTML attributes, and npm package names. SEO-friendly URLs use kebab-case because hyphens are treated as word separators by search engines while underscores are not. On thecalcu.com, all calculator and converter URLs use kebab-case slugs, such as /sip-calculator-india/ and /speed-converter/.
CONSTANT_CASE uses all uppercase letters with underscores separating words, for example, 'HELLO_WORLD_EXAMPLE'. It is the universal convention for named constants and environment variables in most programming languages: Java, Python, C, JavaScript (for module-level constants). Environment variables in .env files always use CONSTANT_CASE (e.g., DATABASE_URL, API_SECRET_KEY, NODE_ENV). Indian DevOps and cloud engineering teams use CONSTANT_CASE for all infrastructure configuration values.
Title Case capitalises the first letter of every word, 'Hello World Example', and is used for article headings, page titles, and book chapter names. Sentence case only capitalises the first letter of the first word, 'Hello world example', and is used for body text, button labels, and UI copy. Indian content teams and English-language publications increasingly prefer Sentence case for body content and subheadings, following the style of major international publications.
Indian IT projects span multiple technology stacks with different conventions. Java enterprise projects (common in Indian banks, insurance, and large enterprises) use camelCase for methods, PascalCase for classes, and CONSTANT_CASE for constants. Python projects follow PEP 8: snake_case for variables and functions, PascalCase for classes. React/Node.js projects use camelCase for variables, PascalCase for components, and kebab-case for CSS. Database teams almost universally use snake_case for column names. Many Indian product startups adopt Google's Java Style Guide or Airbnb's JavaScript Style Guide.
Paste your snake_case text into the input field and click Copy next to the camelCase output. For example, 'user_profile_card' becomes 'userProfileCard'. The converter handles any combination of separators in the input, snake_case, kebab-case, dot.case, and even mixed camelCase inputs are all split into words correctly before converting to your target case.
dot.case uses all lowercase letters with dots separating words, for example, 'hello.world.example'. It is used in configuration file keys (such as Java .properties files and some YAML structures), logging namespace identifiers (log4j, SLF4J loggers are typically named 'com.company.module'), and some programming language module paths. dot.case is less common than camelCase and snake_case but appears regularly in enterprise Java and configuration management contexts.
The Case Converter splits input text into words before applying the target case, so mixed input formats are handled correctly. 'helloWorldExample', 'hello-world-example', 'hello_world_example', 'Hello World Example', and 'HELLO_WORLD_EXAMPLE' all produce the same word list ['hello', 'world', 'example'] and therefore the same output in each target case. CamelCase boundaries (a lowercase letter followed by an uppercase letter) are detected and treated as word separators.
Type or paste your text into the Input Text area at the top. All ten case variants, UPPER CASE, lower case, Title Case, Sentence case, camelCase, PascalCase, snake_case, kebab-case, CONSTANT_CASE, and dot.case, update instantly below. Click the Copy button on any card to copy that result to your clipboard. The input supports multi-word phrases, existing camelCase, snake_case, or any mixed format. The URL updates as you type, so you can share a pre-filled link.
Also known as
text case converteruppercase to lowercaselowercase to uppercasetitle case convertercamelCase convertersentence case convertersnake case converterkebab case convertertext to uppercasecapitalize text onlineconvert text case