How To Calculate Subnet From Ip Address

The Lightbulb Moment

You've probably stared at a subnet mask like 255.That's why 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. 255.Here's the thing — calculating a subnet from an IP address isn't about memorizing formulas. 255.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. Which means no jargon without explanation. No skipping steps. That said, 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." So any device with 192.100 with a subnet mask of 255.255.Think about it: 0. The mask tells your machine: "The first three numbers (192.That's why the last number (100) is the host. 168.1.1) are the network. 1.x is on the same local network. 168.Practically speaking, 168. 255.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. Because of that, 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. 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. Say you have the IP address 172.Even so, 16. Here's the thing — 0. 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. Day to day, 0. 0.0 to 191.255.255.255.255, Class B covers 128.0 to 126.Class A covers 1.So naturally, 0. 0.0.Day to day, 255. 255, and Class C covers 192.255.0 to 223.Consider this: 255. 255.That said, 0, is Class B, which means the default subnet mask is 255. Our example, 172.0.Which means 16. 0.Also, 0. 255.0 (or /16 in CIDR notation).

This default mask means the first two octets (172.Which means 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. And do you need four subnets? In real terms, sixteen? 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. For Class B, that's 11111111.11111111.On top of that, 0. 255.00000000.00000000 (255.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.255.192.In real terms, 0. 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).

Want to learn more? We recommend 14 out of 20 as a percentage and how many days till march 10 for further reading.

For Subnet 1 (172.Still, 16. Here's the thing — 0. 0 to 172.In practice, 16. In practice, 0. 63):

Network address: 172.16.Still, 0. 0
First usable host: 172.On top of that, 16. Think about it: 0. And 1
Last usable host: 172. That said, 16. 0.62
Broadcast address: 172.Still, 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. Also, instead of writing 255. 255.255.0, you write /24. The number after the slash represents how many 1s are in the subnet mask.

A /24 means 24 bits are network (255.255.0), leaving 8 bits for hosts. Day to day, 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.0.Worth adding: 0. 0 and starts borrowing bits without realizing it's Class A with a default mask of 255.Plus, 0. Think about it: 0. 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 B defaults to 255.Because of that, 255. 255.In real terms, 0. 255.Here's the thing — - Class A defaults to 255. 0 (/8); the first octet is the network portion, leaving three octets for hosts.
Class C defaults to 255.0.Because of that, 0. That's why 0 (/16); the first two octets are network bits, with two octets remaining for hosts. 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.0.Since the default mask leaves 24 host bits, you must borrow three bits (2³ = 8). 255.Because of that, the new mask becomes 255. Because of that, 0. 255., 10.On the flip side, 0) and you need eight subnets. Plus, g. 224 or /27.

For a Class B network (e.16.0) where you require 16 subnets, you borrow four bits from the third octet. In practice, g. , 172.On top of that, 255. And 240. 0.The mask turns into 255.0 or /20.

If you are working with a Class C block (e., 192.Still, 255. g.Even so, 1. Even so, 255. 0) and need four subnets, you only need to borrow two bits from the final octet, resulting in 255.168.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. Think about it: 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. Because of that, 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. Think about it: 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. 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. Master these steps, and you’ll be able to design efficient, scalable IP layouts with confidence.

This is one of those details that makes a real difference.