JSONToonPro
Number tool

Hex to Text Converter

Convert a hexadecimal string back into readable text, accepting spaced or unspaced hex and 0x prefixes, decoded as UTF-8. Everything runs 100% client-side in your browser.

100% client sideInstant resultNo data sent
Hex input
0 chars
Text output
Result appears here...

How to Convert Hex to Text

Decoding hex back to text is the step you take when reading a hex dump, inspecting a packet capture, or recovering a string from raw binary data. Every pair of hex digits is one byte, and every byte maps to a character.

  1. Remove any formatting first: spaces, commas, and 0x prefixes are not part of the data.
  2. Split the remaining digits into pairs, working from the left. Each pair is one byte.
  3. Convert each pair from base 16 to decimal. The left digit is worth sixteen times the right digit, so 43 is 4 times 16 plus 3, which is 67.
  4. Look up each decimal value in an ASCII table and write out the matching character.

Worked example: decoding 43 6F 64 65

43 = (4 × 16) + 3 = 67 = C
6F = (6 × 16) + 15 = 111 = o
64 = (6 × 16) + 4 = 100 = d
65 = (6 × 16) + 5 = 101 = e

43 6F 64 65 = "Code"

Reading a Hex Pair

In a two digit hex byte the left digit carries the high four bits and the right digit carries the low four bits. The left digit is multiplied by 16 and the right digit is added to it, so the range runs from 00 (zero) up to FF (255).

That is the entire range a single byte can hold. Values 32 to 126 are the printable ASCII characters, values below 32 are control codes such as tab and newline, and values above 127 belong to multi byte UTF-8 sequences.

ASCII, Unicode, and UTF-8

ASCII is the original character encoding standard, finalised in 1963. It defines 128 characters: the English alphabet in both cases, the digits 0 to 9, common punctuation, and 33 non printing control codes such as tab, newline, and carriage return. Because 128 values fit in seven bits, every ASCII character fits comfortably inside a single byte.

ASCII covers English and almost nothing else, which is why Unicode exists. Unicode assigns a number, called a code point, to every character in every writing system, plus symbols and emoji. UTF-8 is the encoding that turns those code points into bytes, and it was designed so that the first 128 code points encode to exactly the same single bytes as ASCII. That backward compatibility is why plain English text looks identical in both.

The practical consequence for this tool: English letters, digits, and punctuation each produce one byte. Accented characters, Greek, Cyrillic, Arabic, and CJK characters produce two or three bytes each, and emoji usually produce four. The converter handles all of them correctly using UTF-8.

Where Hex Decoding Fails

  • An odd number of hex digits cannot be decoded, because bytes always come in pairs. This usually means a digit was dropped when copying.
  • Any character outside 0 to 9 and A to F is invalid. Stray punctuation from a copy and paste is the usual cause.
  • Bytes above 7F will not produce sensible characters on their own. They are part of a UTF-8 sequence and need the following bytes to decode correctly.

ASCII Conversion Table

Every printable ASCII character with its decimal code, hexadecimal byte, and binary byte. Codes 0 to 31 are control characters and are not printable, so they are not listed here.

CharDecHexBinary
space322000100000
!332100100001
"342200100010
#352300100011
$362400100100
%372500100101
&382600100110
'392700100111
(402800101000
)412900101001
*422A00101010
+432B00101011
,442C00101100
-452D00101101
.462E00101110
/472F00101111
0483000110000
1493100110001
2503200110010
3513300110011
4523400110100
5533500110101
6543600110110
7553700110111
CharDecHexBinary
8563800111000
9573900111001
:583A00111010
;593B00111011
<603C00111100
=613D00111101
>623E00111110
?633F00111111
@644001000000
A654101000001
B664201000010
C674301000011
D684401000100
E694501000101
F704601000110
G714701000111
H724801001000
I734901001001
J744A01001010
K754B01001011
L764C01001100
M774D01001101
N784E01001110
O794F01001111
CharDecHexBinary
P805001010000
Q815101010001
R825201010010
S835301010011
T845401010100
U855501010101
V865601010110
W875701010111
X885801011000
Y895901011001
Z905A01011010
[915B01011011
\925C01011100
]935D01011101
^945E01011110
_955F01011111
`966001100000
a976101100001
b986201100010
c996301100011
d1006401100100
e1016501100101
f1026601100110
g1036701100111
CharDecHexBinary
h1046801101000
i1056901101001
j1066A01101010
k1076B01101011
l1086C01101100
m1096D01101101
n1106E01101110
o1116F01101111
p1127001110000
q1137101110001
r1147201110010
s1157301110011
t1167401110100
u1177501110101
v1187601110110
w1197701110111
x1207801111000
y1217901111001
z1227A01111010
{1237B01111011
|1247C01111100
}1257D01111101
~1267E01111110

Looking for a different conversion? Browse every developer tool including binary, hex, octal, and Base64 converters.

Frequently asked questions

4 answers
The converter reads your hexadecimal input two digits at a time, since each byte is written as a pair of hex characters. It turns every pair back into its byte value, then decodes the resulting bytes as UTF-8 to reconstruct the original characters. For example, the hex pair 41 becomes the byte 65, which UTF-8 decodes to a capital A.

More JSON Tools

About the Hex to Text Converter

When you copy bytes out of a hex dump, a network trace, or a debugger, they arrive as hexadecimal that is hard to read at a glance. This converter turns that hex back into text: it accepts spaced bytes, tightly packed hex, and values carrying a 0x prefix, strips the separators, and decodes the bytes as UTF-8 so multi-byte characters reassemble correctly. If the digit count is odd, meaning a byte is incomplete, it flags the problem instead of producing garbage. All of this happens locally in your browser, so the data you decode never touches a server.