Tinker Tools

Text Case Converter Instantly

Convert text between UPPERCASE, lowercase, Title Case, camelCase, snake_case and more with one click.

Input0 characters
Result — UPPERCASE

How it works

1. Enter Your Text

Type or paste any text into the input field. The tool accepts text of any length and from any language.

Paste Anything

2. Choose Case Mode

Select from 10 conversion modes in the sidebar. The result updates instantly as you switch between modes.

10 Modes

3. Copy the Result

Click the Copy button to copy the converted text to your clipboard. Use it in your code, documents, or anywhere else.

One-Click Copy

What is Text Case Conversion?

Text case conversion is the process of transforming text from one capitalization style to another. This covers everyday styles like uppercase and lowercase, but it also includes programming-specific conventions that dictate how multi-word identifiers are written. CamelCase joins words together with each new word capitalized -- getElementById, fetchUserData. Snake_case separates words with underscores and keeps everything lowercase -- get_element_by_id, fetch_user_data. Kebab-case uses hyphens -- get-element-by-id, fetch-user-data. PascalCase is like camelCase but with the first letter also capitalized -- GetElementById, FetchUserData. Each convention exists because specific languages, frameworks, and ecosystems adopted them as standard, and mixing conventions within a codebase creates confusion.

The reason case conventions matter so much in programming goes beyond aesthetics. Many systems treat case differences as meaningful. File systems on Linux are case-sensitive -- config.json and Config.json are two different files. CSS class names are case-sensitive in HTML5. Database column names may or may not be case-sensitive depending on the collation setting. JavaScript object keys are always case-sensitive. A typo in casing is one of the most common sources of bugs that linters and compilers do not always catch, especially across system boundaries where a JSON key from an API needs to map to a database column that uses a different convention.

Title Case is another important style that follows specific rules depending on which style guide you use. AP style capitalizes all words except short prepositions, articles, and conjunctions (unless they start the sentence). APA style capitalizes words of four or more letters. Chicago style capitalizes the first and last words and all major words. These differences mean that the phrase 'a guide to the best practices' would be capitalized differently under each standard. A good text case converter lets you choose which rules apply, or at minimum follows the most widely used convention for title capitalization.

Key Features and Benefits

  • Standard Case Transformations — Convert between UPPERCASE, lowercase, Title Case, and Sentence case with a single click. These cover the majority of everyday text needs -- formatting headings, normalizing user input, preparing display text. The transformations handle Unicode correctly, so accented characters like e with acute become E with acute in uppercase, and German sharp s (ss) follows locale-aware rules.
  • Programming Case Conventions — Switch between camelCase, PascalCase, snake_case, kebab-case, SCREAMING_SNAKE_CASE, and dot.case. Each maps to common usage: camelCase for JavaScript variables and functions, PascalCase for classes and React components, snake_case for Python and Ruby, kebab-case for CSS classes and URL slugs, SCREAMING_SNAKE_CASE for constants, and dot.case for configuration keys in some frameworks.
  • Intelligent Word Boundary Detection — The converter identifies word boundaries even in strings that lack obvious separators. Input like getUserData is recognized as three words -- get, User, Data -- by detecting transitions from lowercase to uppercase. Strings with underscores, hyphens, spaces, or dots are split at those delimiters. This means you can paste a camelCase variable name and convert it directly to snake_case without manually adding separators first.
  • Batch Conversion for Multiple Lines — Convert an entire list of strings at once rather than one at a time. Paste a column of variable names or CSS classes, apply the conversion, and get back the full list in the new format. This is a huge time saver during refactoring -- renaming 50 Python functions from camelCase to snake_case by hand is tedious and error-prone. Batch conversion handles it in seconds with consistent results.
  • Preservation of Acronyms and Special Terms — Good converters recognize common acronyms like HTTP, URL, API, and ID and handle them sensibly. Converting httpURLConnection to snake_case should produce http_url_connection, not h_t_t_p_u_r_l_connection. Similarly, converting to PascalCase should yield HttpUrlConnection rather than Httpurlconnection. Acronym-aware conversion prevents garbled output that defeats the purpose of standardization.
  • Preview Before Applying — See the converted result before committing to any changes. This preview step is valuable when you are unsure how a particular input will be handled -- especially with mixed-format strings that contain numbers, special characters, or unusual spacing. You can try different case styles on the same input and compare the outputs side by side to pick the one that best fits your needs.

