DanfioSearch tools/

Type a tool name, a pinyin spelling or a synonym - both languages are searched.

Case Converter & Text Cleaner

Global tools

Paste a heading, a sentence, a variable name or a whole document and this page writes it in any of twelve cases - lowercase, UPPERCASE, Title Case, Sentence case, camelCase, PascalCase, snake_case, kebab-case, CONSTANT_CASE, Train-Case, alternating case and inverse case - while you type. Every case is shown beside the others applied to the same words, so you can see what `PascalCase` does to your sentence without asking for it and undoing it.

Case Converter & Text Cleaner - Danfio

https://danfio.com/tools/case-converter/ - printed from this page

Everything happens in this tab as you type, and the sample above carries a non-breaking space, a zero-width space and a curly apostrophe on purpose - the cleaner has something to report on.

The four letter cases change letters and keep the punctuation, the spacing and the line breaks. The six code cases rebuild the text out of words and join them, so the punctuation between words cannot come along.

Chicago headline style keeps a preposition small however long it is, which is where the other style disagrees. The list is printed under the table.

A zero-width space, a byte-order mark, a soft hyphen or a word joiner: invisible characters that came out of a copy and paste and make two identical-looking lines unequal. A zero-width joiner is never removed.

A non-breaking space, a thin space, two spaces in a row, a tab in the middle of a line, a space at the end of a line. The indentation at the start of a line is never touched.

Curly quotes are a different character from the ones on your keyboard, which is why a search for a quoted phrase finds nothing in text pasted out of Word. This switch is the direction, and nothing is changed unless you ask.

A line break inside a sentence is what an email client, a PDF or a text editor inserts when it wraps at 72 characters or at the width of a page. Unwrapping puts those back into spaces and leaves the blank lines between paragraphs alone.

Leave it blank and the files are named after the case you chose, so "title-case.txt" and "title-case-report.txt".

Results update as you type. Nothing leaves your device.

Characters changed

114

Title Case: 40 words, 227 characters in and 224 out. The text itself is in the box below.

Words
40 the pieces the split table lists
Characters in
227 code points
Characters out
224
Sentences
3
Lines
4
Cleanup fixes
4 5 kinds of thing found

The same text, in every case

The caseThe first six wordsCharacters
lowercasehttpserver responses are cached for 24224
UPPERCASEHTTPSERVER RESPONSES ARE CACHED FOR 24224
Title Case - this is the one aboveHTTPServer Responses Are Cached for 24224
Sentence caseHTTPServer responses are cached for 24224
camelCasehttpServerResponsesAreCachedFor24HoursTheStateOfTheArtParserReadsHtml5…179
PascalCaseHttpServerResponsesAreCachedFor24HoursTheStateOfTheArtParserReadsHtml5…179
snake_casehttp_server_responses_are_cached_for_24_hours_the_state_of_the_art_par…218
kebab-casehttp-server-responses-are-cached-for-24-hours-the-state-of-the-art-par…218
CONSTANT_CASEHTTP_SERVER_RESPONSES_ARE_CACHED_FOR_24_HOURS_THE_STATE_OF_THE_ART_PAR…218
Train-CaseHttp-Server-Responses-Are-Cached-For-24-Hours-The-State-Of-The-Art-Par…218
aLtErNaTiNg casehTtPsErVeR rEsPoNsEs ArE cAcHeD fOr 24224
iNVERSE cASEhttpsERVER RESPONSES ARE CACHED FOR 24224
Six words are shown because twelve cases of a whole document is a wall of text; the character count is of the whole text, so that is the column that shows what a case costs or saves.
The cleanup settings on the form are the same for every row: this table is about the case and nothing else.
The small words left small in Title Case are: a, an, the, and, but, for, nor, or, so, yet, although, as, because, if, since, than, that, though, unless, until, when, whenever, where, whereas, whether, while, whilst, about, above, across, after, against, along, alongside, amid, amidst, among, amongst, around, at, before, behind, below, beneath, beside, besides, between, beyond, by, despite, down, during, except, from, in, inside, into, like, near, of, off, on, onto, out, outside, over, past, per, regarding, round, through, throughout, till, to, toward, towards, under, underneath, unlike, up, upon, via, versus, vs, with, within, without.

The character count falls for two different reasons: a code case drops the punctuation and the spaces between words, and UPPERCASE can be wider or narrower depending on the letters the text uses.

The converted text

HTTPServer Responses Are Cached for 24 Hours. The State-of-the-Art Parser Reads HTML5 and Never Minds Don’t-Style Apostrophes.

A Line that Was Hard-Wrapped by an
Email Client Belongs in One Paragraph with a “Quoted” Phrase.

Copy it, or download it. The punctuation, the spacing and the line breaks are where they were, because a letter case changes letters and nothing else.

How this text was split into words

WordAs it appearsWhy it starts a new word
HTTPHTTPThe first word of the text
ServerServerA run of capitals followed by a small word (`HTMLResponse` splits before `Response`)
responsesresponsesA space, a line break or punctuation before it
areareA space, a line break or punctuation before it
cachedcachedA space, a line break or punctuation before it
forforA space, a line break or punctuation before it
2424A space, a line break or punctuation before it
hourshoursA space, a line break or punctuation before it
TheTheA space, a line break or punctuation before it
statestateA space, a line break or punctuation before it
ofofA space, a line break or punctuation before it
thetheA space, a line break or punctuation before it
artartA space, a line break or punctuation before it
parserparserA space, a line break or punctuation before it
readsreadsA space, a line break or punctuation before it
HTML5HTML5A space, a line break or punctuation before it
andandA space, a line break or punctuation before it
neverneverA space, a line break or punctuation before it
mindsmindsA space, a line break or punctuation before it
dontdon’tA space, a line break or punctuation before it
stylestyleA space, a line break or punctuation before it
apostrophesapostrophesA space, a line break or punctuation before it
AAA space, a line break or punctuation before it
linelineA space, a line break or punctuation before it
thatthatA space, a line break or punctuation before it
waswasA space, a line break or punctuation before it
hardhardA space, a line break or punctuation before it
wrappedwrappedA space, a line break or punctuation before it
bybyA space, a line break or punctuation before it
ananA space, a line break or punctuation before it
The first 30 of 40 words: the table is cut off so it stays readable, and the report carries all of them.
A word is a run of letters and digits, with an apostrophe allowed inside it. Everything else - a space, a line break, an underscore, a hyphen, a dot, a slash, a comma, a bracket, an emoji - separates one word from the next, which is why `state-of-the-art` and `state_of_the_art` produce the same identifier.

Read this table when a code case surprises you. `parseHTMLResponse` becomes `parse_html_response` because a capital after a small letter, and a capital run in front of a small word, are both word boundaries - and `HTTPSERVER` in one word cannot be split at all, because there is nothing there to see.

What the cleaner found

What is in the textHow manyWhat this page did
Invisible characters1Removed
Odd spaces3Replaced with single ordinary spaces
Curly quotes, dashes and ellipses3Left in place
Line breaks inside a sentence1Left in place
Runs of blank lines1Left in place
Also looked for and not found: whitespace at the very start or end, lines that start with a space or a tab.
The count is what was in the paste, not what was changed: switching one of the fixes off changes the third column and nothing else.

Half of why anybody opens a cleaner is to find out what is in the text rather than to change it, so a fix that is switched off still reports its number.

