Text Case Converter

Convert text to UPPERCASE, lowercase, Title Case, Sentence case, camelCase, PascalCase, snake_case, kebab-case, CONSTANT_CASE and more. 12 cases in real time. 100% client-side.

Convert text case without uploading your data

12 case conversions — including camelCase, snake_case, kebab-case, and more — all at once, right in your browser. No uploads, no sign-up, no limits.

100% private

Real-time conversion

Free forever

How to use

1
Paste Your Text
Type or paste text into the input box at the top. You can paste from any source — Word, code editor, browser, or chat.
2
View All 12 Cases
Every case variant appears instantly in a grid below — no buttons to click. Scroll through to compare all variants.
3
Copy The One You Need
Click the Copy button next to any variant to copy it to your clipboard. The button turns green briefly to confirm the copy.

Why Use This Text Case Converter?

12 cases at once, real-time conversion, and privacy-first design.

12 Cases at Once

See every common case variant in a single grid, so you can compare and pick the right one without switching tools.

Real-Time Conversion

All 12 outputs update instantly as you type — there is no 'Convert' button to click. Change your input and see all variants update.

Programming-Friendly

Includes camelCase, PascalCase, snake_case, kebab-case and CONSTANT_CASE — the standard naming conventions in JavaScript, Python, Rust, Go, and CSS.

Unicode Safe

Uses the browser's native toUpperCase/toLowerCase, which correctly handles accented characters, umlauts, and other Unicode text.

100% Private

All conversion happens in your browser. Your text is never uploaded, stored, or logged.

Free with No Limits

No registration, no API key, no daily quotas. Free for personal and commercial use, forever.

Understanding Text Case Conventions

Programming naming conventions

Programming languages have established naming conventions for different types of identifiers. Following these conventions makes code more readable and consistent with the language's ecosystem. JavaScript uses camelCase for variables and functions (e.g., `getUserData`), PascalCase for classes and React components (e.g., `UserProfile`), and UPPER_SNAKE_CASE for constants (e.g., `MAX_RETRIES`). Python uses snake_case for variables and functions (e.g., `get_user_data`) and PascalCase for classes (e.g., `UserProfile`).

CSS uses kebab-case for class names and IDs (e.g., `.primary-button`, `#main-content`). URLs use kebab-case for slugs (e.g., `/blog/how-to-use-regex`). Database column names typically use snake_case (e.g., `created_at`, `user_id`). Environment variables use UPPER_SNAKE_CASE (e.g., `DATABASE_URL`, `API_KEY`). Our tool supports all of these conventions, making it easy to convert between them.

Title Case vs. Sentence case

Title Case capitalizes the first letter of each significant word, following publishing conventions. Minor words (articles, conjunctions, short prepositions) are kept lowercase unless they appear at the beginning or end. For example, 'The Lord of the Rings' is correct Title Case. This is used for book titles, article headlines, and formal headings.

Sentence case capitalizes only the first letter of each sentence, with the rest in lowercase (except proper nouns). For example, 'The lord of the rings' is Sentence case. This is used for running text, descriptions, and informal headings. Some style guides prefer Sentence case for headings, arguing that it's cleaner and easier to read.

When to use each programming case

camelCase: JavaScript variables and functions, Java methods, C# variables. PascalCase: JavaScript/TypeScript classes and interfaces, React components, C# classes and methods. snake_case: Python variables and functions, Ruby variables and methods, Rust variables. kebab-case: CSS class names, HTML IDs, URL slugs, file names. CONSTANT_CASE: constants in most languages, environment variables, configuration keys.

Common Use Cases

Real-world scenarios where a text case converter saves time.

Renaming Code Identifiers

Convert a column name like 'User First Name' to `userFirstName` (camelCase) or `user_first_name` (snake_case) for your backend.

Cleaning Up Caps Lock

Accidentally typed a paragraph with Caps Lock on? Use the 'lowercase' option to fix it instantly.

Headlines & Titles

Apply Title Case to blog post titles, press release headlines, or book chapter headings in one click.

CSS Class Names

Convert 'primary button large' to `primary-button-large` (kebab-case) for HTML class attributes or `primary_button_large` for BEM.

