How To Calculate Subnet From Ip Address

The Lightbulb Moment

You've probably stared at a subnet mask like 255.255.So 255. 0 and wondered what dark magic produced it. Or maybe you've seen a network engineer drop a /24 into conversation and felt your confidence evaporate. Even so, here's the thing — calculating a subnet from an IP address isn't about memorizing formulas. It's about understanding a few core ideas and then applying them step by step.

I've walked through this dozens of times with junior engineers, and the moment it clicks — usually around the third or fourth example — their shoulders relax. That's what this guide is for. Worth adding: no jargon without explanation. No skipping steps. Just a clear path from "what even is a subnet?" to "oh, I can do this.

What Is a Subnet, Really?

A subnet (short for subnetwork) is a logical way to slice up a larger IP network into smaller, manageable pieces. Think of it like dividing a big apartment building into individual units. Each unit has its own address, but they all share the same building.

Every device on a network — your laptop, phone, smart fridge — has an IP address. That address has two parts: the network portion (which identifies the network itself) and the host portion (which identifies the specific device). The subnet mask is the tool that tells your computer where that division happens.

The Two Parts of an IP Address

Take 192.168.So 1. 100 with a subnet mask of 255.Consider this: 255. 255.In real terms, 0. The mask tells your machine: "The first three numbers (192.168.1) are the network. The last number (100) is the host.Think about it: " So any device with 192. 168.Even so, 1. x is on the same local network. Anything else goes to the router.

This matters because it determines what traffic your computer tries to handle directly versus what it sends to the gateway. Get the subnet wrong, and your device thinks it's talking to someone on the same floor when they're actually across town.

Why It Actually Matters

Misconfigured subnets cause real problems. Devices can't talk to each other. Printers vanish from the network. Remote access stops working. In larger networks, a single wrong subnet mask can isolate entire departments.

But beyond troubleshooting, understanding subnets is the foundation for everything else in networking. Practically speaking, vLANs, routing, cloud networking, firewall rules — they all assume you know how addresses break down. If you're studying for a certification (Network+, CCNA, whatever), this is the topic that separates pass from fail.

And honestly? It makes you dangerous in the best way. The next time someone says "we need to carve out a subnet for the new office," you'll know what they mean instead of nodding politely.

How to Calculate a Subnet Step by Step

Let's walk through the process with a concrete example. Plus, say you have the IP address 172. 16.0.So 0 and you need to create subnets. Here's how you figure out what goes where.

Step 1: Identify the Class and Default Mask

First, determine the class of your IP address. Class A covers 1.0.On the flip side, 0. 0 to 126.Practically speaking, 255. In real terms, 255. In practice, 255, Class B covers 128. 0.In practice, 0. 0 to 191.Still, 255. 255.255, and Class C covers 192.0.0.0 to 223.255.255.255. Day to day, our example, 172. 16.0.0, is Class B, which means the default subnet mask is 255.And 255. 0.0 (or /16 in CIDR notation).

This default mask means the first two octets (172.16) represent the network, and the last two (0.0) are available for hosts. But here's where it gets interesting — you're probably not using the full default. You're borrowing bits from the host portion to create subnets.

Step 2: Decide How Many Subnets You Need

Before touching any calculator, figure out your requirements. On top of that, do you need four subnets? Think about it: sixteen? Worth adding: eight? Let's say you need four subnets from that Class B network.

To find out how many bits you need to borrow, use this rule: 2 to the power of the number of borrowed bits equals the number of subnets. So 2^2 = 4 subnets means you borrow 2 bits.

Step 3: Calculate the New Subnet Mask

