Subnet calculator for IPv4 and IPv6

An IPv4 address is 32 bits. The prefix length (the number after the slash) says how many of those bits, from the left, name the network. The rest name a host inside it. Everything else follows from that split. Take 192.168.1.77/26:

Address    192.168.1.77    11000000.10101000.00000001.01 001101
Mask /26   255.255.255.192 11111111.11111111.11111111.11 000000
                                                     network | host

Network    = address AND mask           -> 192.168.1.64
Broadcast  = network with host bits = 1 -> 192.168.1.127
Hosts      = 2^(32-26) - 2 = 64 - 2     -> 62  (192.168.1.65 to .126)
Wildcard   = NOT mask                   -> 0.0.0.63

A shortcut for masks that end inside one octet: subtract that octet from 256 to get the block size. For /26 the last octet of the mask is 192, so blocks are 64 apart (.0, .64, .128, .192), and .77 falls in the block that starts at .64. IPv6 works the same way with 128 bits, written in hex, and without a broadcast address.

Every IPv4 prefix length with its mask, wildcard mask and size. Usable hosts are the total minus the network and broadcast addresses, except /31 and /32. The binary converter shows how each mask octet looks in bits.

IPv6 subnets are almost always /64, because SLAAC (stateless address autoconfiguration) needs a 64-bit interface ID. Larger prefixes are handed out to sites and customers. There is no broadcast address; the first address of a subnet is the subnet-router anycast address.

The calculator writes IPv6 the way RFC 5952 asks: lowercase, no leading zeros, and the longest run of zero groups shortened to ::. It also shows the fully expanded form and the ip6.arpa name you need for reverse DNS.

The address type shown in the tool comes from the IANA special-purpose registries. The ranges you meet most:

Cloud providers keep a few addresses in every subnet for their own routers and DNS, so a /24 there gives you fewer than 254 hosts. The tool shows all three counts for any IPv4 subnet.

When you plan a VPC, size each subnet for the hosts you need plus these reserved addresses, and leave room to grow. The VLSM planner above packs subnets largest first so they never overlap. Running infrastructure as code? Browse DevOps tools on DevHunt, or turn a container command into a compose file with the docker run to compose converter.

Most languages ship this in the standard library, so you rarely need to write the bit math yourself.

# Python
import ipaddress
net = ipaddress.ip_network("192.168.1.77/26", strict=False)
net.network_address, net.broadcast_address   # 192.168.1.64, 192.168.1.127
net.netmask, net.hostmask, net.num_addresses # 255.255.255.192, 0.0.0.63, 64
list(net.subnets(new_prefix=28))             # split into four /28s
ipaddress.ip_address("192.168.1.100") in net # True
list(ipaddress.summarize_address_range(
    ipaddress.ip_address("10.0.0.5"), ipaddress.ip_address("10.0.0.100")))  # range to CIDR

// Go (net/netip)
p := netip.MustParsePrefix("192.168.1.77/26")
p.Masked()                                   // 192.168.1.64/26
p.Contains(netip.MustParseAddr("192.168.1.100")) // true

-- PostgreSQL
SELECT network('192.168.1.77/26'::inet),    -- 192.168.1.64/26
       broadcast('192.168.1.77/26'::inet),  -- 192.168.1.127/26
       netmask('192.168.1.77/26'::inet),    -- 255.255.255.192
       '192.168.1.100'::inet << '192.168.1.64/26'::cidr;  -- true

// JavaScript (no built-in, IPv4 only)
const toInt = ip => ip.split('.').reduce((n, o) => (n << 8) + +o, 0) >>> 0;
const mask = prefix => (prefix ? (~0 << (32 - prefix)) >>> 0 : 0);
const network = (toInt('192.168.1.77') & mask(26)) >>> 0;

In JavaScript, remember >>> 0: bitwise operators work on signed 32-bit integers, so without it any address above 127.255.255.255 comes out negative. For IPv6, use BigInt, which is what this calculator does. To read the hex form of an address as a number, try the hex to decimal converter.