IPv6 subnet calculator

The formula, with a worked example

• An IPv6 address is 128 bits, written as eight groups of four hex digits. Each hex digit is 4 bits, so each group is 16 bits.
• Network prefix = address AND mask, where the mask is the prefix length in ones and the rest zeros: 2001:db8:abcd:12::1 with /64 keeps the first four groups, 2001:db8:abcd:12::.
• Last address = network OR NOT mask, every host bit set to 1: 2001:db8:abcd:12:ffff:ffff:ffff:ffff.
• Total addresses = 2^(128 − prefix): a /64 holds 2^64 = 18,446,744,073,709,551,616.
• Number of /64 subnets = 2^(64 − prefix) for prefixes up to /64: a /48 holds 2^16 = 65,536 of them, and a /56 holds 2^8 = 256.
• IPv6 has no broadcast address, so nothing is subtracted from the total.

Reading an IPv6 address

An IPv6 address is 128 bits long, four times the length of an IPv4 address. It is written as eight groups of four hexadecimal digits separated by colons, for example 2001:0db8:abcd:0012:0000:0000:0000:0001. Two shortening rules make it easier to read. Leading zeros in a group can be dropped, so 0db8 becomes db8 and 0012 becomes 12. And one run of groups that are all zero can be replaced with a double colon, so the address above becomes 2001:db8:abcd:12::1.

The double colon can only appear once, because otherwise there would be no way to tell how many zero groups each one stands for. The calculator accepts either form and shows its answers both ways: the short form defined in RFC 5952, and the expanded form with all 32 hex digits, which is easier to line up when you compare addresses.

How the prefix splits the address

The prefix length works exactly as it does in IPv4: it counts how many bits from the left are the network part. Because each hex digit is 4 bits, prefixes that are multiples of 4 fall on a digit boundary and multiples of 16 fall on a group boundary. A /48 keeps the first three groups, a /56 keeps the first three groups and two digits of the fourth, and a /64 keeps the first four groups.

Take 2001:db8:abcd:12ff::/56. The first 56 bits are 2001:0db8:abcd:12, the next 8 bits (ff) belong to the host part, so the network is 2001:db8:abcd:1200::/56. Its last address sets every one of the remaining 72 bits to 1: 2001:db8:abcd:12ff:ffff:ffff:ffff:ffff. The prefix holds 2^72 = 4,722,366,482,869,645,213,696 addresses, or 256 subnets of /64 each.

When a prefix does not fall on a digit boundary, say a /61, the split happens inside a hex digit. Convert that one digit to its four bits, keep the bits the prefix covers and zero the rest. The calculator does this for any prefix from 0 to 128.

Why the /64 count matters

In IPv6 the /64 is the usual size of a single subnet, the size most address auto-configuration expects. So the useful question about a larger prefix is often not how many addresses it has, which is always enormous, but how many /64 subnets fit inside it. That number is 2^(64 − prefix). A /48 holds 65,536 subnets of /64, a /52 holds 4,096, a /56 holds 256 and a /60 holds 16.

The address counts are exact. The calculator works them out digit by digit rather than with floating-point numbers, so a /32 shows all 29 digits of 79,228,162,514,264,337,593,543,950,336 instead of a rounded figure.

Edge cases: /127, /128 and no broadcast

IPv6 has no broadcast address. The job broadcast does in IPv4 is done by multicast, so the last address of a prefix is an ordinary address and nothing is subtracted from the count. That is why this page shows a total and a range rather than a usable host count with two taken away.

A /127 holds exactly two addresses, and RFC 6164 describes using it on point-to-point links, much like an IPv4 /31. A /128 is a single address. Both are shown with their real counts of 2 and 1.

The documentation prefix 2001:db8::/32 (RFC 3849) is reserved for examples like the ones on this page, so they never point at a real network.