AaText Case Converter
14 words72 chars
14 conversions
UPPER CASE
THE QUICK BROWN FOX JUMPS OVER THE LAZY DOG. HELLO WORLD FROM FWD TOOLS.
e.g. HELLO WORLD
lower case
the quick brown fox jumps over the lazy dog. hello world from fwd tools.
e.g. hello world
Title Case
The Quick Brown Fox Jumps Over The Lazy Dog. Hello World From Fwd Tools.
e.g. Hello World
Sentence case
The quick brown fox jumps over the lazy dog. Hello world from fwd tools.
e.g. Hello world. How are you?
camelCase
theQuickBrownFoxJumpsOverTheLazyDog helloWorldFromFwdTools
e.g. helloWorld
PascalCase
TheQuickBrownFoxJumpsOverTheLazyDog HelloWorldFromFwdTools
e.g. HelloWorld
snake_case
the_quick_brown_fox_jumps_over_the_lazy_dog hello_world_from_fwd_tools
e.g. hello_world
SCREAMING_SNAKE
THE_QUICK_BROWN_FOX_JUMPS_OVER_THE_LAZY_DOG HELLO_WORLD_FROM_FWD_TOOLS
e.g. HELLO_WORLD
kebab-case
the-quick-brown-fox-jumps-over-the-lazy-dog hello-world-from-fwd-tools
e.g. hello-world
COBOL-CASE
THE-QUICK-BROWN-FOX-JUMPS-OVER-THE-LAZY-DOG HELLO-WORLD-FROM-FWD-TOOLS
e.g. HELLO-WORLD
Train-Case
The-Quick-Brown-Fox-Jumps-Over-The-Lazy-Dog Hello-World-From-Fwd-Tools
e.g. Hello-World
dot.case
the.quick.brown.fox.jumps.over.the.lazy.dog hello.world.from.fwd.tools
e.g. hello.world
aLtErNaTiNg
tHe QuIcK bRoWn FoX jUmPs OvEr ThE lAzY dOg. HeLlO wOrLd FrOm FwD tOoLs.
e.g. hElLo WoRlD
iNVERSE cASE
tHE QUICK BROWN FOX JUMPS OVER THE LAZY DOG. hELLO wORLD FROM fwd tOOLS.
e.g. hELLO wORLD

Text Case Converter — camelCase, snake_case, PascalCase, kebab-case & 14 Formats

Updated May 17, 2026
Share & Support

What's included

Features

All 14 case formats shown simultaneously — paste once and see every conversion without switching between tools or clicking separate buttons
camelCase — splits on spaces, hyphens, underscores, dots, and existing camelCase/PascalCase boundaries; used in JavaScript, TypeScript, Java, Swift, and Dart
PascalCase — same splitting logic as camelCase but capitalizes the first word; used for class names, React components, and TypeScript interfaces
snake_case and SCREAMING_SNAKE_CASE — underscore-separated lowercase and uppercase; used in Python, Ruby, Rust, SQL, and environment variables
kebab-case and COBOL-CASE — hyphen-separated lowercase and uppercase; used in CSS, URLs, npm packages, and HTTP header names
Train-Case, dot.case — capitalised-hyphen and dot-separated formats for HTTP headers, package namespaces, and config keys
Title Case and Sentence case — for headings, article titles, UI labels, and properly capitalised prose
UPPER CASE, lower case, alternating case, inverse case — utility transformations for content editing and creative text effects
Smart input splitting — automatically detects and splits camelCase and PascalCase input so conversions are correct when pasting existing code identifiers
Multi-line support — converts each line independently; paste a batch of variable names and get all 14 formats for the entire list at once
Pin cases to top — ⊹ pin your most-used formats so they appear first in the grid on every visit
Apply back to input — ↑ button feeds any converted output back into the input for chaining transformations

About this tool

Text Case Converter — Free, Convert to camelCase, snake_case, PascalCase, kebab-case & 14 More Formats

Runs in your browser
No install or signup
Free forever

Paste your text once and instantly see all 14 case conversions side by side — no switching between tools, no separate buttons, no waiting. Every format updates live as you type.

This tool covers every naming convention you will encounter in software development and content writing: camelCase for JavaScript variables and functions, PascalCase for React components and TypeScript types, snake_case for Python and database columns, SCREAMING_SNAKE_CASE for constants and environment variables, kebab-case for CSS classes and URL slugs, COBOL-CASE for HTTP headers and legacy systems, Train-Case for HTTP header formatting in Go, dot.case for package namespaces and config keys, Title Case for headings and UI labels, Sentence case for readable prose, UPPER CASE, lower case, alternating case, and inverse case.

