13 tools

Case Converter - Change Text Case Online Free

Convert text between sentence case, UPPERCASE, lowercase, camelCase, snake_case, and more. Free instant conversion.

Try the Tool

100% Free No Sign-up Instant Results Privacy First

Text Tool

Case Converter

Convert text to sentence case, lower case, upper case or capitalized case quickly.

About This Tool

What Is a Case Converter?

A case converter is an online text transformation tool that changes the capitalization of your text between multiple standardized formats. Whether you are writing code, preparing content for publication, formatting headings for a blog post, or setting up database column names, a case converter lets you switch between conventions in a single click without retyping your text manually.

This free online Case Converter supports 10 distinct text case modes: sentence case, lower case, UPPER CASE, Capitalized Case, Title Case, camelCase, PascalCase, snake_case, kebab-case, and constantCase. The tool processes everything directly in your browser, so your text never leaves your device. No account is required, and there are no usage limits.

How to Convert Text Case in 3 Easy Steps

Paste or Type Your Text — Enter your text into the textarea. You can type directly, paste from your clipboard, or import from a file.
Select a Case Mode — Choose from 10 available modes: sentence case, lower case, UPPER CASE, Capitalized Case, Title Case, camelCase, PascalCase, snake_case, kebab-case, or constantCase.
Copy or Download the Result — The converted text appears instantly. Click the copy button to copy it to your clipboard or download it as a text file.

All 10 Case Modes Explained with Examples

1. Sentence Case

Sentence case capitalizes only the first letter of the first word, just like a regular sentence. All other words remain lowercase unless they are proper nouns. This is the most natural reading format and is used for body text, paragraphs, and most content.

Example: the quick brown fox jumps over the lazy dog becomes The quick brown fox jumps over the lazy dog.

2. Lower Case

Lower case converts all characters to lowercase, removing all capitalization. This is useful for normalizing text before comparison, generating URL-friendly strings, or preparing input for case-insensitive searches.

Example: Hello World becomes hello world.

3. UPPER CASE

UPPER CASE converts all characters to uppercase. This format is used for acronyms, emphasis in writing, constants in programming, and headlines in certain design styles. Be aware that overusing uppercase can make text harder to read.

Example: hello world becomes HELLO WORLD.

4. Capitalized Case

Capitalized Case capitalizes the first letter of every word. Unlike Title Case, it does not follow any rules about which words to capitalize or lowercase. Every single word starts with an uppercase letter, regardless of word length or part of speech.

Example: the quick brown fox becomes The Quick Brown Fox.

5. Title Case

Title Case follows standard headline capitalization rules. Major words are capitalized, while minor words like "a," "an," "the," "and," "or," and "but" remain lowercase unless they appear as the first or last word. This format is used for blog titles, article headlines, and publication names.

Example: the art of war becomes The Art of War.

6. camelCase

camelCase starts with a lowercase letter and capitalizes the first letter of each subsequent word. It is the dominant naming convention for variables, functions, and methods in JavaScript, TypeScript, Java, and C#. camelCase improves readability by distinguishing individual words without requiring spaces or separators.

Example: my variable name becomes myVariableName.

7. PascalCase

PascalCase capitalizes the first letter of every word, including the first word. It is used for class names, component names, type definitions, and constructor functions in most object-oriented programming languages. PascalCase is essentially UpperCamelCase and helps identify class-level identifiers at a glance.

Example: my class name becomes MyClassName.

8. snake_case

snake_case separates words with underscores and uses all lowercase letters. It is the standard naming convention in Python (per PEP 8), Ruby, Rust, and most database schemas. snake_case is also common for file names and configuration keys in Unix-like systems.

Example: my variable name becomes my_variable_name.

9. kebab-case

kebab-case separates words with hyphens and uses all lowercase letters. It is widely used for CSS class names, HTML attribute values, URL slugs, Linux file names, and command-line arguments. kebab-case is the most common format for web-related naming.

Example: my variable name becomes my-variable-name.

10. constantCase

constantCase converts all letters to uppercase and separates words with underscores. This format is used for constants, environment variables, and configuration keys across most programming languages. It signals that a value is defined once and should not change during execution.

Example: my constant value becomes MY_CONSTANT_VALUE.

camelCase vs PascalCase vs snake_case vs kebab-case: Key Differences

Understanding the difference between these four formats is essential for developers working across multiple programming languages:

camelCase — myVariableName. Starts lowercase. Used in JavaScript, Java, C#, and TypeScript for variables and functions.
PascalCase — MyVariableName. Starts uppercase. Used for class names, component names, and type definitions.
snake_case — my_variable_name. All lowercase with underscores. Used in Python, Ruby, databases, and system configuration.
kebab-case — my-variable-name. All lowercase with hyphens. Used in CSS, HTML, URLs, and Linux systems.

The choice depends on the programming language, the context of use, and the team or community convention. This tool makes switching between them effortless.

When to Use Each Case in Programming

