Case Converter

What This Tool Does

This case converter changes the capitalization of your text instantly. Paste any text and convert it to:

• UPPERCASE - All capital letters
• lowercase - All small letters
• Title Case - First Letter Of Each Word Capitalized
• Sentence case - First letter of each sentence capitalized
• camelCase - Programming format, no spaces
• PascalCase - Like camelCase but starts with capital
• snake_case - Words joined by underscores
• kebab-case - Words joined by hyphens
• CONSTANT_CASE - Uppercase with underscores
• dot.case - Words joined by dots

Click any button, get your converted text. Copy it. Done.

Why Text Case Matters

Text case affects readability, professionalism, and in some contexts, whether your code actually works.

In Writing and Publishing

Headlines use Title Case or Sentence case for a reason. "How to Write Better Headlines" looks professional. "HOW TO WRITE BETTER HEADLINES" looks like you're shouting. "how to write better headlines" looks lazy.

Different publications have different style guides:

• AP Style: Capitalize major words in headlines
• Chicago Manual: Similar, but different rules for prepositions
• APA Style: Title case for titles, sentence case for headings
• MLA: Title case with specific exceptions

Getting case wrong in academic or professional writing signals carelessness. A case converter fixes this in seconds.

In Programming

Case conventions in code aren't just style - they're required in many languages and frameworks.

• JavaScript variables: camelCase (userName, totalCount)
• Python variables: snake_case (user_name, total_count)
• CSS classes: kebab-case (main-header, nav-link)
• Constants: CONSTANT_CASE (MAX_SIZE, API_KEY)
• Classes and components: PascalCase (UserProfile, ShoppingCart)

Using wrong case in code can break things. At minimum, it makes code harder to read and maintain. Most teams enforce case conventions through style guides and linters.

In Data Entry and Databases

Consistent case prevents duplicate records and search issues. "John Smith", "john smith", and "JOHN SMITH" might be treated as three different people in a database. Standardizing to one case prevents these problems.

Understanding Each Case Type

UPPERCASE

Every letter becomes a capital. "hello world" becomes "HELLO WORLD".

Common uses:

• Acronyms and abbreviations (NASA, HTML, CEO)
• Emphasis in informal writing
• Legal document headers
• Button text in some designs
• Constants in programming (MAX_VALUE)

Avoid: Body text in all caps is hard to read. Studies show lowercase text is processed faster because word shapes are more distinct.

lowercase

Every letter becomes small. "HELLO WORLD" becomes "hello world".

Common uses:

• Usernames and email addresses
• URL slugs (example.com/my-page-title)
• File names (document.pdf, image.jpg)
• As a starting point before applying other conversions

Lowercase is the default state. Most conversions start by making everything lowercase, then applying specific rules.

Title Case

First letter of each word capitalized. "the quick brown fox" becomes "The Quick Brown Fox".

Common uses:

• Book titles and chapter headings
• Blog post titles
• Movie and song titles
• Headlines
• Course names and certification titles

Style guides differ on small words. Some capitalize "The", "And", "Of" - others don't. This tool capitalizes every word for simplicity.

Sentence case

First letter of each sentence capitalized, rest lowercase. "HELLO THERE. HOW ARE YOU?" becomes "Hello there. How are you?"

Common uses:

• Regular paragraph text
• Email subject lines (in some style guides)
• Subheadings in APA format
• Interface text and buttons (in modern design)

Sentence case reads more naturally than Title Case for longer text. Many modern interfaces prefer it.

camelCase

No spaces, first word lowercase, following words start with capitals. "get user data" becomes "getUserData".

Common uses:

• JavaScript variable names
• Java method names
• JSON property names
• TypeScript interfaces

Called "camelCase" because the capitals in the middle look like a camel's humps. It's the most common convention in JavaScript and related languages.

PascalCase

Like camelCase, but the first letter is also capitalized. "get user data" becomes "GetUserData".

Common uses:

• Class names in most languages
• React component names
• C# method names
• TypeScript type names

Sometimes called "UpperCamelCase". PascalCase got its name from the Pascal programming language, though it's used everywhere now.

snake_case

All lowercase, words separated by underscores. "get user data" becomes "get_user_data".

Common uses:

• Python variables and functions
• Ruby variables and methods
• Database column names
• File names in some systems
• PostgreSQL identifiers

Python's PEP 8 style guide specifically recommends snake_case for functions and variables. It's also common in REST API endpoints.

kebab-case

All lowercase, words separated by hyphens. "get user data" becomes "get-user-data".

Common uses:

• CSS class names
• URL slugs
• HTML attributes
• npm package names
• Git branch names

Called "kebab-case" because the hyphens look like food on a skewer. It's the standard for web-facing identifiers.

CONSTANT_CASE

All uppercase, words separated by underscores. "max file size" becomes "MAX_FILE_SIZE".

Common uses:

• Constants in most programming languages
• Environment variables
• Configuration keys
• Enum values in some languages

