Skip to content

Subnet Splitter · Networking

Split a block and find the free space around it.

Give a parent like 10.0.0.0/24 plus the subnets already allocated, and get the free space as minimal CIDRs — then split a CIDR into subnets of any prefix and find the next available subnet, all in your browser.

Runs in your browser IPv4 & IPv6 No signup Updated Jul 28, 2026

Subnet Splitter playground

Enter a parent block, then list the CIDRs already in use. Blank lines and # comments are ignored. Add a "split into /N" to see every equal-size subnet.

Result

Enter a parent CIDR or pick an example to see the free space, an equal-size split, and a parsed breakdown of your allocations here.

The Gap

The leftover space is where mistakes hide.

Carving a block into subnets is easy until something is already allocated. Now the free space is a ragged set of differently-sized gaps, and eyeballing the next aligned /26 or /27 between two existing assignments is exactly the kind of binary arithmetic that produces an overlap or a wasted range.

This splitter subtracts what you have already handed out and reports the remaining space as the minimal set of CIDRs — find free subnet space in your CIDR block at a glance, then split it into /N subnets and pick the next available one. For IPv4 and IPv6 alike, entirely in the browser, with nothing to install.

Need to confirm a list does not overlap first? Try the CIDR / Subnet Checker.

The Pipeline

How it works.

Four deterministic steps run on every keystroke — all inside your browser tab, with exact BigInt arithmetic.

  1. Read the inputs.

    The parent block and each existing allocation are parsed to exact 32- or 128-bit ranges.

  2. Subtract the used.

    The allocations are removed from the parent, leaving the unallocated address regions.

  3. Decompose the gaps.

    Each leftover region is expressed as the minimal set of aligned CIDRs that tiles it exactly.

  4. Split and pick.

    Split into /N subnets and the next correctly aligned free /N is surfaced for handing out.

A Worked Example

Two /26s in a /24, what is left?

Subtract the used blocks from the parent and the free space falls out as aligned CIDRs — minimal even when the gaps are different sizes.

Even split

With the first and third /26 used, the free space is the other two — and the next free /26 is 10.0.0.64/26.

split-/24
parent      10.0.0.0/24
allocated   10.0.0.0/26     (used)
            10.0.0.128/26   (used)

free space
  10.0.0.64/26              next free /26
  10.0.0.192/26

A VLSM gap

When allocations are unequal, the leftover does not fit one prefix — it becomes the minimal mix of a /27 and a /26.

vlsm-gap
parent      10.0.0.0/24
allocated   10.0.0.0/25     (used)
            10.0.0.128/27   (used)

free space (minimal VLSM set)
  10.0.0.160/27
  10.0.0.192/26

Next Step

Got a list of subnets? Check them for overlaps.

Before you carve out more space, the CIDR / Subnet Checker takes your existing allocations and finds overlaps and containment, then aggregates everything into the minimal covering set — so the parent you feed the splitter is clean to begin with.

free.txt
10.0.0.0/24
  − 10.0.0.0/26
  − 10.0.0.128/26
  →  10.0.0.64/26
  →  10.0.0.192/26

FAQ

Questions, answered.

Tap a question to expand the answer.

Give it a parent block — for example 10.0.0.0/24 — plus any subnets already allocated inside it, and it subtracts the used space and reports the gaps as a minimal set of CIDRs. It can also split the parent (or any free gap) evenly into /N subnets and tell you the next free block of a size you ask for. Everything runs in your browser; nothing is uploaded.

No. Parsing and all the maths run 100% client-side in your tab — there is no server, no account and no logging. You can safely paste internal parent blocks and allocations.

Free space is the part of the parent block that none of your existing allocations cover. Because that leftover region rarely lines up with a single power-of-two boundary, the splitter expresses it as a Variable-Length Subnet Mask (VLSM) set — the smallest list of differently-sized CIDRs that exactly tiles the gap, rather than forcing one fixed prefix.

It scans the free space in order and returns the first block of prefix /N that is fully unallocated and correctly aligned to its own boundary — the block you would hand out next if you were carving the parent into /N subnets. If no aligned /N fits in the remaining free space, it tells you so instead of guessing.

Yes. IPv6 is handled with full 128-bit precision using BigInt, so you can split a site /48 into /64s or find the free space inside a /56 just as accurately as you subtract /26s from an IPv4 /24. IPv4 and IPv6 parents are both first-class.

Enter the parent CIDR — for example 10.0.0.0/16 — and choose a new prefix length such as /24. The tool enumerates every equal-size subnet of that prefix within the parent, marking each one as free, used, or partially allocated. Splitting a /16 into /24s yields 2^(24-16) = 256 subnets, each with its own network address and 254 usable host addresses.

Provide the parent CIDR, enter your existing allocations, and select the target prefix length. The tool scans the free intervals left after subtracting used space and returns the first correctly aligned block of that size that does not overlap any existing allocation. This is the next available subnet you can hand out without causing a conflict.

Paste your existing allocations under a parent CIDR and the tool subtracts the used intervals from the parent range. It then expresses each unallocated region as the minimal set of aligned CIDRs, so you can see every gap — including the largest contiguous free block — at a glance.

Use 2^(new prefix minus parent prefix): 2^(24-16) = 256. A /16 contains 256 /24 subnets, each with 256 total addresses (254 usable after the network and broadcast addresses). You can verify this by entering 10.0.0.0/16 with a split prefix of /24 and seeing all 256 blocks listed.

Overlapping subnets cause routing conflicts because one address would appear to belong to two ranges. The tool checks each candidate subnet against your existing allocations and marks it as used or partial if it conflicts, only flagging a subnet as free when it is fully unallocated and correctly aligned within the parent CIDR.

New to this? Read our guide on Networking for DevOps Engineers.

More free, private DevOps tools.

The Subnet Splitter is one tool in OpsCanopy — a growing canopy of browser-based validators, converters and testers that never touch a server.

New to Networking?  Read the Networking guide →

29 free tools, every one offline-capable — opscanopy.com works with no signup and nothing uploaded.

More networking: the CIDR / Subnet Checker and the Subnet Calculator, or browse the full tools directory.

Provided as-is for convenience; always confirm critical network changes against your own authority. OpsCanopy is free and open.