ForHosting KIT · Text & AI

Split camelCase into words

Turn a compact name like GetUserProfile into Get User Profile, ready for a label, a heading or alt text. Acronyms, digits, underscores and hyphens are split cleanly, and every letter keeps its original case. Free in your browser.

  • Free
  • Runs in your browser
  • No sign-up
  • Your data stays on your device
Use it from WebAPIEmailTelegramApp soon
If you enter
Text
helloWorld
You get
Text
hello World
Original
helloWorld
Words
hello, World
Word count
2

This split-camelCase-into-words tool takes a camelCase or PascalCase identifier and returns a plain, space-separated phrase you can read without decoding code style. It finds each capital-letter boundary—between a lowercase letter or digit and an uppercase letter, and between a run of capitals and a following Titlecase word—then rebuilds the text as separate words. Existing underscores, hyphens, spaces, and other non-alphanumeric separators are treated as breaks too, so mixed identifiers stay legible. Nothing is guessed from a model, nothing is fetched over the network, and nothing depends on the clock or random seeds.

What splitting camelCase does to a name

Splitting camelCase turns a single compacted identifier into a readable phrase by inserting word breaks where capital letters mark a new word. In practice helloWorld becomes hello World, GetUserProfile becomes Get User Profile, and XMLHttpRequest becomes XML Http Request because the engine also splits an acronym from a following Titlecase segment. Letter-to-digit and digit-to-letter edges are broken as well, so patterns such as getUser2FA expand into get User 2 FA without inventing new characters or dropping digits.

Underscores, hyphens, dots, and spaces already present act as separators and never reappear as glue in the middle of a token. There is no silent mode that lowercases everything, no locale-specific title rules, and no partial success that drops empty segments without saying so.

Where camelCase splitting fits in study, publishing, and software

Students meet camelCase when a coding exercise demands property names that match a style guide, then later need the same names as human labels on worksheets, slides, or accessibility alt text. Teachers can pre-generate answer keys that show the expected phrase form without trusting opaque spreadsheet macros that change locale rules mid-file. Backend and integration teams expand legacy CSV column titles and OpenAPI property names into documentation headings and support-runbook text before freeze.

Design systems and CMS workflows turn token names into display labels that content editors can understand without reading source. Support and operations teams paste feature flags and noisy ticket subjects into readable phrases so dashboards and on-call notes share one plain-language shape.

What does the split-camelCase-into-words tool cost?

It is free in your browser on this page.

What happens if I send an empty string?

Empty text is not a valid split; provide a non-empty camelCase or PascalCase string with at least one alphanumeric character.

How are acronyms handled?

Runs of capitals followed by a Titlecase word are split so XMLHttpRequest becomes XML Http Request. Case on each token is preserved.

Does this tool convert a phrase into camelCase?

No. It only splits camelCase or PascalCase into words. Use the convert-to-camelCase tool if you need the opposite direction.

Is the result the same every time for the same input?

Yes. The transform is pure and deterministic: no network, no randomness, and no clock. The same identifier always yields the same phrase and words array.

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.

POSThttps://api.kit.forhosting.com/str/split-camel-case

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.

curl -X POST https://api.kit.forhosting.com/str/split-camel-case \
  -H "Authorization: Bearer $KIT_KEY" \
  -H "Content-Type: application/json" \
  -d '{"text":"helloWorld"}'
{
  "text": "helloWorld"
}
{
  "task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
  "type": "str.split_camel_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.

Per request$0.002

Published price — no tokens, no invented credits. A failed task is never charged.

max_chars100000
HTTPCodeMeaning
401unauthorizedMissing or invalid API key.
402insufficient_balanceYour balance doesn't cover the task price.
404unknown_typeThat task type doesn't exist.
429rate_limitedToo many requests. Use the webhook instead of polling.

Use it when variable names, API fields, React props, class names, or design tokens need to become labels, headings, documentation, or accessibility text. Empty input and separator-only strings fail with a clear invalid_input error so a blank form cannot look like a successful split. Run it free in the browser for naming drills and refactor prep, or call the API at $0.002 per successful request when CI, forms, and pipelines need the same phrase every time.

What splitting camelCase means and what the response contains

This calculator returns five stable fields: text holds the space-joined readable phrase you will copy into UI copy or docs, original echoes the exact input string so you can audit what was split, words is the ordered array of tokens, word_count reports how many tokens were produced, and method is the fixed tag split_camel_case for logs and multi-tool pipelines. The engine either builds a complete phrase inside the supported length or rejects the request with invalid_input. Rejected cases include a missing text field, a null value, an empty string, whitespace-only or separator-only payloads that leave no alphanumeric tokens, objects and arrays that are not plain text, and any payload longer than the documented maximum character count.

How the text field is read and how the result stays reproducible

The value must be a non-empty string; finite numbers and bigints are stringified first so a bare numeric code still becomes a single-token phrase after conversion to decimal digits. Leading and trailing whitespace are trimmed before tokenization; internal runs of spaces, underscores, hyphens, dots, and other non-alphanumeric characters act as word breaks and do not survive as empty array slots. Case is preserved on each token: the split inserts spaces but does not force lowercase or Title Case, so you can still see original acronyms and capitals in the phrase and in the words array. The preferred field is text, but aliases input, string, value, content, s, and identifier are accepted so query strings, spreadsheets, and typed forms can reuse the same contract without renaming columns. Booleans, plain objects, and arrays are rejected with a clear message so a mistaken JSON body does not become the word true or an unhelpful object dump. Empty string is always invalid_input: the product promise is split an identifier into words, not invent a blank success. Length is capped at one hundred thousand characters so a runaway paste cannot monopolize a Worker; longer payloads fail with an explicit limit message rather than a truncated silent cut. Pair the free browser run on this page with the priced API when you need the identical readable phrase inside an automated pipeline without shipping your own string helpers.

Where camelCase splitting fits in study, publishing, and software

Front-end and full-stack developers split React props, GraphQL field aliases, CSS-in-JS theme tokens, and configuration keys into readable copy for settings panels, form labels, and changelog lines. On this page the work runs entirely in your browser; through the API each successful split costs $0.002, failed validation is not charged, and nothing is stored after the response returns. That split—free interactive exploration and a priced, identical API—matches the rest of the KIT tier-A catalog and lets you move from a classroom demo to an automated pipeline without changing the phrase result. Pair it with convert-to-camelCase, snake_case, or title-case tools when you are building a small lab of free, deterministic text helpers for forms, CMS prep, and data hygiene.

Readable labels from code identifiers

Turn camelCase props, JSON keys, and class names into space-separated labels for forms, settings panels, and accessibility text.

Documentation and changelog prep

Expand PascalCase types and API field names into plain phrases for README sections, OpenAPI descriptions, and release notes.

Deterministic naming fixtures

Generate reproducible word lists and phrases for unit tests, golden files, and CI assertions on identifier-to-label transforms.

Read the full KIT documentation →