How does this compare to other case converters?

A side-by-side comparison of popular text case conversion tools.

Feature	NovaTools	ConvertCase.net	CaseConverter.com
Privacy (no upload)	100% local	Uploads to server	Uploads to server
Price	Free unlimited	Free with ads	Free with ads
Number of cases	12	8	6
Programming cases	5 cases		Limited
Real-time conversion		Button	Button
Unicode support		Limited	Limited
Copy per variant			Limited
Works offline	After page load

Most online case converters upload your text to their server. Our tool processes everything locally — your text and code never leave your browser.

Text Case Quick Reference

Common text case conventions and their uses.

Programming Naming Conventions

Symbol / Code	Description	Example
`camelCase`	First word lowercase, subsequent words capitalized. Used for JS/Java variables and functions.	`getUserData`
`PascalCase`	All words capitalized. Used for classes, types, and React components.	`UserProfile`
`snake_case`	Words joined with underscores, all lowercase. Used in Python, Ruby, Rust.	`get_user_data`
`kebab-case`	Words joined with hyphens, all lowercase. Used for CSS classes and URL slugs.	`primary-button`
`CONSTANT_CASE`	All uppercase with underscores. Used for constants and environment variables.	`MAX_RETRIES`

camelCase

First word lowercase, subsequent words capitalized. Used for JS/Java variables and functions.

Example:getUserData

PascalCase

All words capitalized. Used for classes, types, and React components.

Example:UserProfile

snake_case

Words joined with underscores, all lowercase. Used in Python, Ruby, Rust.

Example:get_user_data

kebab-case

Words joined with hyphens, all lowercase. Used for CSS classes and URL slugs.

Example:primary-button

CONSTANT_CASE

All uppercase with underscores. Used for constants and environment variables.

Example:MAX_RETRIES

Publishing Conventions

Symbol / Code	Description	Example
`Title Case`	Capitalize significant words, lowercase articles/conjunctions/prepositions.	`The Lord of the Rings`
`Sentence case`	Capitalize only the first letter of each sentence.	`The lord of the rings`
`Capitalize Each Word`	Capitalize the first letter of every word, including minor words.	`The Lord Of The Rings`
`UPPERCASE`	All letters capitalized. Used for emphasis or acronyms.	`THE LORD OF THE RINGS`
`lowercase`	All letters lowercase. Used for casual text or code.	`the lord of the rings`

Title Case

Capitalize significant words, lowercase articles/conjunctions/prepositions.

Example:The Lord of the Rings

Sentence case

Capitalize only the first letter of each sentence.

Example:The lord of the rings

Capitalize Each Word

Capitalize the first letter of every word, including minor words.

Example:The Lord Of The Rings

UPPERCASE

All letters capitalized. Used for emphasis or acronyms.

Example:THE LORD OF THE RINGS

lowercase

All letters lowercase. Used for casual text or code.

Example:the lord of the rings

FAQ

Which case conversions are supported?

The tool supports 12 case conversions: UPPERCASE, lowercase, Title Case, Sentence case, Capitalize Each Word, camelCase, PascalCase, snake_case, kebab-case, CONSTANT_CASE, aLtErNaTiNg, and InVeRsE. Each conversion is applied to your text instantly and displayed in a grid, so you can compare all variants at once and copy the one you need. The programming-style cases (camelCase, PascalCase, snake_case, kebab-case, CONSTANT_CASE) treat spaces, dashes, underscores, and punctuation as word separators.

What is the difference between Title Case and Capitalize Each Word?

Title Case follows common publishing conventions (Associated Press style) and keeps short function words like 'a', 'an', 'the', 'in', 'on', 'at', 'to', 'for', 'of', 'and', 'but', 'or', 'nor', 'so', 'yet' lowercase unless they are the first or last word of the string. Capitalize Each Word (also called Start Case) uppercases the first letter of every word regardless of its part of speech. For example, 'the lord of the rings' becomes 'The Lord of the Rings' in Title Case but 'The Lord Of The Rings' in Capitalize Each Word.

How does camelCase handle non-alphanumeric characters?

