---
title: My ISP gave me a /56. Now what? How to plan IPv6 subnets with the IPv6 Subnet Calculator
description: Your ISP or cloud gives you an IPv6 prefix like 2001:db8:abcd:1200::/56, and you need to turn it into networks for the office, the guests and the servers. To plan IPv6 subnets, give every LAN its own /64 and count how many /64s your prefix holds: a /56 has 256, a /48 has 65,536. Here's how to work it out with the free IPv6 Subnet Calculator, and a Python check that lists every subnet.
canonical: https://watchfor.io/blog/how-to-plan-ipv6-subnets
---

# My ISP gave me a /56. Now what? How to plan IPv6 subnets with the IPv6 Subnet Calculator

2026-10-04 · WatchFor Team · Guides · guides, networking, basics

Your ISP or cloud gives you an IPv6 prefix like 2001:db8:abcd:1200::/56, and you need to turn it into networks for the office, the guests and the servers. To plan IPv6 subnets, give every LAN its own /64 and count how many /64s your prefix holds: a /56 has 256, a /48 has 65,536. Here's how to work it out with the free IPv6 Subnet Calculator, and a Python check that lists every subnet.

To plan IPv6 subnets, give every LAN or VLAN its own **/64** and number the
/64s inside the prefix you were assigned. A /56 leaves 8 bits between the
prefix and the /64 boundary, so it holds 2^8 = 256 LANs. A /48 holds 65,536,
a /60 holds 16. You don't count hosts as with IPv4: a single /64 has room
for more addresses than any network will ever use, and SLAAC, the way most
devices configure themselves, needs exactly a /64.

The free [IPv6 Subnet Calculator](/ipv6-subnet-calculator) shows any prefix's
first and last address, the exact address count, how many /64s fit, the
compressed and expanded forms, the address type and the `ip6.arpa` reverse
name. It runs in your browser. No signup.

## What this tool answers

*How big is this IPv6 prefix, where does it start and end, and how many
LANs can I make from it?* Reach for it when an ISP, a data centre or a cloud
VPC hands you a prefix, when you write firewall rules or routes for IPv6,
when you need the expanded form for a config file, or when you set up
reverse DNS for an IPv6 block.

## A real example

### Planning IPv6 subnets from an ISP prefix