Where those characters come from

  • Invisible characters: A zero-width space, a byte-order mark, a soft hyphen or a word joiner. They come from a copy and paste, and they are why two lines that look identical are not equal. Removing one joins the letters around it, which is usually the point: it is invisible, so it was breaking a word that looks whole. A zero-width joiner is deliberately not on the list - it holds an emoji family together and Indic scripts need it.
  • Odd spaces: 1 were not the space bar (a non-breaking space, a thin space, an em space), 1 were two or more spaces in a row, 0 were tabs away from the start of a line, and 1 were spaces at the end of a line. Whitespace at the start of a line is never touched: that is indentation, and it is how a paste of code survives this page.
  • Curly quotes, dashes and ellipses: A word processor writes curly quotes, an apostrophe shaped like one, an em dash and three dots as a single character. In code they are all different characters from the ones on your keyboard, which is why a search for a straight-quoted word finds nothing in a page that holds the curly form. This text holds 3 curly quotes, 0 typographic dashes and 0 ellipses.
  • Line breaks inside a sentence: A line break in the middle of a sentence is what an email client, a PDF or a text editor does when it wraps at 72 characters or at the width of a page. Unwrapping turns those back into spaces and leaves the blank lines that separate real paragraphs alone.
  • Runs of blank lines: Two or more blank lines where one would do, which is what a paste out of a document with headings and images in it usually brings along.

What the numbers do not say

  • The text holds 40 words, and where each one starts is a decision: a capital after a small letter (`parserReads`), a capital run in front of a small word (`HTMLResponse`), a digit next to a letter while the switch above says so, and everything that is not a letter or a digit. The table under the result prints all of them with the reason, so a code case never has to be taken on trust.
  • Title Case is the list of small words plus three exceptions, all of it printed under the table above: a small word is capitalized when it opens the title, when it closes it, and when it follows a colon or another sentence end inside the title. "A Tale of Two Cities" is that rule, and "A Tale Of Two Cities" is the other setting.
  • A word that arrives with a shape of its own is left exactly as it was, which is how `iPhone`, `macOS`, `API`, `USA` and `HTML5` survive. A word written entirely in capitals is read as an acronym while it is short and as shouting once it is long, and in a text that is in capitals throughout every word is re-cased - which is the only way a title in capitals can be converted at all.
  • Names are not detected: an apostrophe does not start a new word, so `o’brien` comes out as `O’brien`. A hyphen does, so `state-of-the-art` is capitalized in every part - "State-of-the-Art", which is what Chicago does with a compound in a title.
  • The cleaner reports before it fixes, and it is conservative about two things it never touches: the whitespace at the start of a line, which is indentation, and the zero-width joiner, which holds an emoji family together and which some scripts need. In this text the settings were: invisible characters removed, odd spaces replaced with ordinary spaces, quotes left in place, line breaks left as they are.
  • Curly quotes are a direction rather than a fix: straightening them is what pasting into code needs, and curling them is what a text editor calls smart quotes. The one decision that needs context is the apostrophe, and it is made by looking at the neighbors: a quote between two letters closes a word, so a straight `don't` becomes `don’t` rather than `don‘t`.
  • Not included, on purpose: no language detection, so casing follows the Unicode default and is English-shaped; no transliteration or accent stripping, so `café` stays `café` even in kebab-case, because a URL slug is a different job; no acronym dictionary, so a word typed in small letters is never guessed into capitals; and no stemming, so nothing here decides that `count` and `counts` are one word.
Converted in this tab by the same function that produced the text already in the page you loaded, so nothing was sent anywhere - and there is no endpoint behind this page that could accept a paste even if something tried to send one.

The same page cleans what a copy and paste brings along: a non-breaking space that looks exactly like a space, a zero-width space that makes two identical lines unequal, a soft hyphen, doubled spaces, spaces at the end of a line, curly quotes, and the line breaks an email client inserts when it wraps at 72 characters. Nothing is uploaded, and the cleaner reports what it found before it changes anything - including when you tell it to leave something alone.

About this case converter & text cleaner

Casing looks trivial until a heading has to become a variable name and an acronym has to survive it. This page writes one piece of text in twelve cases - Title, Sentence, camelCase, snake_case, CONSTANT_CASE and the rest - side by side, so the effect of a case on your own words is visible before you commit to it.

Nothing is uploaded, and the cleaning is where the privacy matters: a paste often carries a non-breaking space, a zero-width space or a soft hyphen that looks identical to the eye and breaks a comparison, and the tool reports each one before it touches it. All twelve conversions run client-side in your browser, so a draft or a variable name never reaches a server at all.

