PascalCase converter
Turn any phrase or identifier into PascalCase: hello world example becomes HelloWorldExample, ready to use as a class, type or component name. Every word starts with a capital letter and nothing separates them. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Worked example
- Text
- hello world example
- Result
- HelloWorldExample
- Text
- HelloWorldExample
- Original
- hello world example
- Length
- 17
PascalCase is the identifier style used for type names, component classes, and many public APIs: each word starts with an uppercase letter and there are no spaces, hyphens, or underscores between words. Developers rename database columns, CSS class stems, CLI flags, and product phrases into PascalCase when generating code, React components, or C# types. Empty or whitespace-only strings fail with invalid input so pipelines never store blank type names.
What PascalCase is and where it is used
PascalCase writes a name as one run of words, each starting with a capital letter, with no spaces, hyphens or underscores in between. It is the usual style for type names and component classes, so developers reach for it when they turn database column names, CSS class stems, command-line flags or plain product phrases into names for generated code, React components or C# types. Design systems use it as well, turning multi-word token names into component names without editing them by hand. The phrase hello world example becomes HelloWorldExample: three words, three capitals and no separators, 17 characters in all.
How the conversion works and the usual surprises
First the text is split into words. Spaces, tabs, hyphens, underscores, dots and slashes all count as breaks, and a capital letter inside a word or a switch between letters and digits starts a new word too, so helloWorld is read as two words. Each word then gets a capital first letter and a lowercase rest, and everything is joined. A block of capitals is therefore not kept as it was. Do not confuse the result with camelCase, which starts with a lowercase letter, or with styles that keep a separator between words. Text made only of punctuation is rejected, because there is no word to capitalize.
What you can do with it
Design tokens and UI libraries
Design systems convert multi-word token names into PascalCase React or Flutter component identifiers without hand editing.
FAQ
How do I convert text to PascalCase?
The response result field is the PascalCase output; original echoes your input for comparison.
Is the PascalCase converter free?
The browser tool runs free on your device.
How is PascalCase different from camelCase?
PascalCase capitalizes every word including the first (HelloWorld). camelCase leaves the first letter lowercase (helloWorld). This tool always produces PascalCase.
Do hello world, hello-world and hello.world give the same result?
Yes. Spaces, tabs, hyphens, underscores, dots and slashes all separate words in the same way, so each of those versions becomes HelloWorld.
How are acronyms such as XML handled?
A block of capitals is treated as one word and gets a capital first letter with the rest in lower case. That is why getHTTPResponseCode becomes GetHttpResponseCode rather than keeping the capitals.
Related tools
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/pascal-case \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"text":"hello world example"}'const res = await fetch("https://api.kit.forhosting.com/str/pascal-case", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"text": "hello world example"
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/str/pascal-case",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"text": "hello world example"
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/str/pascal-case", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"text":"hello world example"}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"text":"hello world example"}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/str/pascal-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": "hello world example"
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "str.pascal_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.
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. |
Technical notes
What PascalCase means and how words are detected
PascalCase is for identifiers: HelloWorldExample has three word heads and zero separators. This converter first expands camelCase and digit boundaries so helloWorld and XMLParser become separate tokens, then splits on any run of non-alphanumeric characters such as spaces, tabs, hyphens, underscores, dots, and slashes. Inputs that contain only punctuation or separators with no letters or digits are rejected as empty content for casing purposes. PascalCase differs from camelCase, snake_case, kebab-case, and sentence case. camelCase leaves the first letter lower; snake_case and kebab-case keep separators; sentence case is for prose. Each remaining alphanumeric word is rewritten with an uppercase first character and lowercase remainder, then the words are concatenated. hello world becomes HelloWorld; hello_world and hello-world produce the same result; getHTTPResponseCode becomes GetHttpResponseCode after acronym-aware boundary splits. Prefer this tool when the search intent is convert to PascalCase, Pascal case converter, or class name from phrase; use separate tools for sentence case, URL slugs, or snake_case.
Input contract, empty rejection, and reading the response
Source text follows the same retention rules as other KIT parse items. Send a JSON body with the required string field text set to the non-empty phrase or identifier you want rewritten. Aliases input, value, s, and content are accepted when older forms or client generators use those names. Missing text, a non-string value, an empty string, a whitespace-only string, or a string with no alphanumeric word all raise invalid_input with a message that names the problem, and those failures are not charged on the prepaid API. Use result alone when you only need the identifier; use original and result together when a rename UI must show before-and-after; use words and word_count when a generator or linter inspects token boundaries. Keep payloads to ordinary identifier and phrase sizes suitable for a Worker isolate rather than multi-megabyte dumps; this product is a name formatter, not a bulk file processor.
API usage, pricing, codegen workflows, and practical limits
Do not expect locale-specific title rules or dictionary-aware acronym lists beyond the simple boundary heuristics documented here; house style for brand names may still need a later editorial pass. Authors shipping SDKs can document text as the only required field and show a multi-word success example plus an empty-string error example so integrators see both sides of the contract. Call the free in-browser PascalCase converter for one-off renames, classroom demos, design-token naming, and schema brainstorming without installing a desktop utility or writing a one-liner in every language. Use the prepaid KIT API when a codegen worker, OpenAPI transformer, CMS field normalizer, or mobile backend needs the same transform under balance at $0.002 per successful item; validation failures never consume balance after the engine rejects the request. A typical workflow takes a product label such as order line item, runs this endpoint, then inserts result into a C# class or React component file name. Another workflow normalizes mixed snake_case API fields from a partner feed into PascalCase DTOs for a typed client. Pair this endpoint with a sentence-case or slug tool when the same human phrase must also become prose copy or a URL path, but keep the steps separate so each landing page matches a single search intent—PascalCase for type identifiers, sentence case for readable paragraphs, slugs for routes.
Integration use cases
Codegen and type names
Code generators turn product phrases and schema labels into PascalCase class, struct, and component names ready to drop into templates.
API and DTO normalization
Integration pipelines rewrite snake_case or kebab-case partner fields into PascalCase DTO properties for strongly typed clients.
Technical questions
What happens if text is empty?
Empty strings, whitespace-only strings, and strings with no alphanumeric words fail with invalid_input and are not charged.
Does this support snake_case and kebab-case input?
Yes. Underscores, hyphens, spaces, and other non-alphanumeric separators are treated as word breaks before capitalization.