Compress, expand, convert IPv4↔IPv6, and calculate subnets
IPv6 is the most recent version of the Internet Protocol, designed to replace IPv4 and address the critical shortage of available IP addresses. While IPv4 uses 32-bit addresses (about 4.3 billion total), IPv6 uses 128-bit addresses, providing approximately 3.4 × 10^38 unique addresses — enough for every atom on Earth's surface to have its own IP address. IPv6 addresses are written in hexadecimal notation, using eight groups of four hexadecimal digits separated by colons, such as 2001:0db8:85a3:0000:0000:8a2e:0370:7334. To make these long addresses more manageable, IPv6 supports several compression rules: leading zeros within each group can be omitted, and a single consecutive run of all-zero groups can be replaced with a double colon (::). Our IPv6 Address Converter tool helps network professionals and developers convert between different IPv6 formats, validate addresses, and understand the structure of IPv6 addressing for proper network configuration and troubleshooting.
Enter an IPv6 address in any valid format into the input field above. The tool accepts fully expanded notation (2001:0db8:85a3:0000:0000:8a2e:0370:7334), compressed notation (2001:db8:85a3::8a2e:370:7334), mixed IPv4-in-IPv6 notation (::ffff:192.168.1.1), or even IPv4-mapped addresses. You can paste addresses from router configurations, server logs, firewall rules, or any other source. The converter automatically detects the input format and processes it accordingly, so you do not need to specify what type of conversion you need — it generates all common formats simultaneously for your convenience.
The converter instantly displays your IPv6 address in multiple formats: fully expanded (all 32 hexadecimal digits, no compression), compressed (using :: for zero groups and omitting leading zeros), reverse DNS format (the nibble format used for PTR records), and the full 128-bit binary representation. It also shows the address type — whether it is a global unicast address, link-local address (fe80::/10), unique local address (fc00::/7), loopback address (::1), or any other IPv6 address category. Additionally, the tool extracts the network prefix and interface identifier portions, and can generate the EUI-64 based interface identifier from a MAC address when applicable.
Use the converted addresses directly in your network configuration, documentation, or code. The expanded format is useful for DNS zone files and comparison operations where exact string matching is needed. The compressed format is the standard for display and human-readable documentation. The reverse DNS nibble format is essential when creating PTR records in DNS for reverse lookups. The binary representation helps when studying how IPv6 addressing works or when configuring access control lists on routers that use binary matching. For developers working with IPv6 in applications, the tool ensures correct address normalization, preventing bugs caused by inconsistent address formatting across different systems and programming languages.
IPv6 address compression follows two main rules defined in RFC 5952. First, leading zeros within each 16-bit group can be omitted — so 0db8 becomes db8, and 0370 becomes 370. Second, one or more consecutive groups of zeros can be replaced with a double colon (::), but this can only be used once per address to avoid ambiguity. For example, 2001:0db8:0000:0000:0000:0000:0000:0001 compresses to 2001:db8::1. When multiple zero groups exist, the double colon should replace the longest consecutive run. If two runs have equal length, the first one should be compressed. Note that a single zero group can also be compressed with ::, so 2001:db8:0:0:1:0:0:1 becomes 2001:db8::1:0:0:1. Our converter handles all these rules automatically and always produces RFC 5952-compliant output.
IPv4-mapped IPv6 addresses are used to represent IPv4 addresses within the IPv6 address space, allowing dual-stack applications to handle both protocols simultaneously. These addresses use the format ::ffff:w.x.y.z, where w.x.y.z is an IPv4 address. For example, ::ffff:192.168.1.100 represents the IPv4 address 192.168.1.100 in IPv6 notation. They are particularly important in scenarios where an IPv6-enabled application needs to communicate with an IPv4-only server, or when a server needs to distinguish between connections from IPv4 and IPv6 clients. The operating system's networking stack handles the translation transparently. IPv4-compatible addresses (deprecated) used the format ::w.x.y.z without the ffff prefix, but these have been removed from the standard because they caused ambiguity. Our converter recognizes both formats and provides the corresponding representations.
IPv6 reverse DNS uses a completely different format than IPv4. Instead of the familiar in-addr.arpa domain, IPv6 uses ip6.arpa. Each hexadecimal digit of the fully expanded address is written in reverse order (least significant first) and separated by dots. For example, the address 2001:db8::1 (fully expanded as 2001:0db8:0000:0000:0000:0000:0000:0001) becomes 1.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.8.b.d.0.1.0.0.2.ip6.arpa. This reverse nibble format creates a DNS hierarchy that allows delegation of reverse lookup zones at any boundary, unlike IPv4 where delegation only occurs at octet boundaries. Creating correct PTR records is essential for mail server deliverability, network troubleshooting, and security auditing. Our converter generates the correct reverse DNS format automatically from any valid IPv6 address input.