A case converter is a spelling of letters, not a grammar checker or a style guide: it changes how words are written and leaves their meaning, their order and their punctuation alone. When two cases could both be right, the page shows all of them and lets you pick rather than guessing for you.

How this case converter & text cleaner works

Where a word ends, which is the whole of the code cases

A case like `snake_case` cannot be produced by changing letters: it has to know where one word ends and the next begins, and the answer is not spaces. `parseHTMLResponse` is three words, `HTTPServer` is two, `don’t` is one, `state-of-the-art` is four, and a page that only splits at spaces turns each of them into a single long token - which is where the surprises in other converters come from.

This page splits on four things: everything that is not a letter or a digit (a space, a line break, an underscore, a hyphen, a dot, a slash, a comma, a bracket, an emoji), a capital letter after a small one, a capital at the end of a run of capitals when a small word follows it, and a digit beside a letter when the switch says so. All four are printed word by word under the result, with the reason each word starts where it does, so you can check the split rather than trust it.

Four letter cases and six code cases

The four letter cases change letters and keep everything else: `lowercase` and `UPPERCASE` change every letter, `Title Case` capitalizes each word, and `Sentence case` capitalizes the first letter of each sentence. The punctuation, the spacing, the quotes and the line breaks come through untouched, which is what makes them safe on prose.

The six code cases rebuild the text out of those words and join them with nothing, an underscore or a hyphen. That is exactly what an identifier needs, and it is why the punctuation between words cannot come along: `Hello, world!` is `hello_world` in snake_case, and an apostrophe is dropped rather than turned into part of an identifier. `alternating case` and `iNVERSE cASE` are the two that work letter by letter, one for a joke and one for repairing a caps-lock accident.

Title case is a style, not an operation

There is no such thing as the title case of a sentence, which is why the switch beside it exists. The page follows Chicago headline style: every article, every conjunction and every preposition stays small however long it is (`A Tale of Two Cities`, `The Road between Two Cities`), with three exceptions - a small word is capitalized when it opens the title, when it closes it, and when it follows a colon or another sentence end inside the title. The other setting capitalizes every word, which is what AP style does with a preposition of four letters or more. The whole list is printed on the page.

A word that arrives with a shape of its own is left exactly as it was, which is how `iPhone`, `macOS`, `API`, `USA` and `HTML5` survive a title case. A word written entirely in capitals is read as an acronym while it is short and as shouting once it is long, and in a text that is in capitals throughout every word is re-cased - the only way "THE QUICK BROWN FOX" can be converted at all, since every word in it looks like an acronym.

Sentence case, and the one rule it does not share

Sentence case lowers everything and then capitalizes the first letter of each sentence. It finds sentence ends with the same abbreviation list as the word counter next door, so `Mr. Smith`, `Fig. 3`, `e.g.` and a stop between two digits (`3.14`) do not start a sentence. What it does not share is the counter's other rule: for a count, a stop followed by a small word is read as continuing the sentence (`see index.html for`), which is the conservative answer when a number is at stake and a useless one here, because the text is small precisely because it is being converted.

A word that arrives as an acronym keeps its capitals, so `NASA` and `iPhone` come through unharmed, and the English pronoun `I` is capitalized in all four of its contractions. The switch under the case decides whether the start of every line counts as a sentence start as well: a list of bullet points wants that, and a paragraph an email client hard-wrapped must not have a capital in the middle of every line.

What a paste brings along, and what the cleaner refuses to touch

Text pasted out of Word, a PDF or a web page carries characters nobody can see: a non-breaking space (which is not the space bar, and which fails every search and comparison), a zero-width space at the end of a line, a soft hyphen where the document hyphenated a word, a byte-order mark, a word joiner. Then there are doubled spaces, spaces at the end of a line, curly quotes that are different characters from the ones on your keyboard, and the line breaks an email client inserts at 72 characters. Each of those has a switch, and the table under the result says how many of each were found and what the settings did about it.

