Route Summarization Calculator
Summarize routes without hiding extra address space.
Reduce CIDR routes to the smallest exact set, then see the smallest one-route covering supernet when exact aggregation is not possible.
Routing note: a mathematically valid summary may still be inappropriate if component routes use different next hops, policies, or reachability behavior. Verify routing intent before advertising an aggregate.
Your route analysis will appear here
Enter one or more CIDR routes to compare exact aggregation with their smallest covering supernet.
What is route summarization?
Route summarization (also called route aggregation) replaces several routing-table entries with fewer, broader entries that cover the same or a superset of destinations. A router or route filter advertising 10.20.0.0/22 instead of four separate /24 routes sends one entry instead of four, without changing which addresses are reachable through it — provided the summary is exact.
Exact route summarization
An exact summary covers precisely the same address space as the routes it replaces: zero additional addresses, zero addresses lost. This only happens when the supplied networks are contiguous and properly aligned — four /24 networks that tile one /22 exactly, for example. When routes don't align this cleanly, the calculator reports the smallest exact CIDR set it can produce, which may still be more than one prefix.
What is a covering supernet?
A covering supernet is the single smallest CIDR block that contains every supplied network, whether or not the result is exact. If the routes don't tile a clean boundary, the covering supernet necessarily includes address space that wasn't in the original list — this tool calculates and reports exactly how much.
Exact summary vs. broader supernet
These answer different questions. "What is the smallest exact set of CIDRs for these routes?" is exact summarization — always safe with respect to address space, since nothing is added. "What is the smallest single prefix that covers all of these routes?" is the covering supernet — useful for a single default-style aggregate, but potentially advertising reachability for addresses that were never part of the original route list. This calculator never presents the second as equivalent to the first.
Why route alignment matters
Two CIDR blocks can only merge into one exact parent when they are the same size and sit as the two aligned children of that parent — the lower block must start on a boundary that's an exact multiple of twice its own size, and the upper block must begin exactly where the lower one ends. 10.0.0.0/24 and 10.0.2.0/24 look close together, but they are not aligned siblings — merging them into one prefix would have to also include 10.0.1.0/24, address space that was never supplied.
How CIDR routes are aggregated
Exact aggregation normalizes every route to its true network address, removes exact duplicates and routes fully contained within a larger supplied route, then repeatedly merges any remaining pair of exact aligned siblings until no further merge is possible. The covering supernet is calculated independently: the longest common leading-bit prefix shared by the lowest and highest address across all normalized routes.
Route summarization and next hops
Address-space math is only part of a safe real-world summary. Before advertising an aggregate route, confirm the component routes share the same next hop, the same administrative routing policy, and consistent BGP attributes where applicable. Also consider route filtering, discard/null-route behavior for any address space the aggregate covers but the network doesn't actually use, and how the aggregate behaves if one component route fails. This calculator checks address alignment, not routing policy.
Route summarization in IPv4 and IPv6
The same alignment rules apply to both families using the same 128-bit vs. 32-bit address math — IPv6 uses BigInt arithmetic throughout so large prefix counts stay exact. Two aligned /48 networks, for example, merge into a /47 under the identical rule that merges two aligned IPv4 /24s into a /23: the lower block must sit at an even index at that boundary.
Duplicate and contained routes
Pasting the same route twice, or a route that's already fully covered by a larger route you also supplied, doesn't add real address space — exact summarization removes both before merging, and reports how many were removed, so they never inflate the reported coverage or route count.
When route summarization can be unsafe
Summarization reduces route-table size, simplifies routing policy, and cuts configuration complexity — real, practical benefits at scale. But a broader aggregate can also hide more-specific topology from routers that would otherwise see it, create black-hole behavior if traffic is drawn toward the aggregate for address space that isn't actually reachable through it, and advertise reachability for unused address space if the covering supernet is deployed without checking what it actually contains. None of this is automatic or unavoidable — it's exactly why this tool separates "exact" from "broader coverage" instead of quietly picking one.
Route Summarization Calculator vs. CIDR & IP Range Converter
The CIDR & IP Range Converter's Merge mode performs the same exact-aggregation math as this tool's Exact mode — they share the same underlying algorithm. This tool adds the routing-specific framing on top: the "can these become one prefix" answer, the smallest covering supernet with its additional-coverage analysis, and route-table-oriented metrics like route count and reduction percentage.
Route Summarization Calculator vs. Subnet Overlap Checker
The Subnet Overlap Checker answers "do these networks conflict, contain one another, or sit adjacent to each other?" — a diagnostic question about relationships between networks. This tool answers a planning question: "can this group of routes be represented more efficiently, and if so, exactly how?" Overlapping or duplicate input is exactly the kind of thing the Overlap Checker is built to surface before you summarize.
Worked examples
Every result below is independently verified, not just implemented and assumed correct.
Example 1 — exact vs. covering supernet, side by side
Input: 172.16.0.0/24, 172.16.4.0/24. These two /24s are not adjacent, so the exact summary stays two routes: 172.16.0.0/24 and 172.16.4.0/24, 0% reduction, 0 extra addresses. The smallest single covering supernet is 172.16.0.0/21 (172.16.0.0–172.16.7.255, 2,048 addresses) — against 512 addresses actually supplied, that's 1,536 additional addresses: 75% of the /21 is address space that was never in the original list, a 300% increase over the original coverage.
Example 2 — exact, four aligned /24s
Input: 10.20.0.0/24, 10.20.1.0/24, 10.20.2.0/24, 10.20.3.0/24. Exact summary: 10.20.0.0/22. Original routes: 4. Summarized routes: 1. Extra addresses: 0.
Example 3 — exact aligned siblings
Input: 10.0.0.0/25, 10.0.0.128/25. Exact summary: 10.0.0.0/24. Extra addresses: 0. These two /25s are the aligned lower and upper halves of the same /24, so they merge exactly.
Example 4 — redundant/contained route
Input: 10.0.0.0/24, 10.0.0.128/25. The /25 is fully contained within the /24 and adds no unique address space. Exact normalized output: 10.0.0.0/24 alone — 1 contained route removed.
Example 5 — exact IPv6 siblings
Input: 2001:db8:0::/48, 2001:db8:1::/48. These are the aligned lower and upper /48 children of the same /47, so they merge exactly to 2001:db8::/47 — zero additional addresses, verified with the same BigInt alignment check used for IPv4.