Binary to Hexadecimal Converter — Compact Bits into Hex

Compress long binary strings into compact hexadecimal. Because one hex digit equals four binary bits, the conversion is a straight lookup — no base-10 detour, no floating-point drift. Useful for hex dumps, color codes, and reading raw byte values.

How binary to hex works

Group the bits into 4-bit nibbles starting from the right. Each nibble maps to one hex digit: 0000=0, 1010=A, 1111=F. If the bit-count is not a multiple of 4, the tool left-pads with zeros so nothing gets mis-aligned.

Quick examples

How to use

1. Paste your binary into Input. Spaces between bits or nibbles are stripped before grouping.
2. Hex appears in Output, upper-case, no 0x prefix. Add the prefix yourself if you need it.
3. To go the other way, hit Hex → Binary at the top, or press Swap.
4. Tap Copy to grab the hex string. All conversion happens client-side.

Real-world use cases

• Memory dumps and debugger output. An 8-, 16-, or 32-bit register collapses from a wall of 0s and 1s into 2, 4, or 8 hex characters, which fits one screen line and stays readable when you scan a backtrace.
• Hash and cryptographic inspection. SHA-256, MD5, and HMAC outputs are almost always presented as hex. Flipping a hex digest back to binary via hex to binary lets you compare bit patterns when verifying a one-bit change or studying the avalanche effect.
• CSS and design tokens. A color like #FF00FF splits into three byte-aligned channels; sliding each channel back to binary shows exactly which bits drive red, green, and blue, which is handy when explaining color depth or alpha blending.
• Byte-boundary recognition. Because 8 bits land neatly on 2 hex digits, hex makes it obvious where one byte ends and the next begins — something that's almost impossible to eyeball in a long binary string without counting.
• Teaching base systems. Hex is the cleanest bridge between base-2 and the higher-radix worlds students see in decimal work; the rule "4 bits = 1 hex digit" is the first piece of bit-twiddling intuition that actually sticks.
• Packet and protocol analysis. Wireshark, tcpdump, and most protocol decoders print byte streams in hex by default. Converting a suspicious field back to binary is often how you spot a misaligned flag bit or an off-by-one length header.

Why hex is binary's natural shorthand

Hexadecimal won out as binary's everyday shorthand for one reason: 16 is a power of two. Because 2⁴ = 16, every group of 4 bits maps to exactly one hex digit with no leftover and no arithmetic — a property no other common base shares. Base-10, the system humans actually count in, can't do this: a decimal digit covers the range 0-9, which doesn't align with any whole number of bits, so binary-to-decimal conversion always involves division and remainders.

Early machines didn't all settle on hex straight away. Word-oriented systems from the late 1950s and early 1960s, such as the 36-bit IBM 7090 and the later PDP-series minicomputers, often displayed memory in octal (base-8), since 3 bits per octal digit fit a 36-bit word evenly. Hex pulled ahead once the 8-bit byte became the universal unit — a shift driven largely by IBM's System/360 in the mid-1960s, which standardised the 8-bit byte across an entire product line. After that, "1 byte = 2 hex digits" was simply too convenient to ignore.

The choice of A-F for the values 10-15 is also an IBM legacy. Earlier experimental systems had tried other glyphs (some used U-Z, others picked Greek letters), but IBM's documentation for the System/360 era settled on 0-9 followed by A-F, and that convention was later locked in by ANSI and IETF standards. This converter follows it: digits are upper-case by default, odd-length inputs are left-padded with zeros to the next multiple of 4, and any whitespace between groups is silently ignored before conversion.

Worked examples

A few inputs done by hand show the 4-bit grouping rule in action:

Common pitfalls

• Case mixing. The output is upper-case A-F, but the reverse direction (hex to binary) accepts either case. Don't waste time normalising case before pasting — the parser handles it.
• Reading hex as decimal. 10 in hex is 16 in decimal, not ten. If a register dump shows FF and you mentally read it as "ninety-nine", every downstream calculation will be off. When in doubt, route the value through a known-good binary translator to cross-check.
• Losing byte boundaries. F0AA looks like four hex characters but is actually two bytes (F0 and AA). When copying into a protocol field that expects a byte count, divide the hex length by 2, not by 4.
• Confusing this output with IPv6. IPv6 addresses also use hex, but they're written in colon-separated groups of four hex characters (fe80::1), with lower-case letters and a special :: shorthand for runs of zeros. This converter produces plain, unseparated upper-case hex — paste it into an IPv6 context and the format won't match.
• Separators in the input. Any whitespace inside the binary input is stripped before grouping, so 1111 0000 and 11110000 produce the same result. Non-binary characters (anything other than 0, 1, or whitespace) are flagged rather than silently dropped.