---
url: https://findutils.com/guides/case-converter-guide
title: "Case Converter: camelCase, snake_case, kebab-case and More"
description: "Convert text to camelCase, PascalCase, snake_case, kebab-case, CONSTANT_CASE, Title Case and more with the free FindUtils Case Converter. No signup."
category: text_tools
content_type: guide
guide_type: subtopic
cluster: text
locale: en
read_time: 9
status: published
author: "olgunozoktas"
published_at: 2026-10-17T08:00:00Z
excerpt: "Learn which naming case each language and file format expects, how to convert text between ten cases in one click, and how to avoid the acronym, punctuation, and multi-line traps that produce broken identifiers."
tag_ids: ["text-tools", "case-converter", "naming-conventions", "developer-tools", "writing"]
tags: ["Text Tools", "Case Converter", "Naming Conventions", "Developer Tools", "Writing"]
primary_keyword: "case converter"
secondary_keywords: ["camelcase converter", "snake case converter", "kebab case converter", "convert to title case", "pascal case vs camel case", "constant case"]
tool_tag: "case-converter"
related_tool: "case-converter"
related_tools: ["case-converter", "url-slug-generator", "whitespace-cleaner", "text-find-replace", "word-counter"]
updated_at: "2026-10-17T08:00:00Z"
og_image: "/images/content/guides/case-converter-guide-cover-20261017.webp"
image_alt: "Four rows of letter tiles spell the same two words, joined by a raised capital letter, an underscore, a hyphen, and in all capitals, showing one phrase in four naming cases."
---

A case converter rewrites the same words in a different letter case or naming style, such as turning `user profile id` into `userProfileId`, `user_profile_id`, or `user-profile-id`. Paste text into the FindUtils [Case Converter](/text/case-converter/), click one of ten case buttons, and copy the result. It is free, needs no signup, and converts the text in your browser.

This guide explains what each case is for, which conventions popular languages and formats follow, how to convert step by step, and the input patterns that most often produce a wrong identifier.

## What Cases Does the Case Converter Support?

The FindUtils Case Converter supports ten cases: four for prose and six for identifiers. Prose cases keep spaces and line breaks; identifier cases join words with a capital letter or a separator character. The table shows each case applied to the input `user profile id`.

| Case | Output | Typical use |
|------|--------|-------------|
| UPPERCASE | `USER PROFILE ID` | Headings, labels, emphasis |
| lowercase | `user profile id` | Normalizing text before comparing it |
| Title Case | `User Profile Id` | Headlines, button labels |
| Sentence case | `User profile id` | UI copy, form hints |
| camelCase | `userProfileId` | JavaScript variables and functions |
| PascalCase | `UserProfileId` | Class and type names |
| snake_case | `user_profile_id` | Python functions, database columns |
| kebab-case | `user-profile-id` | CSS class names, URL paths, file names |
| CONSTANT_CASE | `USER_PROFILE_ID` | Constants, environment variable names |
| dot.case | `user.profile.id` | Configuration and translation keys |

## Which Case Does Each Language Expect?

Each major language publishes its own naming rules, so the right case depends on where the name will live. The conventions below come from each project's official style guide.