Two things are never touched, on purpose. Whitespace at the start of a line is indentation: it is how a list, an outline or a block of code shows its shape, and a cleaner that collapses it is rewriting the document rather than cleaning it. And a zero-width joiner is not noise: it holds an emoji family together and some scripts need it, so it stays. The cleaner is a measuring instrument as much as a tool - the counts it prints are of what was in the paste rather than of what it changed, so switching a fix off tells you what you were carrying instead of hiding it.

Worked examples

Each example below was run through the calculator on this page when the site was built, so the numbers match what you see when you enter the same inputs.

A heading in capitals, converted to a title

The text to convert: THE QUICK BROWN FOX JUMPS OVER THE LAZY DOG · What to convert it to: Title Case - each word capitalized, small words left small

Characters changed

28

Title Case: 9 words, 43 characters in and 43 out. The text itself is in the box below.

Words: 9 · Characters in: 43 · Characters out: 43 · Sentences: 1

Every word in capitals is re-cased and the prepositions stay small: a text written in capitals throughout switches the acronym rule off, which is the only way this conversion can work at all.

A sentence turned into a Python identifier

The text to convert: Parse the HTMLResponse from HTTPServer · What to convert it to: snake_case - words joined with underscores, all small

Characters changed

33

snake_case: 7 words, 38 characters in and 40 out. The text itself is in the box below.

Words: 7 · Characters in: 38 · Characters out: 40 · Sentences: 1

The split is the whole story: `HTMLResponse` gives `html_response` because a capital run in front of a small word is a boundary, and `HTTPServer` gives `http_server`.

A paste out of Word, cleaned and given a sentence case

The text to convert: a “smart” quote from Word… · What to convert it to: Sentence case - the first letter of each sentence, the rest small · Quotes and dashes: Straighten them for code (the ones on your keyboard)

Characters changed

27

Sentence case: 5 words, 28 characters in and 28 out. The text itself is in the box below.

Words: 5 · Characters in: 28 · Characters out: 28 · Sentences: 1

Two doubled spaces collapsed, two curly quotes straightened and an ellipsis turned back into three dots, then the first letter capitalized - and the count of each is in the table under the result.

An email someone wrapped at 72 characters

The text to convert: one two three four five six · What to convert it to: lowercase - every letter small, punctuation kept · Line breaks: Unwrap hard-wrapped lines, keep the paragraphs

Characters changed

1

lowercase: 6 words, 28 characters in and 28 out. The text itself is in the box below.

Words: 6 · Characters in: 28 · Characters out: 28 · Sentences: 1

The break inside the sentence becomes a space and the blank line stays, which is what turning a hard-wrapped email back into paragraphs means.

Frequently asked questions

Which case should a title use?

That depends on the style guide you are writing to, and the page therefore refuses to choose. Chicago headline style keeps every article, conjunction and preposition small however long it is, so `the road between two cities` becomes "The Road between Two Cities"; AP style capitalizes prepositions of four letters or more, so the same title becomes "The Road Between Two Cities". Both are on the form, the list of small words is printed under the table, and the one thing the page does not do is disguise the choice as arithmetic.

Why is my camelCase not what I expected?

Almost always because of where the words were cut. The table under the result prints every word with the reason it starts there, and the two that surprise people are acronym runs and digits. `parseHTMLResponse` becomes `parseHtmlResponse` rather than `parseHTMLResponse`, because a linter that enforces camelCase wants the acronym run re-cased; and `HTML5` stays one word unless the digit switch is moved, in which case it becomes `html_5`.

Is anything I paste sent anywhere?

No. The whole tool follows one fixed rule applied to a string: it runs in your browser as you type, and the same rule ran when the page was prepared, so the conversion is already inside the page you loaded. There is no upload button because there is no upload, and there is no endpoint behind this page that could accept a document even if something tried to send one. A draft under embargo can be pasted here.

What does the cleaner do about characters I cannot see?