Start with your default mask in binary. 00000000 (255.0.11111111.For Class B, that's 11111111.255.In real terms, 00000000. 0).

You're borrowing 2 bits from the host portion. Those borrowed bits turn into 1s in the mask:

11111111.11111111.11000000.00000000

Convert that back to decimal: 255.0. 192.So 255. In CIDR notation, that's /18.

Step 4: Find the Block Size

The block size tells you the range of addresses in each subnet. Take the value of the octet where you started borrowing bits. In our example, the third octet went from all zeros to 11000000, which is 192 in decimal.

Block size = 256 minus the decimal value of the changed octet. So 256 - 192 = 64.

This means each subnet spans 64 addresses. Your subnets start at:

Subnet 1: 172.16.0.0 to 172.16.0.63
Subnet 2: 172.16.0.64 to 172.16.0.127
Subnet 3: 172.16.0.128 to 172.16.0.191
Subnet 4: 172.16.0.192 to 172.16.0.255

Step 5: Determine Usable Host Range

Within each subnet, you need to identify which addresses you can actually assign to devices. The first address is the network address (all host bits are 0), and the last is the broadcast address (all host bits are 1).

If you found this helpful, you might also enjoy auto loan payment calculator with extra payments or what is 9 months from today.

For Subnet 1 (172.16.In practice, 0. 0 to 172.Day to day, 16. 0.So naturally, 63):

Network address: 172. 16.0.0
First usable host: 172.16.0.Practically speaking, 1
Last usable host: 172. 16.Still, 0. 62
Broadcast address: 172.16.0.

That gives you 62 usable host addresses per subnet.

Working With CIDR Notation

Modern networking uses CIDR (Classless Inter-Domain Routing) notation almost exclusively. 0, you write /24. 255.Also, 255. Still, instead of writing 255. The number after the slash represents how many 1s are in the subnet mask.

A /24 means 24 bits are network (255.0), leaving 8 bits for hosts. 255.Now, 255. A /26 means 26 bits are network, leaving 6 bits for hosts (2^6 = 64 addresses, 62 usable).

The math stays the same — you're just counting bits instead of converting between binary and decimal.

Common Mistakes That Trip People Up

Forgetting the Default Mask

I see this constantly. Someone grabs 10.On the flip side, 0. Think about it: 0. 0 and starts borrowing bits without realizing it's Class A with a default mask of 255.0.Still, 0. In real terms, 0 (/8). They end up with wildly wrong calculations because they assumed the wrong starting point.

Always check your class first. It determines your default mask, which is your

Checking the class first is essential because it tells you the baseline mask you start from.

Class A defaults to 255.In real terms, 255. 255.0.- Class B defaults to 255.0.- Class C defaults to 255.Because of that, 0 (/8); the first octet is the network portion, leaving three octets for hosts. 0 (/16); the first two octets are network bits, with two octets remaining for hosts.
Still, 255. 0.0 (/24); the first three octets are network bits, leaving a single octet for hosts.

Once you know which octet(s) belong to the network portion, you can decide how many of the remaining host bits you need to “borrow” to create the desired number of subnets. The same exponential rule applies: 2ⁿ = number of subnets, where n is the count of borrowed bits.

Applying the Rule to Different Classes

Suppose you have a Class A address space (e.g.That's why , 10. 0.0.0) and you need eight subnets. On the flip side, since the default mask leaves 24 host bits, you must borrow three bits (2³ = 8). That said, the new mask becomes 255. 255.255.224 or /27.

For a Class B network (e.But g. Day to day, , 172. 16.In practice, 0. In real terms, 0) where you require 16 subnets, you borrow four bits from the third octet. The mask turns into 255.255.240.0 or /20.

If you are working with a Class C block (e.0) and need four subnets, you only need to borrow two bits from the final octet, resulting in 255.255.255.g.In real terms, 1. In real terms, 168. , 192.192 or /26.

Verifying Subnet Boundaries

After the mask is set, the block size is found by subtracting the decimal value of the octet where borrowing began from 256. Also, for a /27 mask, the third octet changes from 0 to 224, so the block size is 256 − 224 = 32. Subnets will therefore be spaced 32 addresses apart, and the usable host range in each subnet will be 30 hosts (32 total addresses minus network and broadcast).

Summarizing the Workflow

Identify the class of the address to determine the default mask.
Decide how many subnets you need and calculate the required number of borrowed bits (2ⁿ = subnets).
Add those bits to the network portion of the mask, producing the new mask in dotted‑decimal or CIDR form.
Compute the block size using 256 minus the decimal value of the changed octet.
List the subnets, then subtract the network address and the broadcast address to obtain the usable host range for each subnet.

Final Thoughts

Subnetting is fundamentally a matter of counting bits. By starting with the correct default mask, borrowing the appropriate number of host bits, and applying the simple exponential relationship, you can carve any IP network into the exact number of subnets you require. Remember that modern networks almost always use CIDR notation, which makes the mask length immediately visible and eliminates the need to convert between binary and decimal for the mask itself. With this disciplined approach, you’ll avoid the common pitfalls of mis‑identifying the class, mis‑calculating the block size, or overlooking the network and broadcast addresses. Master these steps, and you’ll be able to design efficient, scalable IP layouts with confidence.