Case Converter

Convert text to UPPERCASE, lowercase, Title Case, or Sentence case instantly. Perfect for formatting text, coding, and document preparation.

Input Text
Output Text

UPPERCASE

Convert all letters to capital letters for emphasis or formatting

lowercase

Convert all letters to small letters for consistent formatting

Title Case

Capitalize the first letter of each word for titles and headings

Sentence case

Capitalize the first letter of each sentence for proper grammar

How to Use the Case Converter

Step-by-Step Guide:

  1. Paste or type your text in the input area
  2. Choose your desired conversion type
  3. View the converted text in the output area
  4. Click "Copy Text" to copy the result
  5. Use "Clear" to reset both areas

Perfect For:

  • Formatting document titles and headings
  • Converting code comments and variables
  • Preparing text for social media posts
  • Standardizing data entry formats
  • Creating consistent text formatting

Embed This Tool

Add this case converter to your website

<iframe src="https://calculatortools.com/tools/case-converter/embed" width="100%" height="600" frameborder="0"></iframe>

Complete Guide to Text Case Conversion

Everything you need to know about case formats, naming conventions, and when to use each one — from camelCase variables to kebab-case URLs.

Understanding Text Case

Text Case Systems

  • •lowercase: all characters in lower case (e.g., "hello world")
  • •UPPERCASE: all characters in upper case (e.g., "HELLO WORLD")
  • •Title Case: First Letter Of Each Word Capitalized
  • •Sentence case: Only first letter of sentence capitalized
  • •camelCase: first word lower, subsequent words capitalized (e.g., "helloWorld") — used in JavaScript
  • •PascalCase: every word capitalized (e.g., "HelloWorld") — used in class names
  • •snake_case: words separated by underscores (e.g., "hello_world") — Python/SQL
  • •kebab-case: words separated by hyphens (e.g., "hello-world") — URLs/CSS
  • •SCREAMING_SNAKE_CASE: uppercase snake (e.g., "HELLO_WORLD") — constants
  • •dot.case: words separated by dots (e.g., "hello.world") — config keys

Why Case Conventions Matter

  • •Programming: different languages have strict case conventions (PEP 8 for Python, Java style guides)
  • •Database naming: SQL traditionally uses snake_case for column names
  • •URLs & SEO: kebab-case is Google's preferred URL format
  • •CSS class naming: BEM methodology uses kebab-case
  • •API JSON keys: camelCase most common in REST APIs
  • •Constants: SCREAMING_SNAKE_CASE signals immutable values
  • •Readability: consistent casing makes code scannable
  • •Interoperability: systems may be case-sensitive or case-insensitive

How Case Conversion Works

Case Conversion Reference

  • •toLowerCase() → every character to lowercase
  • •toUpperCase() → every character to uppercase
  • •Title Case → capitalize first letter of each word
  • •Sentence case → capitalize after . ! ?
  • •camelCase → split words, join with first word lower
  • •PascalCase → split words, join each capitalized
  • •snake_case → split on spaces/caps, join with _
  • •kebab-case → split on spaces/caps, join with -
  • •SCREAMING_SNAKE → snake_case then toUpperCase()

Word Boundary Detection

  • •Space-separated words (most common): "hello world" → words: ["hello", "world"]
  • •camelCase splitting: "helloWorld" → ["hello", "World"]
  • •PascalCase splitting: "HelloWorld" → ["Hello", "World"]
  • •Underscore-separated: "hello_world" → ["hello", "world"]
  • •Hyphen-separated: "hello-world" → ["hello", "world"]
  • •Mixed detection: handles all boundary types in a single pass
  • •Numbers: treated as word separators in most converters
  • •Acronyms: "XMLParser" → ["XML", "Parser"] (edge case)

Locale-Sensitive Casing

  • •Turkish: i → İ (not I) — requires locale-aware toUpperCase
  • •German: ß → SS when uppercased (no lowercase ß)
  • •Greek: multi-letter uppercase equivalents
  • •English default: safe for most Latin scripts
  • •JavaScript toLocaleUpperCase('tr') for Turkish
  • •JavaScript toLocaleUpperCase('de') for German
  • •Always specify locale for internationalized apps
  • •ASCII-only mode available for URL/slug generation

Real-World Applications

Software Development

  • •Convert variable names from camelCase to snake_case for Python migration
  • •Generate class names in PascalCase from plain descriptions
  • •Create database column names in snake_case from UI labels
  • •Convert API response keys from snake_case to camelCase for JavaScript
  • •Generate CSS class names in kebab-case from component names
  • •Create constant names in SCREAMING_SNAKE_CASE from config keys

