Case Converter

Convert text to UPPERCASE, lowercase, Title Case, camelCase, snake_case and more — instantly.

0 words0 chars

How to use the Case Converter

  1. Paste or type your text. Drop any text into the input box — a headline, a code identifier, a sentence or an entire paragraph.
  2. Click a case button. Choose the format you need: UPPERCASE, Title Case, camelCase, snake_case and more.
  3. Copy and use. Hit Copy to send the transformed text to your clipboard, ready to paste anywhere.

Why use our Case Converter

Ten transforms in one place. UPPERCASE, lowercase, Title Case, Sentence case, camelCase, snake_case, kebab-case, CONSTANT_CASE, aLtErNaTiNg and iNvErSe — all in a single tool.
Instant, in-place conversion. Click a button and the text in the editor transforms immediately. No page reloads, no waiting.
Copy ready to paste. One-click copy sends your transformed text straight to the clipboard.

Free to use — premium coming soon

FREE
  • Ten case transformations
  • Live character and word count
  • One-click copy
PREMIUM
  • Remove ads
  • Batch file conversion
  • Save transform presets

About the Case Converter

The Case Converter rewrites the capitalization of any text you paste in, without changing the words themselves. Drop in a paragraph, a headline, a column of data, or a list of variable names and switch instantly between UPPERCASE, lowercase, Title Case, Sentence case, camelCase, snake_case and kebab-case. It exists because retyping text by hand to fix capitalization is slow and error-prone, and because different contexts demand different conventions: a press headline wants Title Case, a database column wants snake_case, and a CSS class or URL slug wants kebab-case. One paste, one click, and the formatting is consistent throughout.

Reach for it whenever capitalization is wrong or inconsistent. Writers and marketers use it to clean up headlines, social posts and email subject lines, or to tame text that arrived in ALL CAPS. Developers use it to flip identifiers between the styles each language expects: JavaScript and Java favour camelCase, Python and SQL columns favour snake_case, and HTML class names and URLs favour kebab-case. Students and office workers use it to normalise notes, spreadsheets and document headings before publishing. Because it only touches letter case and word separators, the meaning of your content is never altered.

Each mode follows a defined rule rather than a guess. UPPERCASE and lowercase map every letter; Sentence case capitalises the first letter after each sentence-ending punctuation mark and lowercases the rest. Title Case capitalises the principal words while keeping short articles, conjunctions and prepositions lowercase (note that style guides differ: AP capitalises prepositions of four or more letters, while Chicago keeps almost all prepositions lowercase). The programming modes first split text into words, then rejoin them: camelCase removes spaces and capitalises every word except the first, snake_case joins lowercase words with underscores, and kebab-case joins lowercase words with hyphens.

Everything runs entirely in your browser using JavaScript string operations, so your text is never uploaded to a server, stored, or logged. That makes it safe for confidential drafts, internal data and unpublished copy. Because the transformation is rule-based and local, results are instant and identical every time, with no API limits or network delay. One accuracy caveat worth knowing: automatic Title Case cannot know your proper nouns, acronyms or brand-specific styling, so after converting a heading it is worth a quick scan to confirm names like iPhone or NASA read the way you intend.

Frequently asked questions

What is the difference between Title Case and Sentence case?

Title Case capitalises the first letter of each major word, which suits headlines and titles. Sentence case capitalises only the first word of each sentence (plus proper nouns), the way ordinary prose is written.

What are camelCase, snake_case and kebab-case used for?

They are programming naming conventions. camelCase (firstName) is common in JavaScript and Java, snake_case (first_name) is standard in Python and database columns, and kebab-case (first-name) is used for CSS class names and SEO-friendly URL slugs.

Does converting case change the actual words or spelling?

No. The tool only changes letter capitalization and, for the programming modes, the separators between words. The words and their order stay exactly the same; nothing is added, removed or corrected.

Is my text sent to a server or stored anywhere?

No. All conversion happens locally in your browser with JavaScript, so the text never leaves your device and nothing is saved or logged. It is safe for private or unpublished content.

Why does Title Case sometimes leave small words lowercase?

By convention, short articles, conjunctions and prepositions (such as a, the, and, of, to) stay lowercase unless they begin the title. This follows standard style guides, though AP and Chicago differ on how long prepositions are treated, so review the result for your preferred style.

From our blog

How to Read, Fix, and Shrink JSON: A Practical Formatter Guide

By the Super Simple Digital Tools Team · Updated June 2026

JSON is everywhere in modern development, but it almost never arrives in a form you can read. API responses, webhook payloads, and minified config files tend to be a single dense line, and the moment the structure gets nested more than a level or two, scanning it by eye becomes guesswork. A formatter solves the first half of the problem by re-indenting that line into a tidy tree where every key sits at the depth it belongs to. The second half, validation, tells you whether the text is even legal JSON before you waste time debugging the wrong thing.

Start by pasting your text and formatting it. If it beautifies cleanly, the JSON is well-formed and you can read off the structure: objects in curly braces, arrays in square brackets, and indentation showing what is nested inside what. If formatting fails, the tool stops at the first syntax error and tells you the line and column. That location is the fastest path to a fix, because JSON parsers fail at the exact character where the grammar breaks, not at the conceptual mistake somewhere above it.

Most validation failures come down to a short list of habits borrowed from JavaScript or Python. Trailing commas are the number one offender: a comma after the last array element or object property is fine in JavaScript but illegal in JSON. Single quotes are second; JSON requires double quotes for every string and every key, with no exceptions for simple alphanumeric names. Comments are third, since JSON has no comment syntax at all. Knowing these three rules resolves the large majority of the errors people hit when writing JSON by hand.

Once your JSON is valid, minification is the inverse operation. The tool walks the parsed structure and writes it back with no spaces, no newlines, and no indentation, producing the smallest faithful representation of the same data. This is what you want when embedding JSON in a query string, a single-line environment variable, or a request body where every byte counts. Because both directions work from the same parsed tree, you can beautify to inspect, edit, and then minify again without any risk of the formatting step altering your values.

One thing a formatter does not do is judge whether your JSON is correct for its purpose. Syntactic validity only means the text follows the grammar; it says nothing about whether a field is named the way your API expects, whether a date string is in the right format, or whether a number is within an allowed range. Those are semantic concerns, and they belong to JSON Schema validation or to your application's own checks. Treat the formatter as the first gate that catches broken syntax cheaply, then layer schema validation on top when correctness of content matters.

  • If validation fails, look at the line just above the reported position first; a missing comma or an unclosed bracket often shows up as an error on the next token.
  • When pasting an API response from DevTools or curl, beautify it immediately so deeply nested fields become easy to trace before you start editing.
  • Use minify for values you have to fit on one line, such as a JSON-typed environment variable or a config field, but keep a beautified copy for editing.
  • If you need trailing commas or comments for readability, you are working in JSON5 or JSONC, not JSON; strip them before sending the data to a strict parser.

Read the full guide →

Tool by the Super Simple Digital Tools Team. Reviewed by our editorial team. Free to use, no signup required.

Related tools