Text Case Converter

Instantly convert text to any case format — uppercase, camelCase, snake_case, slug, and 10 more. Paste your text, pick a format, done.

0 characters
Characters
0
Words
0
Sentences
0
Lines
0

Select Format

Output

Converted text will appear here...

All Conversions

UPPERCASE

(empty)

Convert all characters to uppercase

lowercase

(empty)

Convert all characters to lowercase

Title Case

(empty)

Capitalize the first letter of each word

Sentence case

(empty)

Capitalize the first letter of each sentence

camelCase

(empty)

Join words with no separator, first word lowercase

PascalCase

(empty)

Join words with no separator, each word capitalized

snake_case

(empty)

Join words with underscores, all lowercase

kebab-case

(empty)

Join words with hyphens, all lowercase

CONSTANT_CASE

(empty)

Join words with underscores, all uppercase

dot.case

(empty)

Join words with dots, all lowercase

path/case

(empty)

Join words with forward slashes

aLtErNaTe CaSe

(empty)

Alternate between lowercase and uppercase

InVeRsE cAsE

(empty)

Swap the case of each character

url-slug

(empty)

URL-friendly format with hyphens

Recent Conversions

Saved conversions will appear here. History persists across sessions.

How case conversion works

tokens = split(input, /[\s_\-./]+/) // split on spaces, _, -, ., / normal = tokens.map(lowercase) output = join(normal, separator) // separator = "" | "_" | "-" | "." | "/" // per-format: camelCase = first + rest.map(capitalize).join("") PascalCase = tokens.map(capitalize).join("") snake_case = normal.join("_") kebab-case = normal.join("-") CONSTANT = tokens.map(uppercase).join("_")

Every case format is a three-step pipeline: tokenize the input into words, normalize each word (lowercase, preserve initials where relevant), then join with the format's separator and capitalization rule. The tokenizer splits on whitespace, underscores, hyphens, dots, and slashes, so it handles input that’s already in any common case. All 14 formats share this pipeline — only the final join and capitalization differ.

Examples

API field name conversion (snake_case → camelCase)

Your backend returns `user_full_name` in JSON and your TypeScript frontend wants `userFullName`. Paste `user_full_name` here, pick camelCase, and you get the exact key your frontend expects. The tokenizer sees the underscore as a word boundary, so `user`, `full`, `name` become three tokens joined as camelCase.

URL slug from a blog title

Title: "10 Ways AI Will Change Software Development in 2026." Paste it, pick slug, and you get `10-ways-ai-will-change-software-development-in-2026`. The slug formatter strips punctuation, lowercases everything, and joins words with hyphens — exactly what Google prefers for readable URLs.

Environment variable from a config key

You have a config key `stripeApiSecretKey` and your deployment platform wants `STRIPE_API_SECRET_KEY`. Paste it, pick CONSTANT_CASE, and the camel boundaries become underscore boundaries automatically. This is the standard format for .env files and CI/CD secrets.

Headline normalization for a CMS

You paste 40 article headlines in mixed case — some SCREAMING, some lowercase, some "Title Case With Weird Capitalization." Pick Title Case and every headline is consistently formatted following AP-style capitalization rules: capitalize the first letter of each word except short articles, conjunctions, and prepositions.

Common questions

Both concatenate words without separators and capitalize word boundaries. The difference is the first letter: camelCase starts lowercase (`getUserName`), PascalCase starts uppercase (`GetUserName`). The convention in most codebases is camelCase for variables and functions, PascalCase for classes, types, and React components. Pick the one your linter expects.

Kebab-case (`my-blog-post`) is standard for URLs, CSS class names, and HTML attributes — hyphens are URL-safe and CSS-native. Snake_case (`my_variable`) is standard for Python, Ruby, Rust, and SQL identifiers. A good rule: hyphens in markup and URLs, underscores in code. They’re almost never interchangeable in a given ecosystem.

It handles them predictably. `XMLHttpRequest` → camelCase gives `xmlHttpRequest` (lowercase the leading acronym), and PascalCase gives `XmlHttpRequest`. If you need to preserve `XMLHttpRequest` as-is, leave it in PascalCase — that’s the convention most style guides use for acronym-heavy identifiers. For CONSTANT_CASE, all acronyms become fully uppercase regardless.

No. The converter is a single JavaScript function that runs in your browser. You can open DevTools → Network and confirm there’s zero traffic while you convert text. This means the tool works offline once the page has loaded, and you can safely paste sensitive data (API keys, internal variable names, customer data) without worrying about leaks.

AlTeRnAtInG cAsE is mostly a meme format used for sarcasm on social media — the SpongeBob mocking format. Inverse case (inverting each character’s case) has a legitimate use in testing: if your app has a bug where case sensitivity matters in a field that shouldn’t care, inverse case is a fast way to generate test inputs that flush out those bugs.

Yes. Paste a multi-line block of text and every line gets converted independently — line breaks are preserved in every format except the ones that strip whitespace (camelCase, PascalCase, slug). If you paste a CSV or JSON blob, the converter operates on the raw text; for structured data transformations, export the output and run it through a proper parser.