Content & SEO

  • •Convert blog post titles to Title Case for publication
  • •Generate URL slugs in kebab-case from article titles
  • •Normalize inconsistent heading casing across a document
  • •Convert imported product names to proper Title Case
  • •Prepare meta titles in Sentence case
  • •Bulk-convert spreadsheet data from ALL CAPS exports

Data Engineering

  • •Normalize column names from mixed-case database dumps
  • •Convert JSON field names between camelCase and snake_case
  • •Standardize CSV headers for pipeline ingestion
  • •Transform legacy COBOL-style names (all caps) to modern conventions
  • •Prepare configuration keys in dot.case notation
  • •Batch-convert table names from PascalCase to snake_case

Documentation & Writing

  • •Convert raw notes to properly capitalized sentences
  • •Normalize author names to Title Case for bibliography
  • •Fix ALL CAPS text pasted from old documents
  • •Prepare legal document headings in Title Case
  • •Convert technical terms to proper case for style guides
  • •Normalize customer-submitted form data

Best Practices

Choosing the Right Case

  • •Use kebab-case for URLs — search engines prefer hyphens over underscores
  • •Use camelCase for JavaScript variables and function names
  • •Use PascalCase for JavaScript/TypeScript class names and React components
  • •Use snake_case for Python, Ruby, and SQL identifiers
  • •Use SCREAMING_SNAKE_CASE for environment variables and constants
  • •Use Title Case for UI headers, product names, and article titles
  • •Use Sentence case for body text, descriptions, and tooltips
  • •Avoid mixing conventions in the same codebase

Handling Edge Cases

  • •Acronyms (HTML, CSS, API) — decide whether to treat as single word or split
  • •Multi-word proper nouns (Los Angeles) — title case may need manual review
  • •Hyphenated words (self-service) — treatment varies by convention
  • •Numbers (web3, e-commerce) — usually kept as-is
  • •Possessives (user's, it's) — apostrophes preserved
  • •Leading/trailing spaces — trim before converting
  • •Empty strings — always return empty string
  • •Unicode letters — test non-ASCII inputs with locale-aware methods

Conversion Examples

Variable & Function Naming

  • •"user profile data" → camelCase → userProfileData
  • •"user profile data" → PascalCase → UserProfileData
  • •"user profile data" → snake_case → user_profile_data
  • •"user profile data" → kebab-case → user-profile-data
  • •"max retry count" → SCREAMING_SNAKE → MAX_RETRY_COUNT
  • •"get user by id" → camelCase → getUserById

URL & CSS Generation

  • •"My Blog Post Title 2024" → kebab-case → my-blog-post-title-2024
  • •"Primary Button" → kebab-case → primary-button
  • •"Background Color" → kebab-case → background-color
  • •"ProductDetailPage" → kebab-case → product-detail-page
  • •"API_BASE_URL" → kebab-case → api-base-url
  • •"section.header.title" → kebab-case → section-header-title

Data Normalization

  • •"JOHN DOE" (legacy) → Title Case → "John Doe"
  • •"product_name" (DB) → Title Case → "Product Name"
  • •"firstName" (API) → snake_case → "first_name"
  • •"STREET ADDRESS" → Sentence case → "Street address"
  • •"order-status" (CSS) → camelCase → "orderStatus"
  • •"HelloWorld" (PascalCase) → lowercase → "helloworld"

Frequently Asked Questions

What is the difference between camelCase and PascalCase?▾
camelCase starts with a lowercase letter (e.g., 'helloWorld'), while PascalCase (also called UpperCamelCase) starts with uppercase (e.g., 'HelloWorld'). camelCase is standard for JavaScript variables and functions; PascalCase for class names and React components.
Which case format should I use for URLs?▾
Use kebab-case (lowercase words separated by hyphens): 'my-page-title'. Google prefers hyphens over underscores in URLs for SEO, and kebab-case URLs are more readable than all-lowercase or camelCase alternatives.
How does Title Case handle short words like 'of', 'the', 'and'?▾
Standard Title Case capitalizes all words, including prepositions. Chicago style leaves short prepositions, articles, and conjunctions lowercase unless they're the first or last word. Our tool capitalizes all words by default for simplicity.
Can this handle non-English text?▾
Yes for most Latin-script languages. Turkish, Greek, and German have special uppercase/lowercase rules (e.g., Turkish 'i' → 'İ', German 'ß' → 'SS'). For precise locale-sensitive conversion in production code, use JavaScript's toLocaleUpperCase() with the appropriate locale tag.
What happens to numbers and special characters?▾
Numbers (0-9) are preserved as-is. Hyphens, underscores, and dots are treated as word separators in most conversions. Apostrophes are preserved. Other special characters are passed through unchanged.
Is there a limit to how much text I can convert?▾
No — the browser's JavaScript engine handles the conversion entirely in memory. Most browsers process millions of characters instantly. Extremely large pastes (> 50 MB) may cause a brief pause.