Utilities Batch Processing 2026-04-10

Batch Text Case Conversion

Convert thousands of strings between camelCase, snake_case, kebab-case, UPPER_CASE, and Title Case using CLI tools, Python, and Node.js scripts.

Tools used: Text Case Converter All Free

The Problem

You're renaming database columns from camelCase to snake_case, converting API response keys for a different language convention, or normalizing CSV headers across dozens of files. Doing it string by string is slow and error-prone.

Why Batch Processing Matters

Batch case conversion is essential for database schema migrations (camelCase → snake_case), API response normalization between systems with different conventions, i18n string key standardization, code refactoring (renaming variables across files), and CSV header normalization before data import.

Common Use Cases

Convert database column names from camelCase to snake_case during migration
Normalize API response keys between camelCase (JavaScript) and snake_case (Python)
Standardize CSV headers across multiple files from different sources
Convert constant names to SCREAMING_SNAKE_CASE across a codebase
Transform kebab-case CSS class names to camelCase for JS object keys

Step-by-Step Instructions

Identify source and target case formats

Common formats: camelCase, PascalCase, snake_case, kebab-case, SCREAMING_SNAKE_CASE, Title Case. Use the Text Case Converter to test a few examples.

Prepare your input

Extract the strings to convert: CSV column headers, JSON keys, variable names from code. Put them in a text file (one per line) or identify the column/key to transform in your data files.

Run the conversion script

Choose from the scripts below based on your language preference. Each handles edge cases like acronyms (HTMLParser → html_parser), numbers (value2key → value_2_key), and consecutive capitals.

Review and spot-check

Acronyms and abbreviations are the most common source of unexpected results. Check that HTTPSProxy converts to https_proxy (not h_t_t_p_s_proxy). Adjust the regex if needed.

Code Examples

# camelCase → snake_case (handles consecutive caps correctly)
echo "myVariableName" | sed -r 's/([A-Z])/_\L\1/g' | sed 's/^_//'
# Output: my_variable_name

# snake_case → camelCase
echo "my_variable_name" | sed -r 's/_([a-z])/\U\1/g'
# Output: myVariableName

# Batch: convert all strings in a file (one per line)
while read line; do
  echo "$line" | sed -r 's/([A-Z])/_\L\1/g' | sed 's/^_//'
done < input.txt > output.txt

# Convert CSV headers (first line only)
head -1 data.csv | tr ',' '\n' | \
  sed -r 's/([A-Z])/_\L\1/g' | sed 's/^_//' | \
  paste -sd',' > /tmp/header.csv
tail -n+2 data.csv >> /tmp/header.csv
mv /tmp/header.csv data_snake.csv

import re
import csv

def to_snake_case(name: str) -> str:
    """Convert camelCase/PascalCase to snake_case."""
    s = re.sub(r'([A-Z]+)([A-Z][a-z])', r'\1_\2', name)
    s = re.sub(r'([a-z0-9])([A-Z])', r'\1_\2', s)
    return s.lower().replace('-', '_').replace(' ', '_')

def to_camel_case(name: str) -> str:
    """Convert snake_case/kebab-case to camelCase."""
    parts = re.split(r'[_\-\s]+', name)
    return parts[0].lower() + ''.join(w.capitalize() for w in parts[1:])

def to_kebab_case(name: str) -> str:
    """Convert to kebab-case."""
    return to_snake_case(name).replace('_', '-')

# Convert a list of strings
with open("names.txt") as f:
    names = [line.strip() for line in f if line.strip()]

for name in names:
    print(f"{name:30s} → {to_snake_case(name)}")

# Convert CSV headers
with open("data.csv") as fin, open("data_snake.csv", "w", newline="") as fout:
    reader = csv.reader(fin)
    writer = csv.writer(fout)
    header = [to_snake_case(h) for h in next(reader)]
    writer.writerow(header)
    for row in reader:
        writer.writerow(row)
print(f"Converted {len(header)} column headers to snake_case")

const fs = require('fs');

function toSnakeCase(str) {
  return str
    .replace(/([A-Z]+)([A-Z][a-z])/g, '$1_$2')
    .replace(/([a-z0-9])([A-Z])/g, '$1_$2')
    .replace(/[\s-]+/g, '_')
    .toLowerCase();
}

function toCamelCase(str) {
  return str.replace(/[_-\s]+(\w)/g, (_, c) => c.toUpperCase());
}

function toKebabCase(str) {
  return toSnakeCase(str).replace(/_/g, '-');
}

// Convert names from a text file
const names = fs.readFileSync('names.txt', 'utf8')
  .trim().split('\n');

const results = names.map(n => ({
  original: n.trim(),
  snake: toSnakeCase(n.trim()),
  camel: toCamelCase(n.trim()),
  kebab: toKebabCase(n.trim()),
}));

// Output as aligned table
results.forEach(r =>
  console.log(`${r.original.padEnd(25)} → snake: ${r.snake} | camel: ${r.camel}`)
);

// Convert JSON keys
const data = JSON.parse(fs.readFileSync('data.json', 'utf8'));
const converted = Object.fromEntries(
  Object.entries(data).map(([k, v]) => [toSnakeCase(k), v])
);
fs.writeFileSync('data_snake.json', JSON.stringify(converted, null, 2));

Single vs Batch Comparison

Single string (web tool)

Type 'myVariableName' → select snake_case → get 'my_variable_name'

Batch output (CLI)

$ wc -l api_fields.txt
156 api_fields.txt

$ python batch_case.py
firstName                 → first_name
lastName                  → last_name
emailAddress              → email_address
phoneNumber               → phone_number
createdAt                 → created_at
...
Converted 156 field names to snake_case

$ python convert_csv_headers.py
Converted 24 column headers to snake_case

Frequently Asked Questions

How do I handle acronyms like HTML, API, or UUID in case conversion?

The Python/Node.js scripts above handle consecutive capitals correctly: HTMLParser → html_parser, getAPIKey → get_api_key. The key is the two-step regex: first split between consecutive caps and a lowercase letter, then between lowercase and uppercase.

Can I convert JSON keys recursively (nested objects)?

Yes — wrap the conversion in a recursive function: if the value is an object, recurse into it; if it's an array, map each element. In Python: def convert_keys(obj): return {to_snake(k): convert_keys(v) for k, v in obj.items()} with base cases for non-dict types.

What about converting variable names in source code files?

For code refactoring, use your IDE's rename feature (safer) or sed with word boundaries: sed -i 's/\bmyVar\b/my_var/g' *.py. Be careful with string literals and comments. Consider using tools like rope (Python) or jscodeshift (JavaScript) for AST-aware renaming.

Related Batch Guides

📋

Each tool runs in your browser with no signup required. Process single items instantly.

Open Text Case Converter

← All Batch Guides All Developer Guides