A common situation with a business line: the ISP assigns a /56 via DHCPv6
prefix delegation, and the network needs a LAN for staff, one for guests,
one for servers and one for management, with room to grow. We used the
documentation prefix `2001:db8:abcd:1200::/56` in place of a real
assignment (`2001:db8::/32` is reserved for examples by RFC 3849, so it
never collides with anyone's network).

In the [IPv6 Subnet Calculator](/ipv6-subnet-calculator) we pasted
`2001:db8:abcd:1200::/56`:

![The IPv6 Subnet Calculator for 2001:db8:abcd:1200::/56: labelled Documentation (2001:db8::/32, reserved for examples and docs), compressed 2001:db8:abcd:1200::, expanded 2001:0db8:abcd:1200:0000:0000:0000:0000, first address 2001:db8:abcd:1200::, last address 2001:db8:abcd:12ff:ffff:ffff:ffff:ffff, 4,722,366,482,869,645,213,696 total addresses, 256 /64 subnets in this /56, and the ip6.arpa reverse DNS name](/blog/how-to-plan-ipv6-subnets-result.webp)

The prefix runs from `2001:db8:abcd:1200::` to
`2001:db8:abcd:12ff:ffff:ffff:ffff:ffff`: 4,722,366,482,869,645,213,696
addresses (2^72), and **256 /64 subnets**. The last address shows where the
space is: only the two hex digits after `12` change between LANs, `00` to
`ff`. Everything after them belongs to the hosts inside each /64.

So the plan writes itself, one hex pair per LAN:

| LAN | Prefix |
| --- | --- |
| Staff | `2001:db8:abcd:1201::/64` |
| Guests | `2001:db8:abcd:1202::/64` |
| Servers | `2001:db8:abcd:1203::/64` |
| Management | `2001:db8:abcd:1204::/64` |
| Spare | `2001:db8:abcd:1205::/64` … `12ff::/64` |

Entering `2001:db8:abcd:1203::/64` confirmed the server LAN: first address
`2001:db8:abcd:1203::`, last `2001:db8:abcd:1203:ffff:ffff:ffff:ffff`,
*This is one /64 LAN*.

**The answer:** a /56 is 256 LANs of one /64 each. Number them by the two hex
digits after `12`, matching the VLAN ID where you can (VLAN 3 → `1203`), and
keep `1200::/64` spare. That's four LANs used and 251 still free. If you need groups of
subnets per site or building, split on a nibble (4 bits = one hex digit):
the first digit gives 16 groups of 16 /64s.

## How to read the results

| Field | What it means |
| --- | --- |
| **Network (summary)** | The prefix in canonical form. Paste an address from the middle and it snaps to the start of its block. |
| **Type badge** | Global unicast (public, routable), Unique local (ULA, `fc00::/7`, private), Link-local (`fe80::/10`), Documentation, Multicast and more. The line under it explains the range. |
| **Compressed (RFC 5952)** | The canonical short form: leading zeros dropped, the longest run of zero groups replaced by `::`, lowercase. Use it in docs and logs. |
| **Expanded** | All eight groups of four hex digits. Some firewalls and scripts need it; it also makes nibble boundaries easy to see. |
| **First address / Last address** | Start and end of the prefix. With IPv6 there's no broadcast address to subtract. |
| **Total addresses** | The exact count, 2^(128 − prefix). |
| **/64 subnets in this /N** | How many LAN-sized subnets fit. At /64 it says *This is one /64 LAN*; longer prefixes are host scope. |
| **Reverse DNS (ip6.arpa)** | The address reversed one hex digit at a time under `ip6.arpa`, the name a PTR record lives at. |

## More ways to use it

- **Size a cloud VPC.** AWS assigns a /56 to a VPC and lets you give /64s
  to subnets. The calculator shows how many you can create and their
  ranges.
- **Write a firewall rule for a whole site.** Allow or deny the prefix
  (`2001:db8:abcd:1200::/56`), not individual addresses: devices pick new
  temporary addresses inside their /64 regularly.
- **Delegate reverse DNS.** For a /56, the reverse zone is the last 14 hex
  digits reversed: `2.1.d.c.b.a.8.b.d.0.1.0.0.2.ip6.arpa`. Mail servers need
  a PTR there; the [reverse DNS guide](/blog/how-to-do-a-reverse-dns-lookup)
  shows how to check one.
- **Check an address from your logs.** Paste it with `/64` to get the LAN it
  belongs to, then look the address up in the
  [IP Address Lookup](/ip-lookup) to see who owns it.
- **Compare with IPv4.** For IPv4 masks and host ranges, use the
  [Subnet Calculator](/subnet-calculator).

## Tips and gotchas

- **Don't make LANs smaller than /64.** SLAAC needs a 64-bit interface ID
  (RFC 4862, RFC 7421); Android, for example, doesn't use DHCPv6 for
  addresses, so a /80 LAN leaves it without one. Point-to-point links can use
  /127 (RFC 6164).
- **Plan on nibble boundaries.** Prefix lengths in steps of 4 (/48, /52, /56,
  /60, /64) line up with hex digits, so each subnet is one digit change and
  reverse DNS zones delegate cleanly.
- **Ask for a stable prefix.** Many residential ISPs change the delegated
  prefix on reconnect. Firewall rules and DNS with hard-coded prefixes break
  when that happens. Business lines usually get a static /56 or /48 (RIPE-690
  recommends a /48 per business site).
- **Use ULA for internal-only networks.** `fd00::/8` addresses (generate a
  random 40-bit Global ID, RFC 4193) stay stable even if the public prefix
  changes.
- **There's no NAT to hide behind.** Every device has a global address, so
  the firewall decides what's reachable. Default-deny inbound on the router.

## Check it from the command line too

Python's `ipaddress` module handles IPv6 the same way:

```bash
python3 -c "
n = ip.ip_network('2001:db8:abcd:1200::/56')
print(n.num_addresses, n[-1])
subs = list(n.subnets(new_prefix=64))
print(len(subs), subs[0], subs[3], subs[-1])
print(ip.ip_address('2001:db8:abcd:1203::1').reverse_pointer)"
```

```text
4722366482869645213696 2001:db8:abcd:12ff:ffff:ffff:ffff:ffff
256 2001:db8:abcd:1200::/64 2001:db8:abcd:1203::/64 2001:db8:abcd:12ff::/64
1.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.3.0.2.1.d.c.b.a.8.b.d.0.1.0.0.2.ip6.arpa
```

The total, the last address and the 256 /64s match the calculator; the last
line is the reverse name for a host on the server LAN. On a Linux host,
`ip -6 addr` shows the addresses and prefix lengths an interface actually
has, and `ip -6 route` shows the delegated prefix and the default route.

## FAQ

**How many /64s are in a /48?**
65,536 (2^16). A /52 has 4,096, a /56 has 256 and a /60 has 16. Each step of
4 bits is a factor of 16.

**Why is the IPv6 subnet always /64?**
Stateless address autoconfiguration builds a device's address from the
64-bit network prefix plus a 64-bit interface ID, so LANs must be /64 for it
to work. [IPv4 vs IPv6](/blog/ipv4-vs-ipv6) covers the background.

**What prefix size should I ask my ISP for?**
A /48 per business site, if the ISP follows RIPE-690; a /56 is common for
homes and small offices. Either leaves plenty of /64s. More on addresses in
[what is an IP address](/blog/what-is-an-ip-address).

---

Canonical page: https://watchfor.io/blog/how-to-plan-ipv6-subnets · All articles: https://watchfor.io/blog/all.md · Site guide: https://watchfor.io/llms.txt