- **Python:** [PEP 8](https://peps.python.org/pep-0008/) says function and variable names should be lowercase with words separated by underscores (snake_case), class names use the CapWords convention (PascalCase), and constants are written in capital letters with underscores, such as `MAX_OVERFLOW`.
- **JavaScript:** the [Google JavaScript Style Guide](https://google.github.io/styleguide/jsguide.html) writes methods and local variables in lowerCamelCase, classes in UpperCamelCase, and constants in CONSTANT_CASE.
- **Go:** [Effective Go](https://go.dev/doc/effective_go) asks for MixedCaps or mixedCaps rather than underscores. Case also has meaning in Go: a name whose first character is upper case is visible outside its package.
- **CSS:** property names are lowercase words joined by hyphens, such as `background-color`, and custom properties follow the same pattern, such as `--main-bg-color` in [MDN's custom properties guide](https://developer.mozilla.org/en-US/docs/Web/CSS/Guides/Cascading_variables/Using_custom_properties). Class names usually follow suit in kebab-case.

When a project already has its own style, match the existing code rather than a general rule. Consistency inside one codebase matters more than any single convention.

## How to Convert Text Case Online

Converting takes three actions: paste, pick a case, copy. The output updates as you type, so you can try several cases on the same input.

### Step 1: Paste Your Text

Open the [Case Converter](/text/case-converter/) and paste a phrase or identifier into the Input Text box. A counter under the box shows the number of characters, words, and lines.

### Step 2: Choose a Case

Click one of the ten case buttons above the input. The Output box shows the converted text, labeled with the case you picked, and the Case Reference panel lists an example of every case.

### Step 3: Copy or Chain the Result

Click Copy to put the result on your clipboard. Click Use as Input to move the output back into the input box, which lets you chain two conversions. Chaining is the fix for several of the traps described below.

## Converting Between Identifier Cases Without Losing Words

The converter finds word boundaries in two ways: at spaces, hyphens, and underscores, and, for snake_case, kebab-case, CONSTANT_CASE, and dot.case, at the point where a lowercase letter is followed by an uppercase one. The camelCase and PascalCase buttons lowercase the input first and split only at non-alphanumeric characters, so they need visible separators.

That difference decides which conversions work in one step:

| From | To | Result | One step? |
|------|----|--------|-----------|
| `user_profile_id` | camelCase | `userProfileId` | Yes |
| `user-profile-id` | PascalCase | `UserProfileId` | Yes |
| `userProfileId` | snake_case | `user_profile_id` | Yes |
| `userProfileId` | kebab-case | `user-profile-id` | Yes |
| `userProfileId` | PascalCase | `Userprofileid` | No: convert to snake_case first |

To turn `userProfileId` into `UserProfileId`, click snake_case, click Use as Input, then click PascalCase. The intermediate `user_profile_id` carries the word boundaries that PascalCase needs.

## Worked Examples

These examples cover the conversions people search for most often.

### Example 1: A database column to a JavaScript property

Input `created_at`, click camelCase, and the output is `createdAt`. This is the usual mapping between snake_case database columns and camelCase object properties.

### Example 2: A setting name to an environment variable

Input `max retry count`, click CONSTANT_CASE, and the output is `MAX_RETRY_COUNT`.

### Example 3: A component name to a CSS class

Input `PrimaryButton`, click kebab-case, and the output is `primary-button`.

### Example 4: Numbers inside identifiers

Input `api v2 key` and the converter keeps the digit with its word: camelCase gives `apiV2Key`, snake_case gives `api_v2_key`, and PascalCase gives `ApiV2Key`.

### Example 5: A headline in Title Case

Input `the lord of the rings` and Title Case returns `The Lord Of The Rings`. The tool capitalizes every word. Many editorial style guides keep short words such as "of" and "the" lowercase, so adjust those by hand if your publication follows such a rule.

## Common Mistakes to Avoid

Most wrong results come from input that is not a clean list of words. Clean the input first and the output is predictable.

### Mistake 1: Converting several identifiers at once

The identifier cases treat a line break like any other separator, so `first name` and `last name` on two lines become `firstNameLastName` in camelCase or `first_name_last_name` in snake_case. Convert one identifier at a time. The prose cases (UPPERCASE, lowercase, Title Case, Sentence case) keep line breaks.

### Mistake 2: Expecting acronyms to split

A run of capitals is read as part of one word. `XMLHttpRequest` becomes `xmlhttp_request` in snake_case, and `getHTTPResponse` becomes `get_httpresponse`. Add a space or underscore between the acronym and the next word before converting, for example `get HTTP response`. Note that style guides disagree on acronyms: PEP 8 prefers `HTTPServerError` over `HttpServerError` in CapWords, while the converter produces `HttpServerError`.

### Mistake 3: Leaving punctuation in the input

The snake_case and kebab-case buttons keep punctuation, so `hello, world!` becomes `hello,_world!`, and apostrophes split camelCase words (`don't stop` becomes `donTStop`). Remove punctuation first with [Find & Replace](/text/text-find-replace/), which supports regular expressions.

### Mistake 4: Stray spaces at the start or end

A leading space becomes a leading separator, so ` leading space` turns into `_leading_space` in snake_case. Run the text through the [Whitespace Cleaner](/text/whitespace-cleaner/) with Trim the ends turned on, then convert.

### Mistake 5: Accented letters in identifiers

The camelCase and PascalCase buttons keep only the ASCII letters A to Z and digits, so `café menu` becomes `cafMenu`. For identifiers, transliterate first: the [URL Slug Generator](/seo/url-slug-generator/) turns `café menu` into `cafe-menu`, and the Case Converter turns that into `cafeMenu`.

### Mistake 6: Trusting Sentence case with names

Sentence case lowercases everything before capitalizing the first letter of each sentence, so `new york. it is big` becomes `New york. It is big`. Re-capitalize proper nouns after converting.

### Mistake 7: Expecting locale-specific capitals

UPPERCASE uses the standard Unicode case mapping, so `istanbul` becomes `ISTANBUL`. Turkish orthography writes the dotted capital `İ` (`İSTANBUL`), which only locale-aware conversion produces, as [MDN's toLocaleUpperCase() reference](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLocaleUpperCase) shows. Check Turkish and Azerbaijani text by hand.

## Case Converter vs Editor Commands vs Code

A browser converter suits one-off renames. Editor commands and code suit repeated, in-place work.

| Aspect | FindUtils Case Converter | Code editor commands | String functions in code |
|--------|--------------------------|----------------------|--------------------------|
| Setup | None; open the page | Built in or via an extension | Write and test the function |
| Cases | Ten, side by side | Varies by editor | Whatever you implement |
| Best for | Quick renames, copy for docs and tickets | Renaming inside a file | Bulk conversion in a build or script |
| Cost | Free, no signup | Usually free | Your time |
| Data handling | Converted in your browser | Local | Local |

## Tools Used in This Guide

- **[Case Converter](/text/case-converter/)** — Convert text between ten prose and identifier cases
- **[URL Slug Generator](/seo/url-slug-generator/)** — Turn titles into clean, transliterated slugs with a hyphen, underscore, or dot separator
- **[Whitespace Cleaner](/text/whitespace-cleaner/)** — Trim ends, collapse spaces, and remove blank lines
- **[Find & Replace](/text/text-find-replace/)** — Strip punctuation or rename patterns with plain text or regex
- **[Word Counter](/text/word-counter/)** — Count words and characters before and after editing

## FAQ

### What is the difference between camelCase and PascalCase?

camelCase starts with a lowercase letter and capitalizes each following word (`userProfileId`). PascalCase capitalizes every word, including the first (`UserProfileId`). JavaScript style guides use camelCase for variables and PascalCase for classes.

### Is snake_case or kebab-case better?

Neither is better in general; each belongs to a context. snake_case is the Python convention for functions and variables, while kebab-case is common for CSS class names, URL paths, and file names. Many programming languages cannot use kebab-case for identifiers because the hyphen is read as a minus sign.

### Why did my camelCase text turn into one lowercase word?

The camelCase and PascalCase buttons lowercase the input and split only at spaces, hyphens, underscores, and other non-alphanumeric characters. Input that is already camelCase has none, so convert it to snake_case first, click Use as Input, and then pick the case you want.

### Can I convert a whole list of variable names at once?

Not with the identifier cases, because they join lines together. Convert names one at a time, or use the prose cases, which keep line breaks.

### Does the Case Converter upload my text?

No. On the tool page, the conversion runs in your browser and the text is not sent to a server.

### Is the Case Converter free?

Yes. It is free, has no usage limits, and needs no signup.

### What case should environment variable names use?

Environment variable names are conventionally written in CONSTANT_CASE, such as `DATABASE_URL`. The CONSTANT_CASE button produces that format from any spaced, hyphenated, or camelCase input.

## Next Steps

- Clean messy input with the [Whitespace Cleaner](/text/whitespace-cleaner/) before converting it.
- Build URL-ready slugs with the [URL Slug Generator](/seo/url-slug-generator/).
- Learn regex-based renaming in the [Find & Replace guide](/guides/text-find-replace-guide/).
- Count words and characters with the [Word Counter guide](/guides/word-counter-guide/).

## Sources

- [PEP 8: Style Guide for Python Code](https://peps.python.org/pep-0008/)
- [Google JavaScript Style Guide](https://google.github.io/styleguide/jsguide.html)
- [Effective Go: Names and MixedCaps](https://go.dev/doc/effective_go)
- [MDN: Using CSS custom properties](https://developer.mozilla.org/en-US/docs/Web/CSS/Guides/Cascading_variables/Using_custom_properties)
- [MDN: String.prototype.toLocaleUpperCase()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLocaleUpperCase)