Text Case Converter

Convert text between upper, lower, title, camel, snake, and kebab case.

What does Text Case Converter do?

This actor converts text between multiple case formats: UPPER CASE, lower case, Title Case, camelCase, PascalCase, snake_case, kebab-case, and CONSTANT_CASE. It automatically detects and splits words from any input format, including camelCase, kebab-case, or mixed inputs. Useful for data transformation, code generation, CSS class naming, and bulk text processing workflows.

Use cases

• Frontend developer converting design token names between camelCase (JavaScript), kebab-case (CSS), and CONSTANT_CASE (environment variables)
• Data engineer normalizing column names or field labels from mixed formats into a consistent snake_case convention
• Technical writer converting variable names to Title Case for documentation headings
• Backend developer generating code identifiers in PascalCase or camelCase from human-readable descriptions
• Content manager standardizing tag names or category labels across a CMS

Why use Text Case Converter?

• Eight case formats -- every input returns all eight conversions at once: upper, lower, title, camel, pascal, snake, kebab, and constant
• Smart word splitting -- automatically detects word boundaries in camelCase, kebab-case, snake_case, and mixed inputs
• Batch processing -- convert hundreds of strings in a single run instead of processing them one at a time
• Word count included -- each result includes the number of words detected in the input
• Structured JSON output -- clean, consistent output ready for downstream processing or integration
• Pay-per-event pricing -- only $0.0005 per string converted, plus a one-time start fee

Input parameters

Parameter	Type	Required	Default	Description
texts	string[]	Yes	--	List of text strings to convert

{
    "texts": ["hello world example", "myVariableName", "some-kebab-case"]
}

Output example

Each text string produces all case conversions:

Field	Type	Description
input	string	The original text
upper	string	UPPER CASE version
lower	string	lower case version
title	string	Title Case version
camel	string	camelCase version
pascal	string	PascalCase version
snake	string	snake_case version
kebab	string	kebab-case version
constant	string	CONSTANT_CASE version
wordCount	number	Number of words detected

{
    "input": "hello world example",
    "upper": "HELLO WORLD EXAMPLE",
    "lower": "hello world example",
    "title": "Hello World Example",
    "camel": "helloWorldExample",
    "pascal": "HelloWorldExample",
    "snake": "hello_world_example",
    "kebab": "hello-world-example",
    "constant": "HELLO_WORLD_EXAMPLE",
    "wordCount": 3
}

How much does it cost?

Event	Price	Description
Start	$0.035	One-time per run
Text converted	$0.0005	Per text string converted

Example costs:

• 10 strings = $0.035 + (10 x $0.0005) = $0.04
• 100 strings = $0.035 + (100 x $0.0005) = $0.085
• 1,000 strings = $0.035 + (1,000 x $0.0005) = $0.535

Using the Apify API

You can start Text Case Converter programmatically from your own applications using the Apify API. Below are examples in Node.js and Python.

Node.js

import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: 'YOUR_TOKEN' });
const run = await client.actor('automation-lab/text-case-converter').call({
    texts: ['hello world example', 'myVariableName'],
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);

Python

from apify_client import ApifyClient

client = ApifyClient('YOUR_TOKEN')
run = client.actor('automation-lab/text-case-converter').call(run_input={
    'texts': ['hello world example', 'myVariableName'],
})
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)

Integrations

Text Case Converter works with the full Apify integration ecosystem. You can connect it to a wide range of automation platforms and data destinations:

• Make (formerly Integromat) -- trigger text case conversion as a step in a multi-tool scenario
• Zapier -- normalize text casing automatically as part of your zap workflows
• n8n -- use the Apify node in n8n workflows for self-hosted text processing pipelines
• Slack -- send converted text results to a Slack channel for team review
• Google Sheets -- export all case variants to a spreadsheet for comparison or selection
• Amazon S3 -- store output datasets in S3 buckets for downstream processing
• Webhooks -- send results to any HTTP endpoint for real-time text normalization

You can also schedule recurring runs on the Apify platform to normalize new data on a timer.

Tips and best practices

• Mix input formats freely -- the actor handles camelCase, kebab-case, snake_case, and space-separated text in the same batch, so you do not need to pre-sort your inputs.
• Use the output format you need -- since all eight formats are returned for every input, pick the field you need in your downstream code and ignore the rest.
• Normalize before comparing -- convert strings to the same case (e.g., lower or snake) before doing string comparisons to avoid mismatches caused by formatting differences.
• Generate code identifiers -- use camelCase or PascalCase output to auto-generate variable or class names from human-readable descriptions.
• Check wordCount for validation -- if your input should always be multi-word (e.g., full names), use the word count to flag single-word entries.

FAQ

How does the actor split words in camelCase or PascalCase input? The actor detects transitions between lowercase and uppercase letters as word boundaries. For example, myVariableName is split into my, Variable, and Name. It also recognizes hyphens, underscores, and spaces as delimiters.

Does it handle special characters or accented letters? The actor processes ASCII letters and common delimiters. Accented characters (e.g., e with accent) are preserved in the output but may not be split correctly at word boundaries. For best results, use ASCII input.

Can I convert only to a specific case instead of all eight? The actor always returns all eight case formats for every input. You can simply use the specific field you need (e.g., snake or camel) and ignore the rest in your downstream processing.

What happens with numbers in the input? Numbers are treated as part of the current word. For example, item2name would be handled as a single token or split at letter-digit boundaries depending on the surrounding context. For best results, use spaces or delimiters to separate words that include numbers.

Can I use this for file name normalization? Yes. The kebab-case and snake_case outputs work well for file names. Pass your original file names (without extensions) as input and use the kebab or snake field from the output.

Can I use Text Case Converter on a schedule? Yes. You can schedule the actor on the Apify platform to run at regular intervals. This is useful if you have a recurring data source where field names or labels need to be normalized on a timer (e.g., processing new CSV headers daily).