Supernet Aggregation Calculator: CIDR Route Summarization

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

#Oct 1Oct 2Oct 3Oct 4Prefix
1 /
2 /
3 /
4 /
5 /
6 /

Each row is one network address with its CIDR prefix length. Only the number of rows chosen above is used.

Summary Supernet 0.0.0.0/0 aggregated CIDR route
Subnet Mask 0.0.0.0 dotted-decimal mask
Total Addresses Covered 0 IPs inside the summary
Over-aggregation 0 extra IPs beyond inputs

🔱Aggregation Snapshot

ANDnet & mask
XORcommon bits
2^hh = 32 - prefix
n-log2Ncontiguous prefix

📈Contiguous Block Aggregation

Blocks (N)Input PrefixBits SavedSummary PrefixExample Summary
22 x /241/2310.0.0.0/23
44 x /242/2210.0.0.0/22
88 x /243/2110.0.0.0/21
1616 x /244/2010.0.0.0/20
22 x /161/15172.16.0.0/15
44 x /162/14172.16.0.0/14
22 x /251/24192.168.0.0/24
44 x /262/24192.168.0.0/24
88 x /273/24192.168.0.0/24
256256 x /248/1610.1.0.0/16

📑Prefix, Mask, and Address Count

PrefixSubnet MaskHost BitsTotal AddressesEquivalent
/8255.0.0.02416,777,216One class A
/12255.240.0.0201,048,57616 x /16
/15255.254.0.017131,0722 x /16
/16255.255.0.01665,536One class B
/20255.255.240.0124,09616 x /24
/22255.255.252.0101,0244 x /24
/23255.255.254.095122 x /24
/24255.255.255.08256One class C

📏Alignment Rules for Clean Summaries

RuleRequirementGood ExampleFails When
Equal sizeAll blocks same prefixFour /24sMixing /24 and /25
Power of twoCount is 2, 4, 8, 16Eight /26sThree /24s together
Boundary startFirst block on the summary boundary.0 for /22Starting at .1.0
ContiguousNo gaps between blocks.0 .1 .2 .3.0 .1 .3 missing .2
Bits savedlog2(N) shortens prefix4 blocks save 2Not a power of two
No overlapSummary stays inside its class scope/22 within /16Crossing major bounds

🗃Aggregation Comparison Grid

Input NetworksSummary RoutePrefixMaskAddressesValidity Note
192.168.0.0/24 to .3.0/24192.168.0.0/22/22255.255.252.01,024Exact, no waste
10.0.0.0/24 + 10.0.1.0/2410.0.0.0/23/23255.255.254.0512Exact pair
172.16.0.0/16 + 172.17.0.0/16172.16.0.0/15/15255.254.0.0131,072Exact, aligned
10.0.0.0/24 + 10.0.5.0/2410.0.0.0/21/21255.255.248.02,048Over-aggregates 1,536
192.168.1.0/24 to .4.0/24192.168.0.0/21/21255.255.248.02,048Not aligned, overreach
10.1.0.0/16 to 10.4.0.0/1610.0.0.0/13/13255.248.0.0524,288Wide, includes extras
10.0.0.0/25 + 10.0.0.128/2510.0.0.0/24/24255.255.255.0256Two halves rejoin
192.168.8.0/24 to .15.0/24192.168.8.0/21/21255.255.248.02,048Eight blocks, exact

✍Formula Breakdown

Network to 32-bit intEach address becomes a number: int = oct1 x 16777216 + oct2 x 65536 + oct3 x 256 + oct4. So 192.168.1.0 is 3232235776.
Common prefix by XORXOR the smallest and largest network integers. The bits that match from the left are the common prefix. Count them to get the summary prefix length.
Summary = net AND maskApply the mask for the common prefix to the first network. Clearing the host bits gives the summary network address.
Contiguous shortcutFor N aligned equal /n blocks where N is a power of two, the summary prefix is n minus log2(N). Four /24s give 24 - 2 = /22.
Addresses coveredA summary with prefix p spans 2 to the power (32 - p) addresses. A /22 covers 2^10 = 1024 IPs.
Over-aggregationSubtract the summed input addresses from the covered total. Any positive value is address space the route advertises but you did not intend.

💡Route Summarization Tips

Reduce table entries: Summarizing 4 contiguous /24 routes into a single /22 turns 4 routing-table entries into 1, a 75 percent reduction. Scale that to 256 /24s collapsing into one /16 and a router advertises 1 prefix instead of 256, shrinking update size and speeding convergence.
Watch over-aggregation: A /21 covers 2048 addresses. If you only own two /24 blocks worth 512 addresses but they force a /21 summary, the route claims 1536 extra IPs. Advertising space you do not control can blackhole traffic, so keep blocks aligned and contiguous.

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.

Supernet Aggregation Calculator: CIDR Route Summarization