Free Text Case Converter Online

Convert Text Between Cases Instantly

A text case converter takes whatever you type or paste and reshapes it into a different letter-casing style at the click of a button — UPPERCASE, lowercase, Title Case, Sentence case, and eight programming-oriented styles including camelCase, PascalCase, snake_case, and kebab-case. Type or paste text into the box, pick a style from the grid of buttons, and the converted result appears below instantly, with a live word and character count sitting under the output. Nothing needs uploading and nothing needs saving first; the transformation happens the moment you click.

The reason a dedicated text case converter earns a spot in most writers' and developers' bookmarks is that manual re-casing is tedious and error-prone. Retyping a paragraph in Title Case by hand means capitalizing each word correctly and remembering which small connecting words conventionally stay lowercase. Converting a phrase into camelCase or snake_case by hand means stripping spaces, deciding where word boundaries fall, and getting the capitalization pattern exactly right — one misplaced capital breaks a variable name a compiler will refuse to recognize. This tool handles both jobs the same way: reliably, instantly, and without the tedium of doing it letter by letter.

How to Convert a Case

1. Paste or type text into the input box at the top of the tool.
2. Choose a case from the grid of twelve buttons: UPPERCASE, lowercase, Title Case, Sentence case, camelCase, PascalCase, snake_case, kebab-case, CONSTANT_CASE, dot.case, aLtErNaTiNg, and iNVERSE.
3. The converted result appears immediately in an output panel below the buttons, labeled with the style you picked, along with a live word count and character count for the converted text.
4. Click "Copy" next to the result to place it on your clipboard. Keep typing in the input box afterward and the output keeps updating to match your active case selection, so you don't need to reselect the same button after every edit.

What Each of the Twelve Styles Actually Does

Six of the twelve styles are the everyday writing formats: UPPERCASE and lowercase convert every letter regardless of word boundaries; Title Case capitalizes the first letter of each word; Sentence case capitalizes only the first letter after each sentence-ending punctuation mark, leaving the rest lowercase; aLtErNaTiNg alternates lowercase and uppercase letter by letter through the whole string; and iNVERSE flips the case of every existing letter, so capitals become lowercase and lowercase becomes capitals.

The other six are naming conventions borrowed from programming, and this text case converter is built to move between all of them, not just from plain prose. Before applying a style, the tool splits your input into individual words — recognizing existing camelCase boundaries, underscores, hyphens, and periods as word separators — which means feeding it an already-formatted user_account_name or userAccountName works exactly as well as feeding it plain words separated by spaces. From that word list, camelCase joins words with no separator and a lowercase first word; PascalCase does the same but capitalizes every word including the first; snake_case joins lowercase words with underscores; kebab-case joins them with hyphens; CONSTANT_CASE joins uppercase words with underscores; and dot.case joins lowercase words with periods.

Style	Example output	Typical use
UPPERCASE	HELLO WORLD	Headlines, emphasis, warning labels
Sentence case	Hello world. Nice to meet you.	Normalizing pasted all-caps text
camelCase	helloWorld	JavaScript variable and function names
snake_case	hello_world	Python variables, database column names
kebab-case	hello-world	URL slugs, CSS class names, file names
CONSTANT_CASE	HELLO_WORLD	Environment variables, constants

Who Reaches for a Case Converter

• Developers renaming variables between conventions. Moving a data field from a Python backend that uses snake_case to a JavaScript frontend that expects camelCase is a small but constant chore this tool handles in one click instead of a manual find-and-replace pass.
• Writers cleaning up pasted text. Text copied from a PDF, an old email, or a scanned document sometimes arrives in stray ALL CAPS or with inconsistent capitalization; running it through Sentence case or Title Case normalizes it in one step rather than manually retyping.
• Anyone building a URL slug or file name. Converting a page title into kebab-case produces a clean, URL-safe slug without spaces or special characters needing separate cleanup.
• Social media managers formatting headlines. Title Case is a common house style for headlines and post titles, and applying it consistently across a batch of drafts is faster through this tool than doing it by eye each time.
• Students and professionals fixing Caps Lock accidents. Text typed with Caps Lock on by mistake converts cleanly back to normal Sentence case rather than needing to be retyped from scratch.

Mistakes That Show Up When Naming Conventions Are Switched by Hand