It counts them and names them. Non-breaking spaces, zero-width spaces, soft hyphens, byte-order marks, word joiners, doubled spaces, tabs in the middle of a line, spaces at the end of a line, curly quotes, typographic dashes, ellipses and hard-wrapped line breaks are each looked for, and the table says how many were there and what the settings did about it. Nothing is removed without a switch, and the counts are of the paste rather than of the change, so the page can be used to inspect a document as well as to fix one.

Why does it not capitalize the name after Mr.?

Because the rule that keeps `Mr. Smith` in one sentence is the same rule that decides where sentences start, and a stop after a known abbreviation does not end one. So `mr. smith arrived.` comes out as `Mr. smith arrived.`: the sentence is right and the name is not. Every tool of this kind has to draw that line somewhere without a dictionary, and this page draws it in the open and prints the list of abbreviations it uses.

Can it make a URL slug?

It does the case half: kebab-case turns `Ten Ways to Clean Up Text` into `ten-ways-to-clean-up-text`, and the cleaner removes the odd spaces and the invisible characters first. What it deliberately does not do is the other half of slugging - transliterating accents (`café` stays `café`), dropping stop words, or cutting the result at a word boundary - because those are editorial decisions about a URL rather than a change of case, and doing them silently here would be the wrong shape of tool.

What happens to emoji and to other alphabets?

An emoji is a separator and never part of a word, so it is dropped by the code cases and left exactly where it is by the letter cases. Letters outside the Latin alphabet are letters: `café` and `naïve` are one word each, CJK text has no spaces to split at, and casing follows the Unicode default, so `İ` and `ß` behave the way Unicode says they should. That is worth knowing before converting a Turkish or German document, because this page does not detect the language and does not pretend to.

Does inverse case repair a caps-lock accident?

Yes, when the whole text was typed with caps lock on: every letter is swapped, so capitals become small and small letters become capitals, and applying it twice gives the original text back. For a text where only part of the accident happened it is a blunt tool - there is no undo history here and no way to tell which letters were meant to be capitals - so the letter cases and the report are usually the better answer.

Assumptions and sources

  • The twelve cases follow the usual conventions: snake_case, kebab-case, CONSTANT_CASE, Train-Case, camelCase, PascalCase, title case (Chicago or AP) and sentence case.
  • Nothing is guessed about the language: no translation, no accent stripping and no acronym dictionary, so the words stay yours.
  • Cleaning only removes stray invisible characters and doubled spaces; everything runs in your browser and nothing is uploaded.

Last reviewed 2026-09-17. Runs locally on your device; keep backups; no financial advice applies. Read the full disclaimer.

Where a figure on this page comes from an official agency — HUD, IRS, FICO or a state body — the site keeps a dated snapshot of the source page in its sources library, and a scheduled job re-checks that snapshot, so the number can be traced back to the document it came from.

Related tools

Word & Character CounterText & WritingCount words, characters, sentences and paragraphs as you type: reading time, word frequency, and the two rules that make counters disagree. Nothing is uploaded.Count words and characters →Regex Tester & ReplacerDeveloper ToolsTest a JavaScript regular expression against your own text: every match with its groups and positions, what each flag does, and how it runs in Python or PCRE.Test a regex →Minifier & BeautifierDeveloper ToolsMinify or beautify CSS and HTML in your browser: comments, whitespace and two safe shortenings, with an honest list of what it will not touch. No upload.Minify or beautify code →Base64 Encoder & DecoderDeveloper ToolsEncode text to base64 or decode it back, in your browser, with the standard and URL-safe alphabets, UTF-8 handled properly, percent-encoding and data URLs too.Encode or decode Base64 →Acronym GeneratorText & WritingTurn a phrase into an acronym of first letters, with a letter-by-letter table of where each initial came from. Deterministic, private, honest about trademarks.Make an acronym →Business Name GeneratorText & WritingTurn a few keywords into business name ideas, usernames and hashtags. Six naming shapes, seeded so the list reproduces, and no false claims about availability.Generate business names →