Hex to IP Converter

About this tool

Hex to IP converts 8-character hexadecimal strings into standard IPv4 dotted-decimal notation. IPv4 addresses are often stored or transmitted as 32-bit hex values in network protocol headers, embedded firmware, Windows registry entries, and SIEM log exports. This tool decodes those values into the readable form you can recognize and use immediately.

Real example

Input: C0A80101

Each pair of hex digits represents one 8-bit octet:
C0 = 192 (12×16 + 0)
A8 = 168 (10×16 + 8)
01 = 1
01 = 1
Result: 192.168.1.1 - the default gateway on most home networks.

The 0x prefix is optional - both C0A80101 and 0xC0A80101 work. Uppercase and lowercase hex are both accepted.

Common use cases

• Packet capture analysis: Wireshark and tcpdump sometimes display IP addresses as raw hex in the packet bytes view. Paste the 8-character value here to read the address without mental arithmetic.
• Embedded firmware and system code: IP addresses in C, Rust, or assembly are often defined as hex constants like 0xC0A80101. Decode them here to verify what address is actually hardcoded.
• Log file parsing: Some SIEMs, firewalls, and load balancers log IPv4 addresses as unsigned 32-bit hex values. This converter bridges the gap between raw log data and readable IPs.
• Windows registry inspection: Windows stores certain IP values in hex format in the registry. This tool decodes them in one step.

How it works

The input is first lowercased and any 0x prefix is stripped. All non-hexadecimal characters are removed. The result must be exactly 8 hex characters. These 8 characters are split into four 2-character pairs, and each pair is parsed with parseInt(pair, 16) to produce a decimal octet. The four octets are joined with dots.

Common mistakes

• Odd-length input: Hex pairs must be complete - if your string is 7 characters, you likely have a leading zero stripped somewhere. 0A is different from A; a missing leading zero changes the octet value entirely.
• Wrong byte order: Some protocols (notably little-endian x86 systems) store IP bytes in reversed order. If the converted IP looks wrong, try reversing the byte pairs: 0101A8C0 instead of C0A80101.
• Confusing with IPv6: IPv6 hex notation is 32 characters (128 bits). This tool only handles 8-character IPv4 values. For IPv6 binary work, use the IPv6 to Binary tool.

FAQ

Does it matter if I use uppercase or lowercase hex
No. Both are normalized before conversion. c0a80101 and C0A80101 produce the same result.

Can I include the 0x prefix
Yes. The 0x prefix is stripped automatically. You can paste values directly from code or a hex editor.

What if I need to go the other direction - IP to hex
Use the IP to Hex tool to convert a dotted-decimal address back to its 8-character hex representation.

Why does the converted IP look like a multicast or private address
The converter just does the math - it does not classify ranges. If you need to know what range an IP belongs to, check the result against RFC 1918 (private: 10.x, 172.16-31.x, 192.168.x) or RFC 5771 (multicast: 224.x-239.x).

Where hex IP addresses appear in practice

Hexadecimal IP representation is most commonly encountered in three places: low-level network protocol debugging, operating system internals, and application log formats that were not designed with human readability as a priority.

Linux /proc/net/tcp: The kernel's TCP connection table at /proc/net/tcp and /proc/net/tcp6 lists all open TCP sockets. The local and remote addresses are stored as little-endian hex integers — 0100007F is 127.0.0.1 in little-endian byte order (bytes reversed). Parsing this file is a common task when writing network monitoring tools or when ss and netstat are unavailable in a stripped environment.

Packet captures and hex editors: In a raw packet hex dump, the IP header starts at byte 12 (after Ethernet frame headers). Bytes 12-15 are the source IP and bytes 16-19 are the destination — four bytes each in big-endian order. When reviewing a Wireshark hex pane or a tcpdump hex dump, converting these 8 hex digits gives you the source and destination addresses without needing the protocol decoder.

Web server logs (some formats): Apache and nginx log IPs in dotted-decimal by default, but some custom logging configurations, CDN access logs, or older application frameworks store IPs in hex. This is also common in DRM systems, some embedded device logs, and Windows event logs for certain network events where the DWORD representation is logged directly.

Hex to IP conversion: the math

An 8-character hex string represents a 32-bit value. Split it into four 2-character pairs. Each pair is one octet. Convert each pair from hex to decimal: c0 = 192, a8 = 168, 01 = 1, 01 = 1. Result: 192.168.1.1.

Watch for byte order. Most network protocols and tools use big-endian (network byte order) — the most significant byte is first. But Linux /proc/net/tcp uses little-endian — bytes are reversed. If a converted IP looks nonsensical, try reversing the byte pairs before converting. C0A80101 big-endian = 192.168.1.1; the same bytes little-endian would be 0101A8C0 (reading the source as C0 A8 01 01 reversed to 01 01 A8 C0 = 1.1.168.192).

Common hex IP values

7F000001 — 127.0.0.1. Localhost loopback. The most commonly recognized hex IP.

C0A80001 — 192.168.0.1. Default gateway for many home routers.

0A000001 — 10.0.0.1. Common first-address in a cloud VPC or corporate 10.x network.

FFFFFFFF — 255.255.255.255. Limited broadcast address.

00000000 — 0.0.0.0. Default route or unspecified/any-interface address.

For the reverse direction, use IP to Hex. For integer form of the same address, see IP to Decimal. For binary form and subnet masking, use IP to Binary.