How to Convert Text Case

  1. 1

    Enter Your Source Text

    Type or paste the text you want to convert. This can be anything from a single variable name to a full paragraph. If you are converting programming identifiers, paste one per line for batch processing. If you are converting prose -- say, reformatting a headline -- paste the full sentence or phrase. The converter accepts any mix of characters, though the output quality depends on how well it can detect word boundaries in your input.

  2. 2

    Select the Target Case Style

    Choose the case convention you need from the available options. For prose, the common choices are uppercase, lowercase, title case, and sentence case. For code, pick from camelCase, PascalCase, snake_case, kebab-case, or CONSTANT_CASE. If you are converting between programming conventions -- say, from a Python snake_case API response to JavaScript camelCase variables -- the converter handles the word splitting and rejoining automatically.

  3. 3

    Review the Converted Output

    Examine the result carefully. Check that acronyms were handled correctly, that numbers in the middle of identifiers did not cause odd breaks, and that special characters were preserved or removed as expected. For title case, verify that articles and short prepositions are lowercased according to your preferred style guide. If anything looks wrong, try a different case style or manually adjust the input to help the converter detect word boundaries better.

  4. 4

    Copy the Result

    Click the copy button to place the converted text on your clipboard. For batch conversions, the entire output list is copied at once with one entry per line. Paste the result into your code editor, CMS, spreadsheet, or wherever you need it. If you are updating variable names in code, remember to use your editor's find-and-replace (or a refactoring tool) to change every occurrence -- missing one reference will break your build.

  5. 5

    Verify in Context

    After pasting the converted text into its destination, do a quick sanity check. In code, run your linter or compiler to catch any case-related issues. In prose, read the converted text aloud to make sure the capitalization feels natural. Title case is especially tricky -- automated conversion sometimes capitalizes words that should stay lowercase based on context, or misses proper nouns that should always be capitalized regardless of position.

Expert Tips for Text Case Conversion

When migrating between API conventions -- say, a Rails backend returning snake_case JSON and a React frontend expecting camelCase -- do not convert manually. Use a serialization layer that handles it automatically. Libraries like camelcase-keys and snakecase-keys in JavaScript, or Pydantic's alias generators in Python, convert entire nested objects recursively. This is safer than string replacement because it handles edge cases like keys that contain numbers (user2_name becomes user2Name, not user2_name). The text case converter is still useful for one-off checks and debugging, but automated conversion should live in your code.

CSS naming conventions have strong opinions about case. The BEM methodology -- Block, Element, Modifier -- uses a specific pattern with double underscores and double hyphens: block-name__element-name--modifier-name. Tailwind CSS uses kebab-case for utility classes. CSS Modules often use camelCase because JavaScript cannot access hyphenated property names with dot notation -- styles.myClass works but styles.my-class requires bracket notation. If you are generating CSS class names programmatically, the case converter helps you ensure consistency with whichever convention your project follows.

Locale-aware case conversion is a real concern for internationalized applications. The Turkish language has four distinct i characters: dotted lowercase i, dotless lowercase i (without a dot), dotted uppercase I (with a dot above), and the standard uppercase I. Converting 'istanbul' to uppercase in a Turkish locale should produce 'ISTANBUL' with a dotted capital I, not the standard 'I'. JavaScript's toLocaleUpperCase() and toLocaleLowerCase() methods handle this, but most online converters default to English rules. If you work with Turkish, Azerbaijani, or Lithuanian text, verify that your converter supports locale-specific transformations.

For database migrations where you need to rename columns from one convention to another, generate the ALTER TABLE statements using batch case conversion rather than writing each one by hand. Export your column names, convert them from camelCase to snake_case (or vice versa), and use the output to script the migration. This approach reduces typos and ensures every column follows the same pattern. Pair this with your ORM's migration tool -- Django migrations, Alembic for SQLAlchemy, ActiveRecord migrations for Rails -- to track the changes in version control. A case convention migration is a mechanical task that benefits enormously from automation, since a single inconsistency can break queries that were working fine before the rename.

Related Tools

Word Counter

Analyze word stats after converting case

Character Counter

Check character count changes after conversion

JSON Formatter

Format JSON keys using consistent naming conventions

Case conversion is a small operation with outsized impact on consistency and readability. After converting variable names or headings, you might want to verify the word count stayed within limits, check that character counts did not shift unexpectedly due to locale-specific rules, or format a JSON object whose keys you just standardized. These tools form a natural chain for text processing tasks -- convert the case, validate the metrics, format the output.

Frequently Asked Questions

Recommended Tools

JSON Formatter

Validate, beautify, and minify your JSON data with tree view and syntax highlighting.

URL Encoder

Quickly encode or decode URL components, parameters, and special characters safely.

Base64 Converter

Convert plain text or binary data to Base64 and back. Support for Data URIs included.