Unicode code point converter
Type Hi and get U+0048 U+0069, one code point per character, with an emoji kept as a single value such as U+1F600 instead of two broken halves. Paste a list of U+ codes to turn it back into text. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Worked example
- Text
- Hi
- Calculation mode
- To codepoints
- Result
- U+0048 U+0069
- Codepoints
- U+0048, U+0069
- Values
- 72, 105
- Quantity
- 2
Unicode assigns every character a unique scalar value written in the familiar U-plus hex notation, from basic Latin letters such as U+0041 for capital A through emoji and historic scripts that need five or six hex digits. Developers, font engineers, localization teams, and support desks constantly need to expand a short string into those code points for debugging, documentation, or wire formats, and just as often need to reassemble a list of U+ tokens into the original glyphs.
How Unicode scalars map to U+XXXX tokens
Unicode defines a space of scalar values from zero through U+10FFFF. Not every integer in that range is a character people type every day, but every abstract character you store in modern text is identified by one of those scalars. JavaScript strings are sequences of UTF-16 code units, so a single emoji or rare CJK ideograph may occupy two units called a surrogate pair.
A correct converter therefore must use code-point iteration rather than indexing one unit at a time; otherwise a smiling face would be misreported as two separate high and low surrogates instead of one scalar such as U+1F600. This capability walks the string with codePointAt, advances by one or two units as needed, and formats each scalar as U+ followed by at least four uppercase hexadecimal digits, extending to five or six digits when the value requires it.
The reverse path accepts several common spellings so paste sources stay flexible: U+0048, u+48, 0x48, bare hex such as 0048, and HTML forms like H or decimal H. Each token is parsed to an integer, then validated: values above U+10FFFF are rejected, and the UTF-16 surrogate range U+D800 through U+DFFF is rejected because those code units are not Unicode scalar values and must never appear as free-standing characters in a well-formed Unicode string. Valid scalars are assembled with fromCodePoint into a normal JavaScript string.
Where Unicode code point conversion shows up in real work
Font and glyph pipelines document which scalars a family covers and need stable U+ lists in specimen sheets and pull-request diffs. Internationalization engineers compare normalized forms, hunt confusing lookalikes, and verify that a product name does not hide a homoglyph by expanding every character to its code point. Accessibility and content teams paste short strings from design tools and need an authoritative expansion when a glyph renders as a box or an unexpected emoji.
Security reviewers inspect user names, URLs, and log lines for non-ASCII control characters or private-use scalars that slip past naive filters. Programming courses teach encoding by showing that a single visible character can map to one scalar while UTF-8 may use multiple bytes; a dedicated converter landing serves that search intent better than burying it under Base64 or UTF-8 repair tools. Support desks receive screenshots of weird symbols and reconstruct the exact code points from a typed or copied sample so engineering can reproduce the bug.
If you need Base32 secrets, percent-encoding for URLs, octal byte dumps, or mojibake repair into UTF-8, treat those as separate search intents and landings rather than overloading this Unicode code point converter page.
What you can do with it
Debug emoji and multi-byte characters
Expand a short string into U+XXXX tokens so surrogate pairs surface as one scalar, then rebuild the original text after editing the list.
Localization and font coverage checklists
Produce stable code-point inventories for product names, specimen strings, and glyph coverage tables shared across design and engineering.
Security and support triage
Reveal hidden or confusable characters in usernames and tickets by listing exact Unicode scalars without guessing from a screenshot alone.
FAQ
What notation does this converter use?
Standard Unicode U+XXXX notation with at least four uppercase hex digits (more when needed). Input also accepts 0xHH, bare hex, and HTML &#x…; / &#…; forms when converting back to characters.
What happens on an invalid code point?
Surrogates (U+D800–U+DFFF), values above U+10FFFF, and malformed tokens are rejected with a clear message. Validation failures are not charged.
Does it handle emoji and surrogate pairs correctly?
Yes. Iteration uses full Unicode code points, so a single emoji is one scalar (for example U+1F600), not two UTF-16 units.
What does it cost?
The browser tool is free and runs locally.
Which formats can I paste to turn codes back into characters?
U+0048, u+48, 0x48, bare hex such as 0048 and HTML references like H or H all work. Values above U+10FFFF and the surrogate range are refused, so a bad paste never produces a wrong character.
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/enc/unicode-codepoint \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"text":"Hi"}'const res = await fetch("https://api.kit.forhosting.com/enc/unicode-codepoint", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"text": "Hi"
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/enc/unicode-codepoint",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"text": "Hi"
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/enc/unicode-codepoint", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"text":"Hi"}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"text":"Hi"}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/enc/unicode-codepoint", 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": "Hi"
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "enc.unicode_codepoint",
"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
This capability does both directions with one pure function: to_codepoints walks the input with full code-point awareness so surrogate pairs become a single scalar, and to_chars parses U+, 0x, bare hex, and HTML numeric references while rejecting surrogates and values above U+10FFFF. Invalid tokens fail immediately with invalid_input so bad paste jobs never invent a wrong character.
How Unicode scalars map to U+XXXX tokens
The entire path is deterministic integer and string work with no network calls, no random seeds, and no wall-clock timestamps, so identical inputs always produce identical JSON.
What you send and what you get back
Optional separator controls how tokens are joined on the way out and split on the way in: space is the default, with comma, newline, and none available for denser or line-oriented lists. In none mode each token must carry an explicit U+, 0x, or HTML prefix so boundaries stay unambiguous. Success responses echo mode, the original text, a result string, an array codepoints of normalized U+ tokens, a numeric values array of integers, a count of scalars, the separator used, a format label, and a short standard reference. Send a required string field named text and an optional mode field set to to_codepoints or to_chars. When mode is omitted, to_codepoints is the default so a single payload still does useful work. To_codepoints turns Hi into U+0048 U+0069 with matching arrays; to_chars reverses that list back to Hi. Missing text, unsupported mode values, strings longer than the documented maximum, empty illegal tokens, non-hex garbage, surrogate code points, and scalars above U+10FFFF all fail with invalid_input and a clear English message naming the problem. Validation failures do not consume prepaid balance. Pricing for successful API calls is the published base of $0.002 per item.
Where Unicode code point conversion shows up in real work
Because this capability is a pure parse engine, API pricing is the published base of $0.002 per successful item and failed validation does not consume balance.
Technical questions
Can I convert both ways?
Yes. Set mode to to_codepoints (default) to map characters to U+ tokens, or mode to to_chars to parse code-point tokens back into a string.