Convert to COBOL-CASE
The COBOL case converter turns ordinary text, mixed identifiers, and loosely formatted labels into a consistent screaming hyphen style: every detected word becomes uppercase and adjacent words are joined with a single hyphen.
Run — free
Paste a phrase such as customer account record and receive CUSTOMER-ACCOUNT-RECORD. It also recognizes common camelCase and PascalCase boundaries, replaces punctuation and existing separators, and keeps digits as useful tokens. The conversion is deterministic, so the same input always produces the same output in a browser, build script, API workflow, or configuration-generation pipeline.
Turn mixed text into a predictable COBOL-style identifier
COBOL-CASE is a visually loud naming style made from uppercase words separated by hyphens. It is associated with classic COBOL source conventions, legacy data definitions, command names, configuration keys, and documentation that needs identifiers to stand out immediately. This converter removes the repetitive work of finding every word, normalizing its capitalization, and fixing separators by hand. Supply plain prose, a copied field label, or an identifier written in another case style. The result contains ASCII letters and digits arranged as uppercase tokens with exactly one hyphen between neighboring tokens. Spaces, underscores, existing hyphens, and punctuation all behave as boundaries, so inconsistent source formatting becomes one stable representation. That consistency is especially useful when generated names must be reviewed, compared, or inserted into templates. The response also includes a word count, making it easy for an automated caller to check how the source was interpreted without reconstructing the tokenizer. Nothing is stored, fetched, inferred from external data, or changed between runs.
Understand how word boundaries and characters are handled
The converter first validates that text is present, is actually a string, fits the published size limit, and contains at least one ASCII letter or digit. It then detects familiar boundaries inside camelCase and PascalCase identifiers. For example, customerAccount becomes CUSTOMER-ACCOUNT, while XMLParser becomes XML-PARSER rather than XMLPARSER. Transitions between letters and digits are boundaries too, which makes report2026Final become REPORT-2026-FINAL. Runs of spaces or punctuation collapse into one separator; they never create doubled or trailing hyphens. Each remaining token is converted to uppercase and joined with a hyphen. This deliberately narrow character policy produces portable output for older toolchains and configuration systems that may not agree about Unicode identifier rules. Accented letters and symbols act as separators instead of being transliterated, because silent transliteration could turn distinct source values into surprising names. If the input contains only punctuation or whitespace, the request returns an invalid-input error rather than an empty success. The algorithm does not consult locale settings, dictionaries, or clocks, so its output remains deterministic across environments.
Use the browser for one-offs and the API for repeatable workflows
For an occasional conversion, paste text into the browser tool and copy the normalized result directly into a source file, configuration document, migration note, or test fixture. For repeated work, call the API from a generator, import pipeline, editor command, or continuous-integration check. The request has one required text field and costs $0.002; the same pure conversion logic powers the browser and API paths. A useful workflow is to normalize candidate names before comparing them, then reject duplicates or names that violate a project-specific length rule. Another is to convert spreadsheet headings into consistent legacy field labels during an export. Because the capability only transforms text, it does not claim that a result is a valid identifier for every COBOL compiler, database, or vendor product. Those systems can impose limits on length, leading characters, reserved words, or allowed symbols, and callers should apply the rules for their target environment after conversion. Keep the original text alongside generated names when auditability matters. This tool standardizes case and separators; it does not replace a compiler, schema validator, or organization-specific naming policy.
What you can do with it
Prepare legacy field names
Convert human-readable labels or modern identifiers into consistent uppercase, hyphen-separated names for migration mappings and documentation.
Normalize configuration keys
Make copied keys predictable before inserting them into templates, examples, fixtures, or systems that use screaming hyphen notation.
Automate naming in generators
Create stable COBOL-CASE output from schema headings or form labels during repeatable build and export workflows.
FAQ
What is COBOL-CASE?
COBOL-CASE is a naming style in which words are uppercase and joined with hyphens, such as CUSTOMER-ACCOUNT-RECORD.
Does it recognize camelCase and PascalCase?
Yes. Lowercase-to-uppercase boundaries and acronym-to-word boundaries are split before the words are uppercased and joined.
What happens to punctuation and repeated separators?
They act as word boundaries. Consecutive separators collapse, so the result has no doubled, leading, or trailing hyphens.
Does the result work with every COBOL compiler?
Not necessarily. The tool normalizes case and separators, but compiler dialects can impose their own length, reserved-word, and identifier rules.
How much does an API conversion cost?
Each API request costs $0.002. The browser version runs the same deterministic conversion locally for free.
For developers — API access
Everything on this page is available programmatically. This section is for teams who want to wire it into their own systems; everyone else can just use the tool above.
API endpoint
Prefer to automate it? One authenticated POST creates the task; the result comes back by webhook or a signed link. The same capability also runs here on the web, by email and from Telegram — and soon from our app too.
Call it from your stack
curl -X POST https://api.kit.forhosting.com/str/cobol-case \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"text":"customerAccount record"}'const res = await fetch("https://api.kit.forhosting.com/str/cobol-case", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"text": "customerAccount record"
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/str/cobol-case",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"text": "customerAccount record"
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/str/cobol-case", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"text":"customerAccount record"}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"text":"customerAccount record"}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/str/cobol-case", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Example request
{
"text": "customerAccount record"
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "str.cobol_case",
"status": "queued",
"_links": {
"result": "/tasks/tsk_…/result"
}
}The API is asynchronous: the call returns a task_id immediately and the result arrives by webhook. Polling is capped at 1 req/s per task.
Pricing
Published price — no tokens, no invented credits. A failed task is never charged.
Limits
max_chars | 100000 |
Errors
| HTTP | Code | Meaning |
|---|---|---|
401 | unauthorized | Missing or invalid API key. |
402 | insufficient_balance | Your balance doesn't cover the task price. |
404 | unknown_type | That task type doesn't exist. |
429 | rate_limited | Too many requests. Use the webhook instead of polling. |