• Dropped or doubled underscores. Manually turning "user account name" into snake_case is easy to get wrong at the boundary between words, especially in a long identifier with several segments, where it's easy to lose track partway through.
• Inconsistent capitalization inside camelCase. Hand-converting a multi-word phrase into camelCase means remembering that only the first letter of each word after the first gets capitalized — a single slip partway through a long name is easy to miss on a quick read.
• Leftover spaces in a supposed kebab-case string. Copy-pasting a title and manually replacing only some of the spaces with hyphens produces a slug that looks right at a glance but fails validation the moment it's used as an actual URL path or a CSS class name.
• Case drift across a long document. A person manually applying Title Case to dozens of headings over a long editing session tends to get less consistent partway through, capitalizing a small connecting word in one heading and not the next.

Each of these is a small, individually forgivable error, but they compound across a codebase or a long document in a way that's tedious to catch during review. Running the same text through a fixed, repeatable conversion rule removes the inconsistency entirely, since the tool applies the identical rule to every input rather than drifting with fatigue partway through a long list.

Case Conversion vs. Manual Retyping and Editor Shortcuts

Some word processors and code editors include a basic case-toggle shortcut, but those are typically limited to switching between upper, lower, and title case on already-written prose — they don't handle the programming-style conventions like snake_case, kebab-case, or PascalCase, since those aren't concepts a general word processor needs. A text editor's find-and-replace feature can approximate a case conversion with a carefully built regular expression, but that requires writing and testing the expression itself, which is far more setup than pasting text into a box and clicking a button.

A text case converter avoids both of those workarounds entirely. Manually retyping text into a new case is the most error-prone option of all, especially for the programming-oriented styles, where a single missed capital letter or misplaced underscore can turn a valid variable name into one a compiler rejects, or turn a working URL slug into one with an accidental space encoded into it. Consistency across a long piece of text is also difficult to maintain by hand — this tool applies the same rule to every character or every word boundary without drifting partway through a long paste.

The same case-conversion logic is available outside the browser as a metered API endpoint: send text and a target case, and get the converted string back in the response, which is useful for normalizing user-submitted field names or cleaning up text during an automated data-import pipeline. The exact request format is documented at the API documentation.

Conversion Happens Locally, Not on a Server

Every case transformation described above runs in your browser's own JavaScript, working directly on the text in the input box. Nothing you paste is sent to a server to be converted, so there's no upload delay and no copy of your text stored anywhere once you navigate away. That also means there's no meaningful limit tied to server processing time — conversion of even a long paste happens as fast as your browser can execute the underlying string operations, which is close to instantaneous for anything short of an extremely large document.

Questions About Converting Text Case

Does the converter recognize an already-formatted variable name like userAccountName as three separate words?

Yes. The word-splitting step specifically looks for the lowercase-to-uppercase boundary inside camelCase and PascalCase text, along with underscores, hyphens, and periods, so it can re-split an already-formatted name into words before applying a different style.

What happens to numbers when I convert a string that contains them?

Digits pass through unchanged in every style, since case conversion only affects letters. A string like "version2Update" still recognizes the word boundary around the letters and keeps the digit attached to whichever word segment it was part of.

Does Sentence case handle multiple sentences in one paste correctly?

Yes. The conversion splits on sentence-ending punctuation first, then capitalizes just the first letter after each split point, so a multi-sentence paragraph gets each sentence capitalized independently rather than only the very first letter of the whole block.

Can I convert text back to its original case after applying a style?

There's no dedicated "undo" style, but since the original text remains in the input box exactly as typed, clearing the output or copying from the input box directly recovers your unconverted text at any point.

Does converting to UPPERCASE or lowercase affect accented letters correctly?

Yes, standard JavaScript case conversion correctly upper- or lower-cases accented Latin letters such as é or ñ, so text in languages that rely on those characters converts the same way plain ASCII text does.

Is there a difference between dot.case and kebab-case besides the separator character?

No structural difference — both lowercase every word and join them with a single separator character, differing only in whether that character is a period or a hyphen. Which one to use depends entirely on the convention the destination system expects, such as a hostname favoring dots and a URL slug favoring hyphens.

Why would I need PascalCase instead of camelCase for what looks like the same name?

The two conventions typically signal different roles in code even though the only difference is whether the first word starts with a capital letter. Many languages and style guides reserve PascalCase for class or type names and camelCase for variables and function names, so picking the right one often matters for readability and convention even when both would technically work.

Related Tools

Before or after reformatting a case, checking the underlying length is often useful — the word counter covers word, sentence, and paragraph totals, while the character counter breaks a string down into letters, digits, punctuation, and byte length. If the destination for converted text is a URL, the slug generator goes a step further than kebab-case alone by also stripping characters that aren't URL-safe. For mocking up a design with placeholder copy in a specific case style, the lorem ipsum generator provides text to convert and test against before real content is ready.