Subnet calculator for IPv4 and IPv6.

For an IPv4 address and prefix it returns the network address, the usable host range, the broadcast address, the number of usable hosts and total addresses, the subnet mask, the wildcard mask, the address type (private, public, documentation and so on), the legacy class, the integer and hex forms and the reverse-DNS name. The binary view colours network bits and host bits so you can see exactly where the boundary falls.

The split slider divides the block into equal smaller subnets, up to 12 bits deeper, and lists each one with its host range and broadcast. Spaces around the slash are fine. Everything is plain arithmetic in your browser; nothing is looked up or sent anywhere.

An IPv4 address is 32 bits. The prefix length after the slash says how many leading bits identify the network; the rest identify hosts. A /24 leaves 8 host bits, so it holds 2^8 = 256 addresses. The subnet mask is the same idea written as an address: /24 is 255.255.255.0, /26 is 255.255.255.192. The 1 bits must be contiguous, so 255.0.255.0 is not a valid mask and the calculator says so.

The wildcard mask is the inverse of the subnet mask (0.0.0.63 for a /26). Cisco access lists and OSPF network statements use it. Usable hosts are the total minus two, because the all-zeros host address names the network and the all-ones address is the broadcast. Prefixes are also how routes are summarised: a router can announce 10.20.0.0/22 instead of four /24s, as long as they are contiguous and aligned.

To verify a result or answer an exam question, find the block size first: 256 minus the last mask octet that is not 255. For 255.255.255.192 that is 64, so networks start at .0, .64, .128 and .192. The address 192.168.10.77 falls in the block starting at .64, so the network is .64, the broadcast is one less than the next block (.127) and hosts run from .65 to .126.

The same trick works in any octet. A /20 has the mask 255.255.240.0, so the block size in the third octet is 256 - 240 = 16, and 10.1.37.9/20 belongs to 10.1.32.0/20, which runs to 10.1.47.255. Usable hosts are 2^(32 - prefix) - 2, so a /20 has 4,094.

For variable-length subnetting (VLSM), allocate the largest subnets first from the start of the block, then fill the remaining space with smaller ones, each aligned to its own size. The split table shows aligned boundaries, which is a quick way to see where a smaller subnet can legally start.

RFC 3021 lets point-to-point links use a /31 with both addresses as hosts, since a two-node link needs no network or broadcast address. A /32 is a single host, common in firewall rules and routing tables. The calculator follows both conventions.

Cloud networks reserve more. AWS and Azure reserve five addresses in every subnet (the first four and the last), so a /24 gives 251 usable addresses there. Google Cloud reserves four per primary range, leaving 252. Budget for this when you size small subnets for load balancers or databases.

RFC 1918 sets aside 10.0.0.0/8, 172.16.0.0/12 and 192.168.0.0/16 for private networks. 100.64.0.0/10 is shared space for carrier-grade NAT, 127.0.0.0/8 is loopback, 169.254.0.0/16 is link-local (also where cloud metadata services live), and 192.0.2.0/24, 198.51.100.0/24 and 203.0.113.0/24 are reserved for documentation. 224.0.0.0/4 is multicast.

Overlapping private ranges are the most common cause of VPN and peering trouble, which is why many organisations allocate 10.x blocks centrally rather than team by team. The address type row recognises all of these, which helps when you are reading someone else's firewall rules or deciding whether an address in a log is internal.

Start with a block large enough for growth, such as a /16 for a cloud VPC, and split it evenly: one subnet per availability zone and tier (public, private, data), with room left for zones and tiers you have not built yet. Make sure the range does not overlap your office network, VPN users or any network you may peer with later, because overlapping ranges cannot be routed and are painful to change.

Kubernetes changes the maths: with the AWS VPC CNI, for example, every pod takes an address from the subnet, so a small node subnet can run out of IPs long before it runs out of CPU. Our cloud consulting team plans these ranges as part of a landing zone, and Kubernetes for small teams covers when you need a cluster at all.

IPv6 addresses are 128 bits, written as eight groups of four hex digits. Leading zeros in a group can be dropped and one run of zero groups can be replaced by ::. The calculator shows both forms, using the canonical text format of RFC 5952.

Subnetting is simpler than in IPv4 because space is plentiful. A single LAN is a /64 (stateless address autoconfiguration needs exactly that), a site commonly receives a /48 or /56, and there is no broadcast address. fe80::/10 is link-local, fc00::/7 holds unique local addresses (in practice fd00::/8) and 2001:db8::/32 is for documentation. The calculator counts how many /64s fit in your prefix and splits it into smaller prefixes.

IPv6 also removes NAT from most designs: each device gets a globally unique address, and the firewall, not address translation, decides what is reachable. For dual-stack networks, give each IPv4 subnet a matching /64 so the two address plans stay easy to correlate.