camelCase — JavaScript variables, TypeScript interfaces, React hook names, Java method names, C# properties.
PascalCase — JavaScript classes, React components, C# classes, TypeScript types, constructor functions.
snake_case — Python variables and functions (PEP 8), database column names, environment config files, Rust variables.
kebab-case — CSS class and ID selectors, HTML attributes, URL slugs, Docker commands, npm package names.
UPPER_SNAKE_CASE — JavaScript and Python constants, environment variables, API keys, configuration flags.
lower case — URL paths, file names, package names, case-insensitive comparisons.

Use Cases for Case Conversion Beyond Programming

Case conversion is not only useful for developers. Content writers use Title Case for blog post headings and article titles. SEO specialists format meta titles in Title Case and URLs in kebab-case to match search engine best practices. Students and researchers convert text to proper sentence case for academic papers and citations. Translators and editors standardize text casing across multilingual content for consistency in labels, headings, and UI strings.

For counting words and characters in your text, use the Word Counter tool. To generate SEO-friendly URL slugs from text, try the Text to Slug converter.

Text Statistics in Real Time

The Case Converter displays live statistics for your input text, including character count, word count, sentence count, paragraph count, and estimated reading time. These statistics help you understand the scope of your text before and after conversion. Since case conversion does not change the structure of your text, the statistics will remain the same regardless of which case mode you choose.

Privacy and Security

All case conversion happens entirely in your browser using JavaScript. Your text is never uploaded to a server, transmitted over the network, or stored anywhere. This means your content remains completely private, making the tool safe to use with sensitive documents, proprietary code, confidential business text, and personal information.

Case conversion follows standard naming conventions. Some edge cases like acronyms, abbreviations, and Unicode characters may produce unexpected results depending on the input. For best results, review converted text before using it in production code or published content.

AI Overview

A case converter is an online text transformation tool that changes the capitalization of input text between multiple standardized formats. It supports ten distinct modes: sentence case, lower case, UPPER CASE, Capitalized Case, Title Case, camelCase, PascalCase, snake_case, kebab-case, and constantCase. The tool processes text entirely in the browser, providing instant results without server uploads.

Quick Answers

What is a case converter?

A case converter is an online tool that changes the capitalization of your text. It can convert text between formats like sentence case, lowercase, UPPERCASE, camelCase, PascalCase, snake_case, kebab-case, and more.

What is the difference between camelCase and PascalCase?

camelCase starts with a lowercase letter and capitalizes subsequent words (e.g., myVariableName). PascalCase starts with an uppercase letter and capitalizes all words (e.g., MyVariableName). PascalCase is used for class names; camelCase is used for variables and functions.

Is this case converter free?

Yes. The Case Converter is 100% free with no registration, no usage limits, and no hidden fees. Convert unlimited text as many times as you need.

Does case conversion change word count?

No. Case conversion only changes the capitalization of letters. The number of words, characters, sentences, and paragraphs remains the same.

Formula / Algorithm

Understanding the Case Converter Algorithm

The Case Converter tool is designed to alter the case of text inputs, making it easier for users to format their text according to their needs. The algorithm behind this tool uses basic string manipulation techniques to convert text into various cases, such as uppercase, lowercase, title case, and others.

Core Logic

The primary logic of the Case Converter relies on iterating through each character of the input string and applying specific transformations based on the desired output case.

Steps Involved

Input Retrieval: The first step is to retrieve the input string from the user. For example, the input string could be "hello world".
Character Iteration: The algorithm then iterates through each character in the string. This is typically done using a loop.
Case Conversion: During each iteration, the algorithm checks the current case of the character:

If converting to Uppercase, it applies the transformation to make the character uppercase.
If converting to Lowercase, it applies the transformation to make the character lowercase.
If converting to Title Case, it capitalizes the first letter of each word while making the rest lowercase.

Building the Output: The transformed characters are collected into a new string.
Output Display: Finally, the output string is displayed to the user.

Practical Example

For instance, if the input string is "hello world" and the desired case is Uppercase, the algorithm processes each character:

h -> H
e -> E
l -> L
l -> L
o -> O
space remains unchanged
w -> W
o -> O
r -> R
l -> L
d -> D

The final output will be "HELLO WORLD". This step-by-step approach ensures that users can effectively convert text to their desired case with ease.

How to Use the Case Converter - Change Text Case Online Free

Enter your text into the textarea input area. You can type directly, paste from your clipboard, or import text from a file.
Choose from 10 available case modes: sentence case, lower case, UPPER CASE, Capitalized Case, Title Case, camelCase, PascalCase, snake_case, kebab-case, or constantCase.
The converted text appears instantly. Click the copy button to copy it to your clipboard or download it as a text file for later use.

Live Examples

Input: hello world

Output: HELLO WORLD

Explanation: The input text has been transformed to uppercase letters, making it suitable for emphasis or titles.

Input: HELLO WORLD

Output: hello world

Explanation: The input text has been changed to lowercase letters, which is useful for standardizing text formatting.