All non-alphanumeric characters (spaces, dashes, underscores, punctuation, special characters) are treated as word separators and removed. The first word is lowercase, and each subsequent word starts with an uppercase letter. For example, 'hello world!' becomes 'helloWorld', 'user-first-name' becomes 'userFirstName', and 'API_KEY' becomes 'apiKey'. This behavior matches the convention used by most programming languages and code formatters like Prettier.

What is CONSTANT_CASE used for?

CONSTANT_CASE (all uppercase with underscores between words) is the convention for naming constants in many programming languages. For example, `MAX_RETRY_COUNT`, `DEFAULT_TIMEOUT`, `API_BASE_URL` in JavaScript, Python, Java, Go, and Rust. It is also used for environment variable names (e.g., `NODE_ENV`, `DATABASE_URL`) and configuration keys. Our tool converts any text to CONSTANT_CASE by splitting on word boundaries, uppercasing all letters, and joining with underscores.

What is the difference between camelCase and PascalCase?

Both camelCase and PascalCase join words without separators, capitalizing the first letter of each word except the first. The difference is that camelCase starts with a lowercase letter (e.g., `firstName`, `getUserData`) while PascalCase (also called UpperCamelCase) starts with an uppercase letter (e.g., `FirstName`, `GetUserData`). camelCase is used for variable and function names in JavaScript, Java, C#, and Swift. PascalCase is used for class and type names in most object-oriented languages.

How does snake_case differ from kebab-case?

Both snake_case and kebab-case join words with a separator, all in lowercase. snake_case uses underscores (e.g., `first_name`, `get_user_data`) while kebab-case uses hyphens/dashes (e.g., `first-name`, `get-user-data`). snake_case is the standard naming convention for variables and functions in Python, Ruby, and Rust. kebab-case is the standard for CSS class names, HTML IDs, and URL slugs. Our tool supports both, along with SCREAMING_SNAKE_CASE (CONSTANT_CASE) for constants.

Does the converter work with non-English text?

Yes. The upper/lower/title/sentence/capitalize conversions use the browser's native `toUpperCase` and `toLowerCase` methods, which handle Unicode correctly. This means accented characters (é → É), German umlauts (ß → SS), and Greek letters (α → Α) are converted correctly. The programming-style cases (camelCase, PascalCase, snake_case, kebab-case, CONSTANT_CASE) are tuned for ASCII identifiers and may not produce ideal results for non-Latin scripts, as they are designed for code identifiers which are typically ASCII.

Can I convert multiple lines at once?

Yes. The tool handles multi-line text. The behavior depends on the case: for UPPERCASE, lowercase, and InVeRsE, each line is converted independently. For camelCase, PascalCase, snake_case, kebab-case, and CONSTANT_CASE, line breaks are treated as word separators and removed, producing a single line. For Title Case, Sentence case, and Capitalize Each Word, line breaks are preserved.

Is my text uploaded anywhere?

No. All conversion happens entirely in your browser using JavaScript. Your text is never uploaded to a server, never stored in a database, never logged, and never transmitted over the network. All conversion is performed locally — no network requests are made when you type or paste text. This makes the tool safe for use with confidential text, source code containing API keys, or any other sensitive content.

Can I use this tool for commercial projects?

Yes. The tool is free for both personal and commercial use with no watermarks, no attribution required, and no usage limits. You can use it for code refactoring, content editing, data cleaning, or any other purpose. There is no registration, no API key, and no subscription required.

100% Client-Side & Private

All conversion happens entirely in your browser using JavaScript.

Your text is never uploaded to a server, never stored in a database, never logged, and never transmitted over the network.
All case conversion is performed locally — no network requests are made when you type, paste, or copy text.
This makes the tool safe for use with source code containing API keys, confidential business documents, legal text, and other sensitive content.
You can verify the privacy by checking your browser's DevTools Network tab.

Explore the topic

All tools in this categoryText & Developer Tools Guides for this topicDeveloper tools

Font Subsetter

Reduce font file size by removing unused characters.

Markdown Editor

Write Markdown with a live preview and copy clean HTML.

Regex Tester

Test and debug your regular expressions in real-time.