Case converter

What Is a Case Converter?

A case converter is a free online tool that instantly changes the capitalization of your text — converting it to UPPERCASE, lowercase, Title Case, Sentence case, or programmer formats like camelCase, PascalCase, snake_case, and kebab-case. Paste in text that arrived in the wrong case (a spreadsheet column in ALL CAPS, a heading typed in lowercase, code variables in the wrong naming convention) and get correctly cased output in one click, with no retyping and no find-and-replace gymnastics.

Wrong-case text is one of the most common small annoyances in digital work, and it shows up everywhere. Data exports arrive in all caps because the source system stores everything uppercase. Content pasted from PDFs inherits random capitalization. Developers switching between languages hit naming-convention mismatches: JavaScript wants camelCase, Python wants snake_case, CSS classes want kebab-case, and C# wants PascalCase. Titles written in sentence case need converting for headline-style publications, and vice versa. Each fix is trivial individually, but across hundreds of lines or a whole codebase, manual correction is slow and error-prone.

The WebTaskTools case converter handles all the standard transformations in one place. Beyond the basic upper/lower/title/sentence cases, it covers the naming conventions programmers actually use daily, plus handy extras like alternating case and inverse case for stylized text. Smart title casing follows real headline rules — it keeps small words like "and," "the," and "of" lowercase unless they start the title, the way professional editors expect. Your text is processed instantly on the server and never stored.

Writers frequently pair this with our character counter (case changes don't alter character counts, but it's worth verifying after edits), our remove duplicate lines tool when cleaning messy pasted lists, and our word counter for document stats.

How to Use the Case Converter

1. Paste or type your text. Click into the input box and paste your text (Ctrl+V / Cmd+V) or type it directly. Multi-line text, lists, and whole paragraphs are all fine.
2. Choose the target case. Click the button for the transformation you want: UPPERCASE, lowercase, Title Case, Sentence case, camelCase, PascalCase, snake_case, kebab-case, aLtErNaTiNg, or InVeRsE.
3. Review the output. The converted text appears instantly. Check that proper nouns, acronyms, and brand names survived as intended — automated casing can't know that "iPhone" should keep its odd capitalization.
4. Copy the result. Use the copy button to grab the converted text and paste it into your document, code editor, or CMS.
5. Convert again if needed. Chain transformations — for example, convert to lowercase first, then to Title Case — to clean up badly mixed input in stages.
6. Clear and repeat. Clear the box and process the next batch; the tool handles unlimited conversions.

Case Styles Explained

Key Features

• Ten transformations in one tool — upper, lower, title, sentence, camel, Pascal, snake, kebab, alternating, and inverse case.
• Smart title casing — follows headline conventions, keeping articles and short prepositions lowercase mid-title.
• Programmer naming conventions — camelCase, PascalCase, snake_case, and kebab-case for real development workflows.
• Multi-line support — converts entire documents, lists, and code blocks while preserving line breaks.
• Instant conversion — output appears the moment you choose a case; no submit button, no waiting.
• Unicode-aware — handles accented characters and non-Latin scripts with proper case mappings.
• Not stored — text is processed instantly and never stored, logged, or retained.
• Free and unlimited — convert as much text as you like, as often as you like.

Title Case Rules Worth Knowing

Not all "title case" is equal, and the differences matter in professional publishing. The two dominant styles are AP/Chicago headline style (used by most US news outlets and book publishers), which capitalizes all major words but leaves articles (a, an, the), short prepositions (of, in, on, at, to), and short conjunctions (and, but, or) lowercase unless they open or close the title — and sentence case (favored by many UK publications, academic journals, and tech documentation), which capitalizes only the first word and proper nouns.

Getting this wrong marks text as amateurish to editors: "The Quick Brown Fox Jumps Over The Lazy Dog" (with "The" and "Over" wrongly capitalized mid-title) is the classic tell of naive capitalization. This converter's Title Case mode applies the small-word rules automatically, so "the lord of the rings" becomes "The Lord of the Rings," not "The Lord Of The Rings." For academic citations, check your style guide — APA uses sentence case for article titles in references, while MLA uses title case — and convert accordingly before finalizing your bibliography.

Case Conventions in Programming

Every language community has settled on casing conventions, and violating them makes code look foreign to experienced developers. JavaScript and Java use camelCase for variables and functions (fetchUserData) and PascalCase for classes and React components (UserProfile). Python's PEP 8 mandates snake_case for functions and variables (fetch_user_data), PascalCase for classes (UserProfile), and UPPER_SNAKE_CASE for constants (MAX_RETRIES). C# uses PascalCase for nearly everything public. CSS classes and HTML attributes conventionally use kebab-case (user-profile-card), and URLs/slugs are lowercase kebab-case for readability and SEO.

