Convert Text to Uppercase, Lowercase, or Title Case (Instant, Free)

You typed an entire paragraph with caps lock on. Or you pasted text from a PDF and it came through as ALL CAPS. Or you need to convert a list of product names to title case for a catalog. Or you need variable names in camelCase for your code.

Retyping the text is tedious and error-prone. Find-and-replace does not help because there is no pattern to match. You just need a tool that converts text between cases, instantly.

The Case Converter handles all the standard text case transformations. Paste your text, pick the target case, and copy the result. No signup, no file upload, just text in and text out.

All the Text Cases Explained

UPPERCASE: Every letter is capitalized. Used for acronyms, headers in legal documents, emphasis in informal writing, and variable names in constants (MAX_RETRIES).

lowercase: Every letter is small. Used for URLs, email addresses, CSS properties, and most programming identifiers.

Title Case: The First Letter Of Each Word Is Capitalized. Used for headings, titles, and proper nouns. Note: style guides disagree on whether small words (a, the, in, of) should be capitalized. AP style lowercase them. APA style capitalizes words of four or more letters.

Sentence case: Only the first letter of the sentence is capitalized (plus proper nouns). Used for regular body text, most UI labels, and many modern design systems that prefer sentence case over title case for headings.

camelCase: Words are joined without spaces, each word after the first starts with a capital letter. Standard for JavaScript/TypeScript variable names: getUserName, isLoggedIn.

PascalCase: Like camelCase but the first word is also capitalized. Standard for class names and React component names: UserProfile, PaymentForm.

snake_case: Words are joined with underscores, all lowercase. Standard for Python, Ruby, and database column names: user_name, created_at.

kebab-case: Words are joined with hyphens, all lowercase. Standard for CSS class names and URL slugs: nav-bar, blog-post-title.

CONSTANT_CASE: Like snake_case but all uppercase. Standard for constants in most languages: API_BASE_URL, MAX_FILE_SIZE.

When to Use Which Case (Style Guide Quick Reference)

For writing and content:

• Blog post titles: Title Case or Sentence case (pick one and be consistent)
• Section headings: Sentence case is the modern trend (Google, Apple, and Microsoft style guides use it)
• Button labels: Sentence case ("Save changes", not "Save Changes")
• Navigation items: Title Case or Sentence case (be consistent across the nav)
• Error messages: Sentence case with a clear description of what went wrong
• Legal documents: Often UPPERCASE for section headers, sentence case for body text

For code:

• JavaScript/TypeScript variables and functions: camelCase
• React components: PascalCase
• CSS classes: kebab-case (or the convention of your CSS framework)
• Python variables and functions: snake_case
• Constants: CONSTANT_CASE
• Database columns: snake_case (most common)
• URLs and slugs: kebab-case
• Environment variables: CONSTANT_CASE

The Case Converter supports all of these transformations. If you are reformatting a list of database columns to JavaScript camelCase, or converting headline-case titles to sentence case for a redesign, it handles the batch instantly.

Use the Word Counter alongside the case converter if you are also tracking character or word counts for your content.

Common Scenarios Where Case Conversion Saves Time

Fixing caps lock accidents. You typed three paragraphs before noticing caps lock was on. Instead of retyping, paste the text into the converter and select lowercase or sentence case.

Reformatting data imports. You received a CSV where all names are in UPPERCASE ("JOHN SMITH"). Convert to Title Case ("John Smith") before importing into your CRM or database.

Converting between code conventions. You copied a Python function name (get_user_profile) and need it in JavaScript format (getUserProfile). Or you are writing a migration script that converts database column names (snake_case) to API response fields (camelCase).

SEO and URL optimization. Page titles need Title Case for display but kebab-case for URLs. Convert "How to Build a Better Widget" to "how-to-build-a-better-widget" for the URL slug.

Legal and compliance documents. Some regulations require specific sections to be in UPPERCASE. Convert formatted text without retyping.

Spreadsheet cleanup. A column of product names has inconsistent casing. Export the column, convert to Title Case, and paste it back. This is faster than fixing each cell individually.

The Text Splitter can help break large text blocks into manageable chunks if you need to convert case for specific sections rather than the entire text.

Title Case Rules: It Is More Complicated Than You Think

Title Case seems simple: capitalize the first letter of every word. But which words?

AP Style (journalism, marketing): Capitalize words with four or more letters. Lowercase articles (a, an, the), short prepositions (in, on, at, by, to, for), and short conjunctions (and, but, or, nor). Always capitalize the first and last word regardless.

Example: "The Art of War and Peace in Our Time"

APA Style (academic): Capitalize all words with four or more letters. Capitalize both words in hyphenated compounds. Capitalize the first word after a colon.

Example: "The Art of War and Peace in Our Time" (same result in this case, but differs with hyphenated words)

Chicago Style (books, publishing): Similar to AP but with specific rules for prepositions used as adverbs ("Turn On the Light" vs "building on the idea").

Sentence case avoids all of this: just capitalize the first word and proper nouns. This is why more design systems and tech companies are switching to sentence case for UI elements. It is simpler, more readable, and avoids arguments about which words to capitalize.

The Case Converter implements standard Title Case rules. For specialized style guide compliance, review the output against your specific guide.

Programmatic Case Conversion Tips

If you need case conversion in your code rather than a web tool, here are the patterns:

JavaScript: `javascript // To uppercase/lowercase str.toUpperCase(); str.toLowerCase();

// To title case str.replace(/\w\S*/g, t => t.charAt(0).toUpperCase() + t.slice(1).toLowerCase());

// camelCase to kebab-case str.replace(/([a-z])([A-Z])/g, '$1-$2').toLowerCase(); `

Python: `python text.upper() # UPPERCASE text.lower() # lowercase text.title() # Title Case (basic) text.capitalize() # Sentence case `

CSS (display-only, does not change the actual text): `css text-transform: uppercase; text-transform: lowercase; text-transform: capitalize; / Title Case / `

The CSS approach is useful for styling headings without modifying the source text. But note that text-transform: capitalize capitalizes every word, including articles and prepositions, which is not correct Title Case by any style guide.

For bulk operations on files, a command-line approach is often fastest. Pipe text through tr '[:upper:]' '[:lower:]' on Unix systems for simple conversions.

FAQ

Does case conversion work with non-English characters?

Yes, for most languages. Unicode defines case mappings for Latin, Greek, Cyrillic, and many other scripts. The Case Converter handles accented characters (e to E, u to U) correctly. Some languages have special rules (German sharp-s to SS, Turkish dotted/undotted I) that basic converters may not handle.

What is the difference between Title Case and Start Case?

Title Case follows style guide rules about which words to capitalize (usually not articles, short prepositions, or conjunctions). Start Case capitalizes the first letter of every word without exception. Most style guides use Title Case, not Start Case.

Can I convert case in Google Sheets or Excel?

Yes. Google Sheets: =UPPER(A1), =LOWER(A1), =PROPER(A1). Excel: Same functions. PROPER is equivalent to Start Case (capitalizes every word). For true Title Case, you need a custom formula or the case converter.

Why do programming languages use different case conventions?

Historical convention. C used snake_case, Java adopted camelCase, and CSS adopted kebab-case because hyphens are valid in CSS identifiers but not in most programming languages. Each community standardized on what felt natural in their ecosystem, and the conventions stuck.