Paste text, click a case, copy the result. Nine case styles, full Unicode support, nothing leaves your browser.
A free, in-browser tool that converts a block of text between nine case styles: UPPERCASE, lowercase, Title Case, Sentence case, snake_case, camelCase, PascalCase, kebab-case, and CONSTANT_CASE. Paste once, click the case you want, copy the result. Nothing leaves your machine.
Think of it as Excel's UPPER, LOWER, and PROPER functions, plus Microsoft Word's "Change Case" menu, plus the programmer-focused styles you'd reach for lodash or the change-case npm package for. One UI, no install.
Underneath, conversions use String.prototype.toLowerCase, toUpperCase, and toLocaleLowerCase / toLocaleUpperCase for locale-aware folding (Turkish dotted I, German ß, Greek final sigma). Identifier styles split on word boundaries (_, -, whitespace, and lower-to-upper transitions) before re-casing each word.
Two of the nine styles are pure letter transforms. UPPERCASE calls String.prototype.toLocaleUpperCase with your browser locale, lowercase calls toLocaleLowerCase. The locale-aware variants matter because MDN's toLocaleUpperCase reference documents the Turkish edge case: in tr-TR, lowercase i uppercases to İ (with a dot), and uppercase I lowercases to ı (without a dot). The non-locale versions get this wrong for Turkish text.
Title Case and Sentence case do more work. Sentence case lowercases everything then capitalises the first letter of each sentence (split on ., !, ?). Title Case capitalises the first letter of every word except short articles, prepositions, and conjunctions like a, an, the, and, or, of, in. The first and last word of the title always capitalise, regardless. AP and Chicago styles disagree on which prepositions to skip; we pick a reasonable default and document the list in the FAQ.
The five identifier styles (snake_case, camelCase, PascalCase, kebab-case, CONSTANT_CASE) all share one normaliser. The text gets split into words on any of: underscores, hyphens, whitespace, periods, or a lowercase-to-uppercase transition (so userProfileName splits into user, profile, name). Each word is lowercased, then rejoined with the target separator and casing rule. This is the same approach the change-case npm package takes.
One pane, one click, one result. There is no signup and no upload.
Drop your text into the input pane. It can be a single phrase, a column of CSV headers, an identifier, or a multi-line paragraph. The Sample button fills the pane with a small example if you want to see the conversions side-by-side first.
Pick one of the nine case styles: UPPERCASE, lowercase, Title Case, Sentence case, snake_case, camelCase, PascalCase, kebab-case, or CONSTANT_CASE. The result appears in the output pane immediately. The original input is preserved so you can try a different style without re-pasting.
Click Copy to put the converted text on your clipboard. Or click Download to save it as a .txt file. Both buttons run locally; nothing is uploaded.
You exported a spreadsheet with headers like First Name, Date Of Birth, Customer ID, and Postgres needs them as first_name, date_of_birth, customer_id. Paste the header row, click snake_case, and you get an identifier-clean version that drops straight into a CREATE TABLE statement without quoting.
A blog title like "Why We Switched from MongoDB to Postgres" becomes why-we-switched-from-mongodb-to-postgres in kebab-case, which is the URL convention Google's URL structure docs recommend. Punctuation strips out, spaces become hyphens, casing normalises. Paste the headline, click kebab-case, paste into your CMS.
You're moving response field names from a Python backend that returns user_profile_name and created_at to a TypeScript frontend that prefers userProfileName and createdAt. Paste the snake_case identifiers, click camelCase, and the splitter handles the underscore boundaries correctly. The reverse trip works the same way.
An older Oracle schema has identifiers in CONSTANT_CASE: USER_PROFILE_NAME, ORDER_LINE_ITEM_ID. Postgres convention is lowercase with underscores. Paste the column list, click snake_case, and you get a Postgres-friendly version. The splitter respects the existing underscores so multi-word identifiers stay correctly word-broken.
You scraped a list of book titles in mixed casing: "the great gatsby", "TO KILL A MOCKINGBIRD", "Of mice And men". Paste them, click Title Case, and you get correctly capitalised titles with articles and short prepositions left lowercase ("To Kill a Mockingbird"). Faster than going row-by-row in Word's "Change Case" menu.
Someone replied to your support thread in full caps. Paste the message, click Sentence case, and it becomes readable: first letter of each sentence capitalised, the rest lowercase. Then click Copy and reply with something a human can actually read without flinching.
A short cheat sheet for the nine styles this tool exposes, plus the Unicode pitfalls worth knowing about. Examples use the input <code>userProfileName</code> or "the quick brown fox" where appropriate.
| Topic | What this tool does |
|---|---|
| UPPERCASE | Every letter capitalised. USERPROFILENAME, THE QUICK BROWN FOX. Backed by String.prototype.toLocaleUpperCase. Common in SQL keywords, CSS text-transform: uppercase, and YAML environment variable defaults. |
| lowercase | Every letter lowercased. userprofilename, the quick brown fox. Backed by String.prototype.toLocaleLowerCase. Used for email addresses, hostnames, and case-insensitive search keys. |
| Title Case | First letter of each significant word capitalised; short articles and prepositions stay lowercase. "The Quick Brown Fox Jumps Over the Lazy Dog". The first and last word always capitalise. AP and Chicago styles differ on prepositions of five letters or more. |
| Sentence case | First letter of each sentence capitalised; everything else lowercased. "The quick brown fox jumps over the lazy dog." Splits on ., !, ?. Useful for cleaning up SHOUTING all-caps text or normalising mixed casing. |
| snake_case | Words joined with underscores, all lowercase. user_profile_name. Python convention for functions and variables (PEP 8). Postgres convention for identifiers. Common in Ruby, Rust, and SQL identifiers. |
| camelCase | Words joined with no separator; first word lowercase, subsequent words capitalised. userProfileName. JavaScript and Java convention for variables and methods. Used by JSON object keys in most JS-native APIs. |
| PascalCase | Words joined with no separator; every word capitalised including the first. UserProfileName. Convention for class names in Java, C#, Python, Rust, and TypeScript. Sometimes called UpperCamelCase. |
| kebab-case | Words joined with hyphens, all lowercase. user-profile-name. CSS selector and property convention. URL slug convention (preferred by Google for SEO). HTML attribute convention per the spec, even though DOM properties expose them as camelCase. |
| CONSTANT_CASE | Words joined with underscores, all uppercase. USER_PROFILE_NAME. Convention for compile-time constants in C, Java, and JavaScript. Common in environment variables (DATABASE_URL, NODE_ENV) and SQL keywords. |
| Unicode pitfalls | Turkish dotted/dotless I (i ↔ İ, I ↔ ı), German ß uppercases to SS, Greek final sigma ς appears only at word end. Always use locale-aware methods for these. See Letter case on Wikipedia for a wider overview and Snake case / Camel case for the identifier history. |
Yes. UPPERCASE and lowercase use String.prototype.toLocaleUpperCase and toLocaleLowerCase with your browser locale. That means in Turkish, i uppercases to İ (dotted) and I lowercases to ı (dotless), per the Unicode rules in Unicode Technical Standard #21. German ß lowercases as itself and uppercases to SS. Greek final sigma ς is also handled correctly.
Title Case keeps short articles, prepositions, and conjunctions lowercase: a, an, the, and, or, but, nor, for, of, in, on, at, to, by, as, vs. The first and last word of the title always capitalise. AP and Chicago styles differ on edge cases (Chicago capitalises prepositions of five letters or more; AP doesn't). We use the AP-leaning short list because it produces the most consistent results across mixed input.
Both join words without separators, but they differ on the first letter. camelCase keeps the first word lowercase: userProfileName. PascalCase capitalises every word including the first: UserProfileName. The convention split is language-dependent: Java uses camelCase for methods and variables, PascalCase for class names; Python's PEP 8 uses snake_case for functions and PascalCase for classes; Google's JavaScript style guide uses camelCase for everything except classes.
Yes. The five identifier styles (snake_case, camelCase, PascalCase, kebab-case, CONSTANT_CASE) all use the same word splitter, which breaks on underscores, hyphens, whitespace, periods, and lowercase-to-uppercase transitions. So userProfileName, user_profile_name, user-profile-name, and USER_PROFILE_NAME all split into the same three words and convert cleanly between any of the five styles. This matches the behaviour of the change-case npm package and lodash's _.kebabCase family.
Yes. Conversions use the locale-aware string methods, so accented Latin (é, ñ, ü), Greek, Cyrillic, Turkish dotted/dotless I, German ß, and most other scripts case-fold correctly. Note the difference between case folding (compare for equality, e.g. String.prototype.normalize + lowercase) and case mapping (display): we do case mapping. For equality comparison across locales, you may want localeCompare with { sensitivity: 'base' } instead.
Up to a few MB is fine and runs in well under a second. Past 10 MB the browser starts to feel it because re-rendering the output pane is expensive on long strings, not because the conversion itself is slow. For files larger than that, use a CLI: tr '[:upper:]' '[:lower:]' in bash, Python's str.upper() / str.lower() / str.title(), or CSS's text-transform property if it's display-only.
It is free, and there is nothing to sign up for. No account, no trial, no daily limit on how much text you convert. Everything runs as plain JavaScript in your browser, so once the page has loaded you can drop your connection and it keeps working. Paste your text, click a case, copy the result. No feature is locked behind a login and there is no paid tier waiting at the end.
No formulas and no app to open. In Excel you would write =UPPER(A1), =LOWER(A1), or =PROPER(A1) in a helper column, then copy-paste-values back; here you paste once and click. Word's Change Case (Shift+F3 cycles through them) only does the letter-case styles, not snake_case, camelCase, or kebab-case. And neither tool gives you programmer identifier styles. Nothing you paste is uploaded; it all stays on your machine.
Nine of them. Four are letter-case styles: UPPERCASE, lowercase, Title Case, and Sentence case. The other five are programmer naming styles: snake_case, camelCase, PascalCase, kebab-case, and CONSTANT_CASE. The identifier styles share one word splitter, so you can convert cleanly between any of them. Your original input stays in the box after each conversion, so you can try a different style without re-pasting.
Nothing is uploaded. Every conversion runs in your browser using the standard String methods built into JavaScript, so your text never touches a server. We do not log it, store it, or send it anywhere. You can paste a customer list, an internal column dump, or an unreleased product name and close the tab with nothing left behind. To check for yourself, open DevTools, switch to the Network tab, and watch as you click a case button. No request goes out.
Yes to both. The whole tool is client-side, so once the page has loaded it keeps working with the network off; turn on airplane mode and the case buttons still convert. On a phone the layout stacks so the input and output sit one above the other, and the buttons are big enough to tap. Copy and Download both work on mobile too, which is handy for fixing an all-caps message before you forward it.
Your text never leaves your browser. Every conversion runs locally on your machine using the standard String methods built into JavaScript's String prototype. No analytics on your input, no logs, no server round-trip. The Unicode rules we follow come from Unicode Technical Standard #21 (Case Mappings), which is the same standard the browser engines themselves implement.