These conventions exist because code is read far more often than it is written. Consistent casing lets a reader instantly distinguish a class from a variable from a constant without checking the declaration. When refactoring across languages — porting a JavaScript library to Python, for instance — bulk-converting identifier lists with this tool saves hours of tedious renaming, though you should always review the output since automated conversion can't resolve genuine ambiguities (is "userID" one word or two?).

Use Cases

Content writers and editors

The problem: A 3,000-word article arrives from a contributor in ALL CAPS, or headlines are in sentence case when the publication's style demands title case. Fixing by hand means retyping or carefully selecting each heading.

How this tool helps: Paste the whole document, apply the correct case in one click, and copy it back. Smart title casing handles the small-word rules automatically, so headlines come out publication-ready.

Developers

The problem: Porting code between languages means renaming dozens of identifiers to match the new language's conventions — userName becomes user_name, MAX_RETRY becomes maxRetry, and missing one breaks the build.

How this tool helps: Convert identifier lists between camelCase, snake_case, PascalCase, and kebab-case in bulk. It's also handy for normalizing environment variable names to UPPER_SNAKE_CASE and generating URL slugs in kebab-case.

Data analysts and spreadsheet users

The problem: Legacy system exports dump names and addresses in ALL CAPS ("JOHN SMITH, 123 MAIN ST"), which looks unprofessional in client-facing reports and breaks proper-case matching in mail merges.

How this tool helps: Paste a column of exported data, convert to Title Case or Sentence case, and paste it back. For large recurring exports, this beats writing spreadsheet formulas every time.

Students

The problem: Essay titles, bibliography entries, and headings need specific casing per the required style guide (APA sentence case vs. MLA title case), and getting the small words right by hand is fiddly.

How this tool helps: Convert titles to the required style instantly and correctly, including the articles-and-prepositions rules that trip people up.

Social media managers

The problem: Brand guidelines demand consistent casing across posts, but copy arrives from five different people in five different cases — and all-caps posts read as shouting.

How this tool helps: Normalize every piece of copy to the brand's house style before scheduling. One click turns a shouted draft into a polished post.

SEO specialists

The problem: URL slugs must be lowercase kebab-case; titles need proper headline casing; meta descriptions read better in sentence case. Inconsistent casing across hundreds of pages looks sloppy in search results.

How this tool helps: Bulk-convert URL lists to lowercase kebab-case slugs and normalize title lists to headline style before importing them into the CMS.

Customer support teams

The problem: Canned responses and macros get edited over time until the capitalization is inconsistent — some replies shout in all caps, others drift into lowercase.

How this tool helps: Run the whole macro library through sentence-case conversion in one pass for a consistent, professional voice across every reply.

Case Sensitivity in the Real World

Whether "A" equals "a" depends entirely on the system reading it, and getting it wrong causes some of the most confusing bugs in computing. Passwords are case-sensitive on virtually every modern system — "Sunshine1" and "sunshine1" are different passwords, which is why caps-lock lockouts are a help-desk cliché. Email addresses are effectively case-insensitive in the domain part (Gmail.com = gmail.com) and almost always treated as case-insensitive in the local part too, even though the standard technically allows case-sensitive local parts. No major provider enforces that distinction.

URLs are split: the domain is case-insensitive (Example.COM works), but the path is case-sensitive on most servers (example.com/About ≠ example.com/about). This is why our converter's lowercase mode matters for slugs — a link shared with mixed-case path segments can 404 on a Linux server. Programming languages vary: Python, Java, C, and JavaScript are case-sensitive (myVar ≠ myvar), while SQL keywords and HTML tags are case-insensitive by convention. Windows file systems are case-insensitive (Report.pdf = report.pdf); Linux file systems are case-sensitive, which is why code zipped on Windows sometimes breaks when deployed to Linux.

These inconsistencies are why case normalization is a standard preprocessing step. Search indexes lowercase everything before comparing. Login systems lowercase emails before lookup. Data pipelines lowercase keys before joining datasets from different sources. Whenever you merge, compare, or look up text from two places, converting both sides to the same case first eliminates an entire class of silent mismatches.

Common Case-Conversion Mistakes

Converting code without checking string literals. Running a bulk case change over source code can alter text inside quoted strings — user-facing messages, SQL queries, regex patterns — where case is meaningful. Always convert identifier lists separately from full source files, or use your editor's refactoring tools for code and this converter for plain text.