The converter is smart about its input. If you paste existing camelCase or PascalCase text like getUserProfileData, it automatically splits on letter-case transitions — get, User, Profile, Data — so all output formats are correct. It also splits on underscores, hyphens, dots, and spaces, meaning you can paste from any source format and get accurate output in every target format.

Multi-line support means you can paste a whole list of identifiers — one per line — and every line gets converted independently. Paste 20 database column names and get all 14 case variants for all 20 names at once.

Pin your most-used cases to the top of the grid so they're always within reach. Use the ↑ Apply button to feed any converted output back into the input for chaining conversions. Everything runs in your browser — no server, no data sent, works offline.

Step by step

How to Use

  1. 1
    Type or paste your text into the input fieldType or paste any text into the large input field at the top of the page. All 14 case conversions appear instantly in the card grid below as you type — no button press required. Click Paste to pull text directly from your clipboard, Sample to load example text and explore the tool, or Clear to reset the input. The word and character count update live in the header.
  2. 2
    Browse the conversion results gridEach card in the grid shows the case format label (e.g., camelCase, snake_case), its colour-coded identifier, the converted output for your text, and a small example to confirm the expected format. All 14 formats — camelCase, PascalCase, snake_case, SCREAMING_SNAKE_CASE, kebab-case, COBOL-CASE, Train-Case, dot.case, Title Case, Sentence case, UPPER CASE, lower case, alternating case, and inverse case — are shown simultaneously so you can compare them at a glance.
  3. 3
    Copy any format with one clickClick the Copy button on any case card to copy that format's output to your clipboard. The button briefly shows a checkmark to confirm the copy. You can copy multiple different formats in sequence — each click copies that card's output independently.
  4. 4
    Filter to find a specific case quicklyUse the Filter cases search input in the toolbar to narrow the grid by name. Type "snake" to show only snake-related formats, "camel" to find camelCase and related formats, or "title" to find title and train case. The grid filters in real time as you type.
  5. 5
    Pin, apply, and chain conversionsClick on any card to pin it to the top of the grid — useful when you always need camelCase or snake_case within reach. Click (Apply) to feed that card's output back into the input field for further transformation — for example, apply camelCase first to split the input cleanly, then apply snake_case to the result. This chaining approach handles complex mixed-format input that a single conversion might not parse perfectly.

Real-world uses

Common Use Cases

💻
Convert variable and function names between programming languages
When porting code between Python (snake_case) and JavaScript (camelCase), paste your Python function names here and copy the camelCase output. When creating a TypeScript interface from a Python dataclass, paste the snake_case field names and copy PascalCase for the type and camelCase for the fields. When writing Go code that calls a REST API with snake_case JSON keys, convert the names to Go's PascalCase exported struct fields. Use the multi-line input to convert a whole list of identifiers at once — paste 20 column names, get all 20 in camelCase in one copy.
🗄
Convert database column names to code variable names
Database column names follow snake_case convention (user_first_name, created_at, is_active). Paste a list of your schema column names here and copy the camelCase output for JavaScript ORM models, the PascalCase for C# entity classes, or SCREAMING_SNAKE_CASE for SQL constants and migration scripts. This eliminates the tedious manual renaming that causes typos when wiring up a new database table to a frontend. Combine with our JSON to TypeScript converter to generate full TypeScript interfaces from API responses.
🎨
Generate CSS class names and design token names
Design tokens and CSS custom properties use kebab-case (--color-primary-500, .flex-center, .btn-outline-danger). Paste your token names from a Figma file or design brief and copy the kebab-case output directly into your stylesheet. For Tailwind CSS arbitrary values and component class names, kebab-case is the standard. Convert the same names to camelCase for JavaScript object keys in a design token JS file, or to SCREAMING_SNAKE_CASE for Sass variable names ($COLOR_PRIMARY_500).
📝
Convert headings and article titles to Title Case
Blog post titles, article headings, email subject lines, and page meta titles conventionally use Title Case. Paste your draft heading in any format and copy the Title Case output. This is especially useful when importing content from a document or database where capitalisation is inconsistent. Run each H1 and H2 heading through the converter to ensure consistent capitalisation across your site. Combine with Word Counter to check heading length and readability, and Meta Tag Generator to write the page title and description.
🔧
Format environment variables and config keys as SCREAMING_SNAKE_CASE
Environment variables in .env files, Docker compose, Kubernetes secrets, CI/CD pipelines, and shell scripts always use SCREAMING_SNAKE_CASE. Paste your config key names here and copy the SCREAMING_SNAKE_CASE output directly into your .env file or configuration YAML. When a developer writes a new feature and needs to name five new environment variables, this converter produces all five formatted correctly in one paste. Combine with the ↑ Apply button to chain — convert to camelCase first to clean up the input, then apply that output and copy the SCREAMING_SNAKE_CASE result.
🌐
Convert page titles and content to URL-friendly kebab-case slugs
URL slugs must be lowercase, hyphen-separated, and free of special characters. Paste a blog post title like "Building a REST API with Node.js and Express" and copy the kebab-case output: "building-a-rest-api-with-node-js-and-express". This is ready to use as the URL path, file name, or route parameter. For static site generators (Jekyll, Hugo, Gatsby, Next.js), file names follow the same kebab-case convention. Use Lorem Ipsum Generator to generate sample slugs for testing routing logic.