The uppercase and underscores signal "this value shouldn't change" in code. It's a universal convention across languages.

dot.case

All lowercase, words separated by dots. "get user data" becomes "get.user.data".

Common uses:

• Java package names (com.example.app)
• Configuration file keys
• Some logging frameworks
• Property access notation

Less common than other formats, but essential in specific contexts like Java package naming.

When to Use Each Case

For Headlines and Titles

Use Title Case or Sentence case. Title Case is traditional for major headlines. Sentence case is trending in modern design - it feels less formal and more approachable.

For Code Variables

Match your language's convention:

• JavaScript/TypeScript: camelCase for variables, PascalCase for classes
• Python: snake_case for everything except classes
• CSS: kebab-case
• Constants: CONSTANT_CASE regardless of language

For URLs and File Names

Use lowercase or kebab-case. URLs are case-sensitive on most servers. "MyPage" and "mypage" can be different pages. Stick to lowercase to avoid confusion.

For Database Columns

snake_case is most common. It's readable and avoids issues with reserved words or case sensitivity across different database systems.

Common Case Conversion Mistakes

Mixing Cases Inconsistently

Seeing "userName", "UserEmail", and "user_phone" in the same codebase signals poor organization. Pick one convention and stick to it.

Using Wrong Case for Platform

CSS classes in camelCase don't work. React components in kebab-case cause errors. Know what format each context requires.

Forgetting Proper Nouns

Converting "Apple iPhone" to lowercase gives "apple iphone" - which might not be what you want. Proper nouns sometimes need to keep their original case. Review after converting.

Ignoring Acronyms

Should "HTML document" become "htmlDocument" or "HTMLDocument" in camelCase? Different style guides answer differently. JavaScript conventions typically prefer "HtmlDocument", while some argue for "HTMLDocument".

Case Conversion in Different Contexts

Email Subject Lines

Title Case was traditional, but Sentence case is gaining preference. "Meeting Tomorrow at 3 PM" vs "Meeting tomorrow at 3 PM". Both work. Sentence case feels more personal.

Social Media

Mixed approaches. Hashtags don't have spaces, so PascalCase helps readability: #BlackFriday vs #blackfriday. Otherwise, sentence case or casual lowercase is common.

Legal Documents

Often use ALL CAPS for important headings, defined terms in Title Case, and body text in sentence case. The caps signal "pay attention here" in contracts.

Academic Papers

Follow your style guide exactly. APA, MLA, Chicago, and others have specific rules. Title case for titles, sentence case for headings (in APA), and so on. Wrong case can cost points.

Tips for Better Case Management

Establish a Style Guide

Whether for writing or coding, document your conventions. "Headlines use Sentence case. Buttons use UPPERCASE. Code uses camelCase for variables." Save this somewhere your team can reference.

Use This Tool for Quick Fixes

You don't need to manually retype text. Paste it here, click the case you need, copy the result. It takes seconds.

Double-Check Proper Nouns

Automated conversion can't know that "iPhone" should keep its specific capitalization or that "McDonald's" has an unusual pattern. Review your output for names, brands, and technical terms.

Convert Before Publishing

Run your headlines through a case converter before publishing. Consistency across a website or document looks professional. Inconsistency looks sloppy.

Case Sensitivity in Technical Systems

Passwords

Always case-sensitive. "Password123" and "password123" are different passwords on every system.

URLs

Domain names are not case-sensitive (GOOGLE.COM = google.com). Paths after the domain usually ARE case-sensitive on Unix servers (example.com/Page ≠ example.com/page).

Programming

Most languages are case-sensitive. "myVariable" and "myvariable" are completely different in JavaScript, Python, Java, and most others. Only a few languages like SQL and Visual Basic are case-insensitive.

File Systems

Windows: Case-insensitive (FILE.txt = file.txt)

Mac: Case-insensitive by default, but can be configured

Linux: Case-sensitive (FILE.txt ≠ file.txt)

This catches many developers when deploying from Mac/Windows to Linux servers.

Practical Examples

Blog Post Title

Original: "how to start a successful online business from home"

Title Case: "How To Start A Successful Online Business From Home"

Sentence case: "How to start a successful online business from home"

Code Variable

Concept: "total purchase amount"

camelCase: totalPurchaseAmount

snake_case: total_purchase_amount

PascalCase: TotalPurchaseAmount

URL Slug

Article: "10 Tips for Better Sleep"

kebab-case: 10-tips-for-better-sleep

Result URL: example.com/blog/10-tips-for-better-sleep

CSS Class

Purpose: "Main Navigation Header"

kebab-case: main-navigation-header

HTML: class="main-navigation-header"

Final Thoughts

Text case seems small, but it affects readability, professionalism, and in technical contexts, whether things work at all.

This tool handles the mechanical conversion. You paste, click, copy. The only thing it can't do is judge context - that's on you.

Check your output. Make sure proper nouns look right. Then use your converted text wherever you need it.

Simple as that.