Title-casing every word blindly. Naive converters capitalize "Of," "The," and "And" mid-title, producing the amateurish "The Lord Of The Rings" instead of "The Lord of the Rings." This tool applies small-word rules, but always give headlines a final human read — style guides differ on edge cases like hyphenated compounds ("Well-Known" vs. "Well-known") and words after colons.

Lowercasing German nouns or Turkish text carelessly. German capitalizes all nouns ("Haus," "Baum"), so lowercasing German prose destroys meaning, not just style. Turkish has dotted and dotless "i" (İ/i vs. I/ı) with case mappings that differ from English — naive ASCII lowercasing produces wrong characters. For non-English text, verify the output with a native reader.

Forgetting that case carries meaning in data. Product SKUs, license keys, and base64-encoded strings are often case-sensitive. "aBc123" and "ABC123" may be different license keys. Never "clean up" the case of identifiers, tokens, or encoded data — convert only human-readable prose and display text.

Fitting the Converter Into Your Workflow

The fastest way to use a case converter is to make it a habit at the boundary between tools: paste into the converter whenever text moves from a spreadsheet into a report, from a draft into a CMS, or from one programming language into another. Keep the tab open during editing sessions and treat it like a spellchecker for capitalization — a five-second stop that prevents the slow embarrassment of publishing "tHE qUICK bROWN fOX" because caps lock was on. For repetitive jobs, like normalizing a weekly data export, bookmark the tool next to the export button so the cleanup step is never skipped. Small, consistent use beats occasional marathon sessions: fixing case at the moment text changes hands keeps every downstream document clean without any single big effort.

Frequently Asked Questions

What is the difference between Title Case and Sentence case?

Title Case capitalizes the first letter of every major word ("The Quick Brown Fox"), while Sentence case capitalizes only the first word and proper nouns ("The quick brown fox"). News headlines and book titles typically use Title Case in the US; body text, academic references (APA), and many UK publications use Sentence case.

Will the converter mess up proper nouns like "iPhone" or "McDonald"?

It can, because automated casing applies rules without knowing brand spellings. "IPHONE" converted to Title Case becomes "Iphone," not "iPhone." Always review converted output for proper nouns, acronyms (NASA, HTML), and brand names, and fix those by hand afterward.

What is camelCase used for?

camelCase (firstWordLower, restCapitalized) is the standard for variables and functions in JavaScript, TypeScript, and Java. The name comes from the "humps" of the capital letters resembling a camel's back. It's also common in Java method names and many API field names.

When should I use snake_case vs. kebab-case?

Use snake_case (words_joined_by_underscores) for Python, Ruby, and database identifiers — languages where hyphens would be parsed as minus signs. Use kebab-case (words-joined-by-hyphens) for CSS classes, HTML attributes, and URL slugs, where hyphens are valid and more readable than underscores. Search engines treat hyphens as word separators in URLs but not underscores, which is why slugs use kebab-case.

Does changing case affect character count?

No — case conversion never adds or removes characters, so the count stays identical. (One edge case: the German ß uppercases to "SS" in some systems, changing length, but this is rare in practice.) If you need to verify, our character counter confirms it instantly.

Can I convert text in languages other than English?

Yes, for scripts that have case distinctions (Latin, Greek, Cyrillic, Armenian). Scripts without case — Arabic, Chinese, Hebrew, Devanagari — pass through unchanged, which is correct behavior. Accented Latin characters (é, ñ, ü) convert properly.

Why does my spreadsheet data come out in ALL CAPS?

Many legacy databases and mainframe systems store text in uppercase only, a holdover from eras when storage was expensive and character sets were limited. Exports inherit this. Converting to Title Case or Sentence case on the way into reports is standard data-cleaning practice.

Is UPPER_SNAKE_CASE the same as CONSTANT_CASE?

Yes — they're two names for the same convention: all uppercase with underscores between words (MAX_CONNECTIONS, API_KEY). It's the universal style for constants and environment variables across nearly all programming languages.

Is my text stored when I convert it?

No. Your text is processed instantly to perform the conversion and never stored, logged, or retained. Confidential documents and proprietary code are safe to convert here.

Can the converter fix RANDOM cApItAlIzAtIoN from a broken keyboard?

Yes — that's exactly what the lowercase and sentence-case modes are for. Convert the garbled text to lowercase first to normalize it, then apply Title Case or Sentence case to get clean, correctly capitalized output.