Got questions?

Frequently Asked Questions

Paste your text into the input field at the top of this converter. All 14 case formats are shown simultaneously in the grid below — find the camelCase card and click "Copy" to copy the converted text to your clipboard. camelCase joins words together with no separator and capitalizes every word except the first: "hello world" becomes "helloWorld". The converter automatically handles text from any source — it splits on spaces, hyphens, underscores, dots, and even detects existing camelCase or PascalCase boundaries.

camelCase starts with a lowercase letter and capitalizes each subsequent word: helloWorld. It is the default naming convention for variables and functions in JavaScript, Java, Swift, Kotlin, and Dart. PascalCase (also called UpperCamelCase) capitalizes every word including the first: HelloWorld. It is used for class names, component names in React, and type names in TypeScript and C#. snake_case separates words with underscores and uses all lowercase: hello_world. It is the standard for variables and functions in Python, Ruby, and Rust, and for database column names in SQL.

kebab-case (also written as "kebab case" or "spinal case") separates words with hyphens and uses all lowercase: hello-world. It is the standard for CSS class names, HTML attributes, URL slugs, and file names in web projects. For example: a CSS utility class might be .flex-center, a URL might be /blog/getting-started-with-react, and a package name in npm uses kebab-case. Kebab-case is invalid in most programming languages as a variable or function name because the hyphen is interpreted as a minus operator — it is primarily a web and filesystem convention.

SCREAMING_SNAKE_CASE (also called CONSTANT_CASE or UPPER_SNAKE_CASE) uses all uppercase letters with underscores between words: HELLO_WORLD. It is the universal convention for constants, environment variables, and compile-time configuration values across almost every programming language. Examples: MAX_RETRIES = 3, API_BASE_URL, NODE_ENV = "production", HTTP_PORT = 8080. In Python, Java, JavaScript, C, C++, Go, and Rust, constants defined at the module or global scope use SCREAMING_SNAKE_CASE. Environment variables in .env files and shell scripts also follow this convention.

Paste your camelCase text (e.g., "getUserProfile") into the input field. The converter automatically detects camelCase word boundaries by splitting on transitions between lowercase and uppercase letters. The snake_case card in the grid shows the converted result: "get_user_profile". Click "Copy" to copy it. The same input simultaneously produces all other formats — PascalCase, kebab-case, SCREAMING_SNAKE_CASE, and more — so you can switch between naming conventions for the same identifier without re-typing.

Title Case capitalizes the first letter of every word: "Hello World". It is used for article headings, page titles, button labels, navigation items, and book titles. This converter capitalizes every word including short conjunctions and prepositions, which is appropriate for UI labels and headings. Academic and journalistic style guides (APA, Chicago, AP) define slightly different rules — for example, short prepositions like "in", "on", and "at" are typically not capitalized in headlines — but for most web and UI purposes, capitalizing every word produces consistent, readable results.

COBOL-CASE (also called screaming kebab case or UPPER-KEBAB-CASE) uses all uppercase letters separated by hyphens: HELLO-WORLD. It gets its name from the COBOL programming language, where identifiers historically used this format. Today it appears as HTTP header names (Content-Type, X-Request-ID, Accept-Language), in some legacy enterprise systems, and occasionally in configuration file keys. The Train-Case variant (Hello-World) is used specifically for HTTP headers in Go's http package, where it distinguishes canonically formatted header keys.

Yes — the converter handles multi-line input. Each line is converted independently so line breaks are preserved in the output. For example, if you paste a list of database column names like "user_first_name", "email_address", "created_at" with each on its own line, the camelCase output will show "userFirstName", "emailAddress", "createdAt" — one per line. This is useful when renaming a batch of variables, converting a list of API field names between conventions, or reformatting a set of CSS class names. Pin your most-used case formats to the top of the grid using the ⊹ button for faster access.