What case styles are supported?

We support camelCase, PascalCase, snake_case, kebab-case, CONSTANT_CASE, and more. Click any button to instantly convert your text.

Does it work with multiple words?

Yes! The tool intelligently handles spaces, underscores, hyphens, and other delimiters to convert between any naming convention.

Can I convert variables in code?

Absolutely! Paste variable names, function names, or any identifier and convert them to your preferred naming style.

What's the difference between camelCase and PascalCase?

camelCase starts with a lowercase letter (myVariable), while PascalCase starts with an uppercase letter (MyVariable).

Yes! Paste multiple lines of text and the tool will convert each line individually to your selected case style.

Case Converter

Convert text between different naming conventions instantly.

Enter text to see conversions

Conversion happens automatically as you type

Case conversion is the process of transforming text between different naming conventions commonly used in programming. Each programming language, framework, and context has preferred naming styles that help maintain code consistency and readability.

These naming conventions aren't arbitrary—they help developers quickly understand the purpose and scope of identifiers in code. For example, PascalCase typically indicates a class or type, while CONSTANT_CASE signals a configuration value that shouldn't change.

This tool automatically converts your input text to all common naming conventions, making it easy to maintain consistency across your codebase, migrate between languages, or adapt to different API standards.

Enter your text: Type or paste any text in the input field. The tool accepts single words, phrases, or multiple words separated by spaces.
Automatic conversion: The tool instantly converts your text to all available naming conventions.
Copy results: Click the copy button next to any converted result to quickly copy it to your clipboard.
Multiple words: The tool intelligently handles multi-word inputs, preserving word boundaries appropriately for each convention.
Preserve formatting: Special characters and numbers are handled correctly in each naming style.

Language	Variables	Functions	Classes	Constants
JavaScript	camelCase	camelCase	PascalCase	UPPER_CASE
Python	snake_case	snake_case	PascalCase	UPPER_CASE
Ruby	snake_case	snake_case	PascalCase	UPPER_CASE
C#	camelCase	PascalCase	PascalCase	PascalCase
Go	mixedCase	MixedCase	PascalCase	MixedCase
Java	camelCase	camelCase	PascalCase	UPPER_CASE

💡 Tip: Using the correct naming convention for your language helps code readability and follows community best practices.

JavaScript/TypeScript: Use camelCase for variables and functions (getUserName), PascalCase for classes and React components (UserProfile)
Python/Ruby: Use snake_case for variables and functions (get_user_name), PascalCase for classes (UserProfile)
CSS/HTML: Use kebab-case for class names and attributes (user-profile-card, data-user-id)
Constants: Use CONSTANT_CASE for configuration values (MAX_RETRY_COUNT, API_BASE_URL)
URLs/Slugs: Use kebab-case for SEO-friendly URLs (blog-post-title, category-name)
File Names: kebab-case for components (user-profile.tsx), snake_case for Python modules (user_model.py)
API Design: Convert between camelCase (JSON) and snake_case (Python backends) for consistent data exchange
Database Columns: SQL typically uses snake_case (user_created_at), while NoSQL might use camelCase (userCreatedAt)

REST API Endpoints

Common patterns for URL paths:

kebab-case: /api/user-profiles/123 (most common)
snake_case: /api/user_profiles/123 (Python-style)
camelCase: /api/userProfiles/123 (less common for URLs)

JSON Keys

The great debate: camelCase vs snake_case

camelCase (JS/Frontend)

{ "userId": 123, "firstName": "John", "createdAt": "2024-01-01" }

snake_case (Python/Backend)

{ "user_id": 123, "first_name": "John", "created_at": "2024-01-01" }

GraphQL

GraphQL typically uses camelCase for all field names: userProfile { firstName lastName }

Acronyms in different naming conventions can be tricky. Here are the best practices:

camelCase / PascalCase:

Preferred: Treat acronyms as words: htmlParser, HtmlParser
Alternative: Keep uppercase: HTMLParser (harder to read)
Examples: xmlHttpRequest, parseUrl, getUserId

snake_case / kebab-case:

Lowercase: html_parser, xml-http-request
Consistency: Never mix uppercase in snake/kebab case

CONSTANT_CASE:

All uppercase: HTML_PARSER, XML_HTTP_REQUEST
Examples: MAX_URL_LENGTH, API_KEY, HTTP_TIMEOUT

Database column and table naming varies by database type and team preference:

SQL Databases (PostgreSQL, MySQL, SQLite)

Most common: snake_case for tables and columns: user_profiles, created_at
Why: Case-insensitive in many SQL databases, avoids quoting issues
Example: SELECT user_id, first_name FROM user_accounts

NoSQL Databases (MongoDB, DynamoDB)

Common: camelCase to match JavaScript/JSON conventions: userId, createdAt
Why: Direct mapping to application code reduces transformation logic

ORM Considerations

ORMs often handle automatic case conversion between database (snake_case) and code (camelCase), but explicit configuration is clearer and prevents bugs.

Be consistent: Pick one convention per context (files, variables, APIs) and stick to it throughout your project.
Follow language conventions: When in Rome... Use the naming style that's standard for your programming language.
Consider your team: If your team has established conventions, follow them even if they differ from general best practices.
Use linters: Tools like ESLint, Pylint, or RuboCop can enforce naming conventions automatically.
Document your choices: Add naming conventions to your project's style guide or README.
API contracts: For APIs consumed by multiple clients, document your naming convention clearly in API documentation.
Migration: When refactoring, use this tool to batch-convert identifiers while maintaining consistency.

You might also need

📄

JSON Formatter

Format and validate JSON

→ JSON key formatting

📊

Word Count

Count words and characters

→ Text processing

🔍

Regex Tester

Test regular expressions

→ Test case patterns

Browse all tools

Case Converter

What is Case Conversion?

How to Use This Tool

Language-Specific Conventions

Common Use Cases

API Naming Conventions