Supernet Aggregation Calculator
Aggregate two to six IPv4 networks into a single CIDR summary route. Enter each network and prefix, then get the summary supernet, its subnet mask, the total addresses the route covers, and how many extra addresses it pulls in beyond your inputs so you can spot over-aggregation before you advertise it.
đĄReal Aggregation Presets
âAggregation Settings
Fill in this many rows below.
Common prefix shares leading bits; contiguous assumes aligned equal blocks.
Displays the address span of the summary.
đ„Network Entries
Each row is one network address with its CIDR prefix length. Only the number of rows chosen above is used.
đąAggregation Snapshot
đContiguous Block Aggregation
| Blocks (N) | Input Prefix | Bits Saved | Summary Prefix | Example Summary |
|---|---|---|---|---|
| 2 | 2 x /24 | 1 | /23 | 10.0.0.0/23 |
| 4 | 4 x /24 | 2 | /22 | 10.0.0.0/22 |
| 8 | 8 x /24 | 3 | /21 | 10.0.0.0/21 |
| 16 | 16 x /24 | 4 | /20 | 10.0.0.0/20 |
| 2 | 2 x /16 | 1 | /15 | 172.16.0.0/15 |
| 4 | 4 x /16 | 2 | /14 | 172.16.0.0/14 |
| 2 | 2 x /25 | 1 | /24 | 192.168.0.0/24 |
| 4 | 4 x /26 | 2 | /24 | 192.168.0.0/24 |
| 8 | 8 x /27 | 3 | /24 | 192.168.0.0/24 |
| 256 | 256 x /24 | 8 | /16 | 10.1.0.0/16 |
đPrefix, Mask, and Address Count
| Prefix | Subnet Mask | Host Bits | Total Addresses | Equivalent |
|---|---|---|---|---|
| /8 | 255.0.0.0 | 24 | 16,777,216 | One class A |
| /12 | 255.240.0.0 | 20 | 1,048,576 | 16 x /16 |
| /15 | 255.254.0.0 | 17 | 131,072 | 2 x /16 |
| /16 | 255.255.0.0 | 16 | 65,536 | One class B |
| /20 | 255.255.240.0 | 12 | 4,096 | 16 x /24 |
| /22 | 255.255.252.0 | 10 | 1,024 | 4 x /24 |
| /23 | 255.255.254.0 | 9 | 512 | 2 x /24 |
| /24 | 255.255.255.0 | 8 | 256 | One class C |
đAlignment Rules for Clean Summaries
| Rule | Requirement | Good Example | Fails When |
|---|---|---|---|
| Equal size | All blocks same prefix | Four /24s | Mixing /24 and /25 |
| Power of two | Count is 2, 4, 8, 16 | Eight /26s | Three /24s together |
| Boundary start | First block on the summary boundary | .0 for /22 | Starting at .1.0 |
| Contiguous | No gaps between blocks | .0 .1 .2 .3 | .0 .1 .3 missing .2 |
| Bits saved | log2(N) shortens prefix | 4 blocks save 2 | Not a power of two |
| No overlap | Summary stays inside its class scope | /22 within /16 | Crossing major bounds |
đAggregation Comparison Grid
| Input Networks | Summary Route | Prefix | Mask | Addresses | Validity Note |
|---|---|---|---|---|---|
| 192.168.0.0/24 to .3.0/24 | 192.168.0.0/22 | /22 | 255.255.252.0 | 1,024 | Exact, no waste |
| 10.0.0.0/24 + 10.0.1.0/24 | 10.0.0.0/23 | /23 | 255.255.254.0 | 512 | Exact pair |
| 172.16.0.0/16 + 172.17.0.0/16 | 172.16.0.0/15 | /15 | 255.254.0.0 | 131,072 | Exact, aligned |
| 10.0.0.0/24 + 10.0.5.0/24 | 10.0.0.0/21 | /21 | 255.255.248.0 | 2,048 | Over-aggregates 1,536 |
| 192.168.1.0/24 to .4.0/24 | 192.168.0.0/21 | /21 | 255.255.248.0 | 2,048 | Not aligned, overreach |
| 10.1.0.0/16 to 10.4.0.0/16 | 10.0.0.0/13 | /13 | 255.248.0.0 | 524,288 | Wide, includes extras |
| 10.0.0.0/25 + 10.0.0.128/25 | 10.0.0.0/24 | /24 | 255.255.255.0 | 256 | Two halves rejoin |
| 192.168.8.0/24 to .15.0/24 | 192.168.8.0/21 | /21 | 255.255.248.0 | 2,048 | Eight blocks, exact |
âFormula Breakdown
đĄRoute Summarization Tips
Over time, routing tables fills with extra routes. Whenever you bring up a new subnet, all the routers along the way has to check, advertise, and store it in their routing table. Add enough small block like this and you end up with a makeshift network. By supernetting, you turn this mess into order by combining multiple smaller networks under a single larger prefix. That cuts down dozens of routes to just one route.
It sounds easy enough, right? The problem is doing the math to find summary without summarizing someone elseâs address space. Bitwise arithmetic! Fortunately, the calculator above take care of that for you while you decide if summary will fit your setup.
How Supernetting Helps Your Network
This is basic idea. Routing relies on leading bits aligning with each other. IPv4 addresses are 32-bit numbers, so theyâre represented as binary numbers. For instance, if we take two addresses like 192.168.0.0/24 and 192.168.1.0/24, they looks like this in binary: The key point is that the first 23 bits aligns. Only at bit 24 do the two differ. Masking off the final bit gives us a /23 address that encompasses both of the original /24s perfectly.
When blocks of addresses line up neatly against power-of-two boundaries, this is all very clean. Two /24s make a /23; four /24s are a /22, etc. But if the blocks arenât aligned or is spread out, then this goes south immediately. Strict common-prefix mode will find the biggest shared prefix no matter how misaligned the addresses are. However, contiguous block mode assume perfect adjacent blocks and uses a quicker formula.
Over aggregation is not a problem with math itself. Itâs something most network designer screw up because their networks arenât contiguous. This means you end up advertising routes for networks that donât actualy belong to you. Because you donât actually have the address space in between, the router has to blow out your prefix to include all the space to make it one route for both sets of addresses. Instead of advertising only your 512 IP addresses, youâre now advertising a /21 which include 2,048 addresses. So youâre advertising space for other peoples networks or unallocated space. Any traffic going to those non-existent subnets ends up getting directed at you and falling into a black hole. The âover aggregationâ metric in the above shows exactly how many additional IPs youâre claiming. If thatâs high then your summary is too loose. Either rearrange your subnetting to conform to a clean boundary, or break it down into two separate advertised routes.
The trick is to align the leading block of your allocation with its proper edge. If you want a /22, then the third octet has to be a multiple of four (e.g., 0, 4, 8). Addresses starting with 1 or 3 will include extra numbers and force the summary to expand toward lower numbers until it hit the previous boundary. This is why many traditional classful networks arenât easily aggregated; theyâre built on an old system predating CIDR and frequently straddle random bits. If youâre building out a network, think about aggregatable schemes from day one when you choose your addressing plan. Give yourself blocks that group naturaly into larger allocations: two, four, or eight, for example. If done right, it pays off big time.
Router performance is limited by how large their routing tables gets. A smaller number of entries result in faster lookups and smaller update packets. It also leads to quicker convergence after link failures. It also helps keep things stable. Say you have an aggregate with 1/24 inside of it that goes down. That summary route will still be advertised out to other peers. Your little problem gets kept contained within your own network, without causing unnecessary churn on the larger part of the internet. In effect, youâre masking the grotty insides of your own network, with a stable, clean interface towards everyone else.
It does take some time to get used to doing CIDR arithmetic, but after you start getting the feel for how the bits stack up, it gets pretty easy. Whether youâre tuning your production backbone or studying for a certification exam, youâll find that understanding the mask is more important then knowing any table by heart. When you have an idea about what kind of summary you want, this will show you immediately where it cuts off and how far you can go without going too far. Try out your edge cases here first so you donât commit something to your configuration file that you end up having to troubleshoot for hours later when the traffic dissapears into nothing.

