What a Unicode char code actually identifies
A Unicode character code is a fixed scalar value assigned to one abstract character in the Unicode standard, written as U+XXXX in hexadecimal — A is U+0041 and 😀 is U+1F600 — and on Android you can look up any character's code point without installing an app by opening a browser-based Unicode Encoder / Decoder that runs locally on the device. The tool iterates over Unicode scalar values rather than JavaScript UTF-16 code units, so supplementary characters stay as one label and never get exposed as a pair of surrogates. Basic characters receive at least four hexadecimal digits, so the capital letter A appears as U+0041, the lowercase é as U+00E9, and a flag such as 🇯🇵 sits at U+1F1EF U+1F1F5 because it is a regional-indicator pair rather than a single character.
Valid scalar values cover the range U+0000 through U+10FFFF, with the interval U+D800 through U+DFFF deliberately excluded because those numbers are reserved for UTF-16 surrogate code units and never identify a character on their own. When you read the output on your phone, every token you see is therefore a real, standalone code point. If the tool rejects a token, it is either out of bounds, inside the surrogate gap, missing its U+ or \u{...} prefix, or contains a non-hexadecimal character. Nothing is silently replaced — the diagnostics you see are the same diagnostics a strict scalar check would produce.
Unicode code points versus Android keycodes
Many Android developers who search for "char code lookup on android" are actually looking for the integer values used by Android's input system, such as KeyEvent.KEYCODE_A = 29 or KeyEvent.KEYCODE_HOME = 3. Those are Android input constants: small integers from the android.view.KeyEvent class that identify a physical key or a software button, not a character. The Unicode code point for the letter A is a completely different number, U+0041, which lives in the Unicode standard rather than in the Android SDK. Confusing the two is one of the most common reasons an ASCII value "looked up" from a phone turns out to be the wrong value for the job.
| Code system | What it identifies | Example for A | Example for é | Example for 😀 |
|---|---|---|---|---|
| Unicode code point (U+XXXX) | One abstract character from the Unicode standard | U+0041 | U+00E9 | U+1F600 |
| Android KeyEvent constant | A physical key or software button in the Android SDK | KEYCODE_A = 29 | No direct keycode (accent requires composition) | No keycode (emoji is not a key event) |
| UTF-8 byte sequence | The byte representation of a code point in the UTF-8 encoding | 0x41 | 0xC3 0xA9 | 0xF0 0x9F 0x98 0x80 |
If your goal is to identify the abstract symbol — for example, to paste a character into a regex, a URL, a filename, or a code comment — use the Unicode code point. If your goal is to react to a hardware key being pressed in an Android app, use the KeyEvent constants from android.view.KeyEvent. The two systems never collide, but the search snippet you happen to read may only cover one of them, so it helps to know which scale you are working on. A related tool on this site, the UTF-8 Encoder / Decoder, gives you the byte side of the same equation if a file format is what you actually need.
How to look up char codes on your Android phone
No install is required. The tool is a single web page that runs entirely in the browser, so any modern Android browser — Chrome, Samsung Internet, Firefox, Brave, Edge — will work. Follow these steps on your phone when you need the code point for a character.
- Open your Android browser and navigate to the Unicode Encoder / Decoder. The page loads as static HTML, so it is friendly on cellular data.
- Make sure the mode selector is set to text-to-code-points. The page exposes two directions and you want encode for this flow.
- Long-press inside the input field, choose Paste, and paste the exact string you want to inspect, including any invisible characters such as spaces, tabs, or zero-width joiners.
- Tap Convert. The output panel fills with one U+ token per line, and supplementary characters remain as a single U+1F600-style scalar value rather than splitting into surrogate halves.
- Copy the U+ sequence.
- To go the other way, switch to code-points-to-text and paste prefixed tokens such as U+1F600 U+1F44D or \u{1F600}\u{1F44D} separated by spaces, commas, or line breaks. The text appears once every token passes scalar validation.
Because the conversion runs locally, the text you paste never leaves the phone, which matters if the string contains sensitive identifiers, draft filenames, or pasted clipboard content from another app.
Reading the U+ output from your phone
Once the conversion has run, each line of the output panel shows one Unicode scalar value. Adjacent tokens belong to the same string in input order, so the sequence itself is the answer — not just the individual values. A handy trick on a phone is to skim the list for anything that starts with U+200D, U+200C, U+FEFF, or U+2060, because those are zero-width and default-ignorable values that often explain why pasted text behaves strangely in search boxes, form fields, or filename comparisons.
| Token | What it is | Why it matters on a phone |
|---|---|---|
| U+000A | Line feed (newline) | Explains an unexpected line break when pasting from a desktop log |
| U+0020 | Regular space | Often confused with U+00A0 (non-breaking space) by search and equality checks |
| U+200D | Zero-width joiner | Joins emoji like 👩💻 into a single visible grapheme from several scalars |
| U+FEFF | Byte order mark / zero-width no-break space | Hidden prefix that breaks exact string comparison |
| U+2060 | Word joiner | Invisible glue that prevents line wrapping at a specific spot |
A single visible emoji can be several code points. The developer emoji 👩💻, for instance, breaks down into three Unicode scalar values in order: U+1F469 (woman), U+200D (zero-width joiner), and U+1F4BB (laptop). Reading the U+ list left to right is therefore the literal sequence the file or message contains, and is the ground truth when a comparison fails because two strings "look the same" but differ by a joiner or a variation selector. The same logic applies to flags (two regional indicators), skin-tone emoji (a base character plus a Fitzpatrick modifier), family emoji, accented letters that can be either precomposed or decomposed, and most CJK punctuation that includes ideographic space.
Decoding prefixed tokens back into text
When you have a list of code points — typically copied from documentation, a stack trace, a JSON log, or a colleague's message — paste them into decode mode and the page rebuilds the matching string. The accepted prefixes are U+ followed by hex digits and the JavaScript-style \u{...} brace notation used by String.fromCodePoint in ECMAScript. Hexadecimal is case-insensitive, so u+1f600, U+1F600, and \u{1F600} all decode to the same scalar value.
Tokens may be separated by spaces, commas, or line breaks. Adjacent values that would otherwise be mistaken for one longer hexadecimal number must keep their prefix and a visible separator. A quick test you can run on your phone is to paste U+1F600 U+1F44D and confirm that the decoded string is two emoji (😀 and 👍) rather than a single garbled character. If the decode rejects a token, it is not silently substituted. The Char Code Lookup Cheat Sheet gathers the exact U+XXXX and \u{...} syntax rules on a single page, which is handy when you need a clean reference alongside the tool.
Limits and edge cases on a mobile browser
The page caps a single conversion at 100,000 code points, which is enough for very long pasted strings but means a megabyte-scale dump will be truncated. Keep that cap in mind if you are inspecting a full log line or a configuration file. Beyond the cap, there are a few specific things the tool deliberately does not do, and listing them helps avoid misreading the output on a small screen.
- No UTF-8 byte output. The values shown are abstract code points. For byte-level work, use the UTF-8 converter — the two-byte UTF-8 representation of é is 0xC3 0xA9, which is not what you will find in this tool.
- No normalization. A precomposed é (U+00E9) and a decomposed e + combining acute (U+0065 U+0301) are treated as different sequences even though many fonts render them identically. That exactness is a feature when you are debugging why a search misses.
- No character names, scripts, or confusable status. The tool answers "which scalar values are in this string" and nothing more. Confusables, names, and script information live in separate Unicode properties.
- No grapheme clustering. The output is the scalar sequence, not a segmentation into user-perceived characters. For most diagnostic work that is exactly what you want.
- Surrogates are rejected. Inputs in the U+D800 to U+DFFF range never produce text, because they are not standalone scalar values. This avoids the common self-consistency trap where a wrong surrogate convention round-trips with itself.
On a phone specifically, two practical points help. First, the browser's paste menu sometimes strips a trailing newline or collapses multiple spaces, so if your debugging depends on invisible characters, paste from an app that preserves them and re-check the U+ list after conversion. Second, long output panels are easier to read in landscape orientation, where each token gets its own line without horizontal scrolling, which matters when you are scanning a string with mixed basic and supplementary characters.
For a deeper look, see ASCII Code Converter on Android: No App Required.