Input: Hello World

Output: hELLO wORLD

Explanation: The tool has switched the case of each letter, providing a fun way to alter text for stylistic purposes.

Input: this is a sample text

Output: This Is A Sample Text

Explanation: Each word in the input has been capitalized, which is ideal for headings or titles.

Input: tHIS IS A sAMPLE tEXT.

Output: This is a sample text.

Explanation: The tool has transformed the input into proper sentence case, correcting capitalization for readability.

Benefits

10 Case Modes
Instant Results
No Registration Required
Detailed Text Statistics
Privacy-First
Works on Any Device

Common Mistakes

Confusing camelCase with PascalCase \u2014 camelCase starts with a lowercase letter, PascalCase starts with an uppercase letter
Using Title Case when you need Capitalized Case \u2014 Title Case follows capitalization rules for major words, while Capitalized Case capitalizes every word
Forgetting that snake_case and kebab-case remove all spaces \u2014 these formats use underscores or hyphens as word separators
Selecting CONSTANT_CASE instead of lower case when building database column names \u2014 database fields are typically lowercase_snake_case, not UPPERCASE_SNAKE_CASE
Not checking word count or paragraph count after converting \u2014 case conversion should not change the text structure, so verify the output if something looks wrong

Professional Tips

Use camelCase for JavaScript and TypeScript variable names, function names, and method names to follow standard naming conventions
Use PascalCase for class names, component names, and constructor functions to distinguish them from variables and functions
Use snake_case for Python variable names, function names, and file names to follow PEP 8 style guidelines
Use kebab-case for CSS class names, HTML IDs, URL slugs, and file names to keep them web-friendly and readable
Use UPPER_SNAKE_CASE for environment variables, constants, and configuration keys across most programming languages

Common Use Cases

Developers

Convert variable names between camelCase, PascalCase, snake_case, and kebab-case when working across different programming languages or frameworks.

Content Writers

Quickly switch between sentence case and title case for headings, subheadings, blog posts, and article titles without manual retyping.

SEO Specialists

Format meta titles in Title Case, URLs in kebab-case, and keywords in lower case to match search engine best practices.

Students and Researchers

Convert text to proper sentence case for academic papers, essays, and citation formats without spending time on manual capitalization.

Database Administrators

Transform column names and table names between camelCase and snake_case when migrating data between different database systems.

Translators and Editors

Standardize text casing across multilingual content to ensure consistency in headings, labels, and UI strings.

Related Concepts

camelCase

A naming convention where the first word is lowercase and each subsequent word starts with an uppercase letter. Examples: firstName, backgroundColor, onClick. Used widely in JavaScript, Java, and C# for variables and functions.

PascalCase

A naming convention where every word starts with an uppercase letter, including the first word. Examples: FirstName, BackgroundColor, OnClick. Used for class names, component names, and type definitions.

snake_case

A naming convention where words are separated by underscores and all letters are lowercase. Examples: first_name, background_color, on_click. The standard for Python, Ruby, and database schemas.

kebab-case

A naming convention where words are separated by hyphens and all letters are lowercase. Examples: first-name, background-color, on-click. Common in CSS, HTML attributes, URL slugs, and Linux file names.

Title Case

A capitalization style where the first letter of each major word is capitalized. Minor words like "a", "the", and "of" are typically lowercase unless they are the first word. Common in headlines and titles.

UPPER_SNAKE_CASE

A convention where all letters are uppercase and words are separated by underscores. Examples: FIRST_NAME, MAX_RETRY_COUNT. The standard for constants, environment variables, and configuration keys.

Frequently Asked Questions

A case converter is an online tool that changes the capitalization of text between formats such as sentence case, lowercase, UPPERCASE, camelCase, PascalCase, snake_case, and kebab-case. It is commonly used by developers, writers, and SEO professionals.

The ten modes are: sentence case (first letter capitalized), lower case (all lowercase), UPPER CASE (all uppercase), Capitalized Case (every word capitalized), Title Case (headline-style capitalization), camelCase, PascalCase, snake_case, kebab-case, and constantCase.

camelCase starts with a lowercase letter and capitalizes each subsequent word (myVariableName). PascalCase starts with an uppercase letter (MyVariableName). Use camelCase for variables and functions, and PascalCase for class names.

snake_case uses underscores to separate words (my_variable_name), while kebab-case uses hyphens (my-variable-name). snake_case is common in Python and databases; kebab-case is common in CSS, URLs, and HTML attributes.

UPPER_SNAKE_CASE (constantCase) is used for constants, environment variables, and configuration keys. It signals that a value should not be changed after initialization.

Yes. Paste your variable name, select the target case mode, and copy the converted result. This is especially useful when migrating code between languages that use different naming conventions.

No. Converting text to a different case does not change the number of characters, words, sentences, or paragraphs. The text statistics displayed by the tool reflect your original input.

No. All case conversion happens in your browser using JavaScript. Your text is never uploaded to a server, ensuring complete privacy.