UTF-8 Byte Analyzer
Analyze Unicode text byte by byte and see exactly how every character is represented in UTF-8. Inspect Unicode code points, byte positions, sequence lengths, hexadecimal values, decimal bytes, binary patterns and UTF-8 leading and continuation bytes.
—
| # | Character | Code Point | Bytes | Hex | Decimal | Binary | Byte Structure |
|---|
—
—
UTF-8 Byte Analyzer
The UTF-8 Byte Analyzer shows how text is represented as actual UTF-8 bytes. Instead of displaying only a converted byte string, the analyzer breaks the input into individual Unicode code points and explains the byte sequence used for every character.
This is useful when debugging encoded text, examining API payloads, studying Unicode, checking multilingual strings, investigating file encoding issues or understanding why apparently similar characters can occupy different numbers of bytes.
For every character, the analyzer reports the Unicode code point, UTF-8 byte count, hexadecimal bytes, decimal byte values, binary byte patterns and whether each byte is a leading byte or continuation byte.
How to Analyze UTF-8 Bytes
Enter Unicode text into the analyzer and select your preferred primary byte display. Hexadecimal is generally the easiest format for debugging, while binary is useful when studying the bit structure of UTF-8.
Press Analyze UTF-8 Bytes. The tool creates a complete byte stream and then separates the text into individual Unicode code points so you can inspect exactly how each character is encoded.
Input:
Hello €
UTF-8 bytes:
48 65 6C 6C 6F 20 E2 82 AC
The ASCII letters use 1 byte each.
The space uses 1 byte.
The euro sign uses 3 bytes.Understanding UTF-8 Byte Length
UTF-8 is a variable-length character encoding. A Unicode code point can use one, two, three or four bytes depending on its numeric value.
| Unicode Range | UTF-8 Length | First Byte Pattern | Example |
|---|---|---|---|
| U+0000–U+007F | 1 byte | 0xxxxxxx | A |
| U+0080–U+07FF | 2 bytes | 110xxxxx | é |
| U+0800–U+FFFF | 3 bytes | 1110xxxx | € |
| U+10000–U+10FFFF | 4 bytes | 11110xxx | 😀 |
Every additional byte in a multi-byte sequence is a continuation byte whose binary form begins with 10.
UTF-8 Byte Analysis Example: ASCII Character
ASCII characters occupy a single UTF-8 byte. This is one reason UTF-8 is compatible with ordinary ASCII data.
Character:
A
Unicode:
U+0041
UTF-8 bytes:
41
Decimal:
65
Binary:
01000001
Length:
1 byte
Byte type:
Single-byte ASCIIUTF-8 Byte Analysis Example: Accented Character
Characters outside the ASCII range may require additional bytes. The lowercase letter é has Unicode code point U+00E9 and requires two UTF-8 bytes.
Character:
é
Unicode:
U+00E9
UTF-8:
C3 A9
Decimal:
195 169
Binary:
11000011 10101001
Byte 1:
Leading byte
Byte 2:
Continuation byteUTF-8 Byte Analysis Example: Euro Sign
The euro sign is Unicode code point U+20AC. Because it falls within the U+0800 to U+FFFF range, UTF-8 represents it with three bytes.
Character:
€
Unicode:
U+20AC
UTF-8 hex:
E2 82 AC
Decimal:
226 130 172
Binary:
11100010 10000010 10101100
Byte 1:
Leading byte
Bytes 2–3:
Continuation bytesUTF-8 Byte Analysis Example: Emoji
Many emoji are represented by Unicode code points above U+FFFF and therefore need four UTF-8 bytes. The grinning face emoji is one common example.
Character:
😀
Unicode:
U+1F600
UTF-8:
F0 9F 98 80
Decimal:
240 159 152 128
Binary:
11110000 10011111 10011000 10000000
Length:
4 bytesLeading Bytes and Continuation Bytes
The first byte in a multi-byte UTF-8 sequence indicates how many bytes belong to the character. The remaining bytes are continuation bytes. This structure makes it possible for a UTF-8 decoder to identify character boundaries inside a byte stream.
2-byte sequence:
110xxxxx 10xxxxxx
3-byte sequence:
1110xxxx 10xxxxxx 10xxxxxx
4-byte sequence:
11110xxx 10xxxxxx 10xxxxxx 10xxxxxxA continuation byte always starts with the binary prefix 10. A valid continuation byte therefore falls between hexadecimal 80 and BF.
UTF-8 Hex, Decimal and Binary Bytes
The underlying byte value does not change when displayed in hexadecimal, decimal or binary. These are simply different number systems for representing the same eight-bit value.
UTF-8 byte:
Hex:
E2
Decimal:
226
Binary:
11100010
All three values represent the same byte.Hexadecimal is commonly used in programming documentation and hex dumps. Decimal byte values are often useful when working with byte arrays, while binary exposes the prefix bits that define UTF-8 sequence structure.
Character Count vs UTF-8 Byte Count
A character count and a byte count are not necessarily the same. English ASCII text frequently uses one byte per character, but international text and emoji can require two, three or four bytes for a single Unicode code point.
Text:
A€
Unicode code points:
2
UTF-8 bytes:
4
A = 1 byte
€ = 3 bytesThis distinction matters when calculating database storage, network payload size, protocol field limits and encoded message lengths.
Unicode Code Points vs UTF-8 Bytes
Unicode code points and UTF-8 bytes describe different layers of text representation. Unicode assigns a numeric code point to a character. UTF-8 defines how that code point is transformed into one or more bytes for storage or transmission.
Character:
€
Unicode identity:
U+20AC
UTF-8 storage representation:
E2 82 ACU+20AC is therefore not itself a UTF-8 byte sequence. It is the Unicode code point from which the UTF-8 bytes are produced.
Why Analyze UTF-8 Bytes?
Byte-level inspection can reveal problems that are difficult to see by looking at rendered text alone. Developers may need to confirm the exact bytes sent by an API, determine why a field exceeds a byte limit, compare apparently identical strings or inspect multilingual data.
UTF-8 analysis is also useful when troubleshooting databases, text files, communication protocols, binary formats, log data, imported CSV content and application interfaces where byte length matters.
Common use cases
Typical uses include inspecting UTF-8 payload sizes, checking emoji byte length, examining Unicode characters, learning UTF-8 bit patterns, debugging international text, comparing ASCII and Unicode storage and understanding hexadecimal dumps.
Common UTF-8 Byte Analysis Mistakes
One common mistake is assuming that every visible character occupies one byte. That is generally true for ASCII but not for the wider Unicode range.
Another mistake is treating JavaScript string length as the same thing as UTF-8 byte length. JavaScript internally represents strings using UTF-16 code units, while UTF-8 uses a separate variable-length byte encoding.
A third source of confusion is assuming that visually identical text must always contain identical Unicode code points. Some characters may have composed and decomposed Unicode representations, resulting in different UTF-8 byte sequences even though they render similarly.
UTF-8 Byte Analyzer Limitations and Notes
The analyzer reports Unicode code points rather than linguistic grapheme clusters. Some visible symbols can consist of multiple Unicode code points. Certain emoji, skin-tone modifiers, combining marks and zero-width-joiner emoji sequences are examples.
For that reason, what a person visually considers one character may occasionally appear as multiple entries in the detailed code-point analysis.
The analyzer processes text locally in your browser. Its purpose is byte-level Unicode inspection and not character-set detection for arbitrary uploaded binary files.