Text Case Converter: camelCase, snake_case and Title Case Explained

Text case is a naming system, and there are more styles than most people can name. The ones you meet daily are UPPERCASE and lowercase, the two extremes; Title Case, which capitalises every word; sentence case, which capitalises only the first; and the two programming styles, camelCase and snake_case, plus their cousins PascalCase, kebab-case and CONSTANT_CASE.

Each style has a home, and the homes are not interchangeable. camelCase belongs to JavaScript variables; snake_case to Python and to most database columns; Title Case to headlines; sentence case to body text. Converting between them is mechanically easy and semantically lossy, which is the whole tension.

Three facts explain nearly every case-related problem. Casing destroys information — uppercase text cannot be restored to its original form, because the capitals of proper nouns are gone. Casing is locale-sensitive — the same letter converts differently in Turkish than in English. And casing styles fight at boundaries — when a camelCase frontend meets a snake_case API, one side must translate, and that translation is a classic bug site.

The rest of this article covers where each style belongs, the naming wars in code and APIs, how to rescue text that arrived in ALL CAPS, the accent and locale traps, bulk conversion for spreadsheets, and the readability question of headlines versus sentence case. If you just need a conversion, the text case converter handles all the common styles in one place.

The Case Styles and Where Each Belongs

Applied to the same phrase, here is what each style produces and where you will find it expected:

The useful skill is not memorising the list but recognising a style on sight and knowing which one the context expects. When a value looks “wrong” in a codebase, a mismatch against this table is usually why.

The Naming Wars: camelCase Versus snake_case

Communities picked their conventions decades ago and never agreed. JavaScript, Java and C# went camelCase for variables because it reads quickly and saves a character. Python, Ruby and the SQL world went snake_case because it is unambiguous and easier to read in long names. Neither choice is wrong; both are entrenched.

The friction appears at the boundary between two systems. A JavaScript frontend sends userName; a Python backend expects user_name. Somewhere in between, a conversion has to happen, and the classic bugs live there: a field converted twice and ending up user_name on both sides of a different boundary, or a key left unconverted so the backend silently receives a field it does not recognise.

• Pick one convention per layer and convert at the boundary, not throughout the code.
• Be explicit about the boundary. A single documented transform between API and storage beats case conversion scattered across the codebase.
• Beware automated renames. Refactoring tools that “fix” casing across a project can break API contracts, because external consumers still send the old field names.

API documentation is the ground truth. Whatever your code style guide says, the wire format is what the other system actually speaks.

Rescuing Text That Arrived in ALL CAPS

A spreadsheet or email in block capitals is a common annoyance, and the fix is a two-step process rather than one button. The reason is that uppercase is destructive: it discards the capitalisation pattern of the original, and no tool can rebuild it from nothing.

The reliable sequence is to convert everything to lowercase first, which is exact and loses nothing further, then apply Title Case or sentence case to get the shape you want. What you then hold is mostly correct — “HELLO WORLD” becomes “Hello World” — with the proper nouns still wrong, because a tool cannot know that “paris” should be “Paris” or that “mcdonald” should be “McDonald”.

That final pass is human, and there is no way around it for text where names matter. For a list of product descriptions or a quick internal note, the automated result is usually good enough; for anything customer-facing, budget two minutes to read it over.

The corollary worth remembering: never uppercase original text you might need later. Keep the original file and work on a copy, because once the capitals are gone, they are gone.

Accents, Locales and the Turkish-i Trap

For plain ASCII text, case conversion is boring and reliable. The moment accents or other scripts are involved, it becomes interesting, because “uppercase” is not a single universal idea.

• Accented Latin letters usually round-trip fine. A modern converter handles é, ü and ñ correctly in both directions.
• The Turkish dotted i. In Turkish, a capital I lowercases to a dotless ı, while an i with a dot uppercases to a capital İ. Apply English rules to Turkish text and you corrupt it silently. The same applies to azeri and a few other locales.
• The German sharp s. The lowercase ß has no single uppercase letter — it becomes SS, two characters. Round-tripping it carelessly changes the string length, which breaks things like fixed-width database fields.
• Scripts without case at all. Arabic, Hebrew, Thai and most other scripts have no upper and lower case, so “convert to uppercase” is a no-op that some tools implement as a silent pass and others as an error.

If your text is Turkish, German, Greek, or any non-Latin script, confirm the tool is locale-aware before trusting the output. A converter that assumes English is fine for English and wrong for everything else.

Bulk Conversion for Spreadsheets and CSV

One cell at a time is not a workflow. The reliable pattern for a whole column is to paste it into a converter that respects line structure, choose the target case, and paste the result back — the key requirement being that the tool treats each line as its own value instead of joining everything into one paragraph.

• Inside a spreadsheet, the functions UPPER(), LOWER() and PROPER() do the job on live data, and have the same proper-noun weakness as any Title Case.
• Check the row count before and after. A tool that drops empty lines or merges wrapped rows will quietly desynchronise your column, and the error only shows up when someone reads the wrong value.
• Keep the original column until you have verified the result. Bulk operations are exactly the size where a small mistake becomes a large one.

For a CSV bound for an import, confirm the case convention the receiving system expects first. Many e-commerce and ERP systems treat column headers case-sensitively, so a header row converted to Title Case can make an otherwise valid file fail to import.

Headlines Versus Sentence Case for Readability

Style guides disagree, but the practical split is simple. Use Title Case where each word is a unit of emphasis: article headlines, book and film titles, buttons, and short menu labels. Use sentence case for anything someone reads as prose: body text, descriptions, error messages, tooltips.

The reasoning is about how the eye moves. In a five-word headline, capitalising each word helps the reader parse it as a title. In a paragraph, capitals on every word interrupt the flow and read as shouty or formal, the visual equivalent of someone talking too loudly.

Style guides also disagree on the small words: most capitalise only words above three or four letters, so “the” and “in” stay lowercase in a title. Automated Title Case converters usually capitalise everything, which is why a generated headline often needs a quick check against the style you follow.

If you take one rule: consistency beats correctness of any particular style. A page that mixes Title Case and sentence case headings looks broken even when each individual heading is defensible.

Convert Text Case Without the Guesswork

Whatever style you need, the conversion should be one paste away:

• A free text case converter covering UPPERCASE, lowercase, Title Case, sentence case, camelCase, snake_case and more.
• Handles multi-line text, so a whole column converts in one paste.
• Runs entirely in your browser — nothing you paste is uploaded.
• Part of the wider string tools set: word counter, character counter, URL encoder and Base64 encoder.

Frequently Asked Questions