Hex to IP Address Converter

Paste C0A80001, 0x0A000032, or a 0100007F:1F90 line from /proc/net/tcp. Get the dotted IPv4 or short IPv6 address, every byte decoded, plus the range the address belongs to.

Waiting for input

8 hex digits for IPv4, 32 for IPv6. A 0x prefix, spaces, colons, and dots between bytes get stripped.

Byte order

Paste a hex value or press Load sample. The first valid line gets a full byte breakdown here.

Reading a hex address one byte at a time

Two hex digits make one byte. An IPv4 address holds four bytes, so eight digits. Take 0A000032:

  1. Split into pairs. 0A, 00, 00, 32.
  2. Convert each pair. Multiply the first digit by 16, add the second. A counts as 10, so 0A is 10. 32 is 3 × 16 + 2 = 50.
  3. Join with dots. 10.0.0.50.

The byte strip in the converter shows each pair in decimal and binary. Binary helps when you check where a /20 or /27 boundary falls inside an octet.

Hex pairDecimalWhere you see it first
0A10Leading byte of the 10.0.0.0/8 private block
64100Leading byte of 100.64.0.0/10 carrier NAT
7F127Loopback, 127.0.0.1
AC172Leading byte of 172.16.0.0/12 private block
C0 A8192 168Home and office LANs, 192.168.0.0/16
FF255Subnet mask bytes, broadcast addresses

Why 0100007F means 127.0.0.1

Linux lists open sockets in /proc/net/tcp and /proc/net/udp. Each address is a raw 32-bit number printed in host byte order. On x86 and ARM, host order is little-endian, so the four bytes come out reversed:

  sl  local_address rem_address   st
   0: 0100007F:1F90 00000000:0000 0A
   1: 0A01A8C0:0016 6401A8C0:D2F4 01

Line 0 is 127.0.0.1 listening on port 8080. Line 1 is an SSH session from 192.168.1.100 to 192.168.1.10. The port after the colon stays in normal order, since the kernel prints the port as a plain number. Set Byte order to Little-endian, paste both lines, and the table lists address and port for each.

Where hex addresses turn up

SourceLooks likeByte order
Wireshark bytes pane, tcpdump -Xc0 a8 01 0aNetwork
/proc/net/tcp, /proc/net/udp on x86 or ARM0A01A8C0:0050Little-endian
/proc/net/tcp6 on x86 or ARM32 digits as four 8-digit wordsLittle-endian per word
/proc/net/if_inet6fe800000000000000000000000000001Network
PXELINUX config file namespxelinux.cfg/C0A8010ANetwork
C code printing s_addr with %08X on x860A01A8C0Little-endian
Python hex(int(ipaddress.ip_address(...)))0xc0a8010aNetwork

Little-endian mode on a 32-digit IPv6 value reverses bytes inside each 8-digit word, which matches how /proc/net/tcp6 prints addresses. The words themselves keep their position.

IPv6: 32 digits in, short form out

IPv6 output follows RFC 5952. Letters go lowercase, leading zeros inside each group drop, and the longest run of two or more zero groups collapses to ::. So 20010DB8000000000000000000000001 prints as 2001:db8::1.

When the first 80 bits are zero and the next 16 are ffff, the result prints as an IPv4-mapped address such as ::ffff:192.168.1.10. Dual-stack servers write client addresses this way in access logs, so the embedded IPv4 address is the one to look up.

Limits worth knowing

  • 8 or 32 digits only. Shorter IPv4 values get zeros on the left, so 0xA000001 reads as 10.0.0.1. A 12-digit MAC address or a 16-digit value gets rejected.
  • No prefix lengths. A trailing /24 fails. Work out network and broadcast addresses in a subnet calculator after you decode the address.
  • No Class A, B, or C label. Classful addressing ended with CIDR in 1993. The result names the registered range instead: private, loopback, carrier NAT, documentation, multicast, or public.
  • Already-formatted IPv6 with :: gets refused. Shortened text is not raw hex. Paste the full 32-digit value.
  • No lookups. The page decodes numbers. For the host behind an address, use IP to Hostname.

Hex to IP questions

Byte order, input formats, and the ranges the converter reports.

How do I convert hex to an IP address by hand?

Split the eight hex digits into four pairs. Convert each pair to decimal by multiplying the first digit by 16 and adding the second, with A to F standing for 10 to 15. C0A80001 gives C0 = 192, A8 = 168, 00 = 0, 01 = 1, so the address is 192.168.0.1.

Why does my hex value give a backwards address?

The value was written in little-endian byte order, the default on x86 and ARM machines. Linux socket tables and C programs printing s_addr with %08X both produce reversed bytes. Switch Byte order to Little-endian, or read the opposite-order line under the result.

What does 0100007F:1F90 mean in /proc/net/tcp?

On a little-endian host, 0100007F is 127.0.0.1 with the bytes reversed, and 1F90 is port 8080. The kernel prints the port as a plain number, so only the address needs flipping. Paste the pair as one line and the converter shows both parts.

Which input formats does the converter accept?

One value per line. Plain C0A80001, a 0x prefix, byte pairs split by spaces, colons, dots, or dashes (C0 A8 00 01), and address:port pairs from /proc/net/tcp. Pairs with a single digit, such as C0:A8:0:1, get padded per byte.

Why does 64400001 show as shared address space?

100.64.0.0/10 is reserved for carrier-grade NAT under RFC 6598. Mobile carriers and some ISPs hand these addresses to customers behind a shared public address. They are not reachable from the internet, though they are not private in the RFC 1918 sense either.

Does the page send my addresses anywhere?

No. Parsing, byte swapping, and range lookup all run in your browser. Nothing gets logged or sent to Toolexe, so pasting lines from a production server log stays on your machine.