Convert text between camelCase, PascalCase, snake_case, kebab-case, UPPERCASE, lowercase, and Title Case in one click. Free online string case converter.
String Case Converter processes your text in the browser, which means even sensitive strings stay private.
It's one of the free
String & Text Tools
on UseToolSuite.
Use it below, then scroll down for a step-by-step guide, answers to common questions, and related tools.
What is Case Converter?
Case Converter is a free online tool that transforms text between seven
popular casing formats: camelCase, PascalCase, snake_case, kebab-case,
UPPERCASE, lowercase, and Title Case. Simply paste or type your text and
click the target format — the converted result appears instantly. This
tool intelligently detects word boundaries in compound strings
regardless of the original format, so it can correctly convert
"helloWorld" to "hello_world" or "Hello World" just as easily. All
processing happens in your browser with zero server calls.
When to use it?
Use the Case Converter whenever you need to adapt variable names,
function names, or identifiers between different naming conventions.
It's particularly useful when translating code between languages that
follow different casing standards — for example, converting JavaScript's
camelCase to Python's snake_case. It also comes in handy when generating
CSS class names, database column names, URL slugs, or constants that
require a specific casing style.
Common use cases
Developers commonly use Case Converter to rename variables when porting
code between programming languages with different naming conventions,
generate consistent CSS class names in kebab-case from design specs
written in Title Case, create database column names in snake_case from
application-layer camelCase properties, format constants in
SCREAMING_SNAKE_CASE, build URL-friendly slugs in kebab-case from page
titles, and batch-convert identifier lists when refactoring codebases to
adhere to new style guides or linting rules.
Naming conventions by programming language
Each language has established conventions: JavaScript uses camelCase for variables and PascalCase for classes. Python uses snake_case for functions and variables, PascalCase for classes. CSS uses kebab-case for class names and custom properties. Go uses PascalCase for exported identifiers and camelCase for unexported ones. Rust uses snake_case for functions and SCREAMING_SNAKE_CASE for constants. Following these conventions makes your code instantly familiar to other developers in that ecosystem and avoids linter warnings.
Converting cases as part of a refactor
Renaming identifiers across a codebase is rarely a one-off — it usually happens when adopting a linter rule or moving code between languages. A practical workflow: copy the identifier list out of your linter report (ESLint’s camelcase rule, PEP 8’s invalid-name from pylint), paste the list here one per line, convert, and use your editor’s multi-cursor or a sed script to apply the renames. Converting the names first and reviewing them as plain text catches awkward results — like an acronym that splits badly — before they touch the code.
Edge cases worth knowing
- Numbers stick to the word before them:
user2fa → user_2fa in snake_case, keeping the digit grouped with its suffix.
- Mixed separators (
hello_world-FooBar) are normalized in one pass; you don’t need to pre-clean the input.
- Title Case follows headline conventions: every word is capitalized. For AP-style headlines where short conjunctions stay lowercase, do a manual pass afterwards — automated AP capitalization requires a dictionary of minor words.
- SCREAMING_SNAKE_CASE is just snake_case + UPPER: convert to snake_case first, then apply UPPERCASE if you need constant style.
Where each convention is expected
Beyond per-language norms, casing matters at system boundaries: REST APIs conventionally use snake_case or camelCase JSON keys (pick one and stay consistent), environment variables are SCREAMING_SNAKE_CASE by POSIX convention, CSS custom properties and HTML data attributes must be kebab-case (HTML attribute names are case-insensitive), and database identifiers are safest in snake_case because unquoted identifiers fold to lowercase in PostgreSQL and uppercase in Oracle. Converting at these boundaries — rather than letting two conventions leak into one layer — is what keeps serializers and ORMs configuration-free.
How helpful was this tool?
Click to rate
Awesome! Glad it helped.
We don't have a marketing budget. The best way to support this free tool is by sharing it with other developers!
Help us improve!
Sorry it didn't meet your expectations. We're always looking to make these tools better. What was missing or broken?
Open GitHub Issue