The Anatomy of IPv4 Address

Igwe Francis — Fri, 07 Aug 2026 15:57:45 +0000

I used to think IPv4 addresses were just random numbers until recently. It blew my mind when I started digging and understanding that they have an anatomy where every number after the dot means something very important.

Note: To understand what IP addresses are, please consult this post because I won't be going over them here. IP Addresses: Digital Connectivity

What is IPv4 in the First Place?

IPv4 is short for Internet Protocol version 4. As you might have already realized, it's the 4th version of the early test designs during the development of the Internet Protocol in test labs in the 1970s. The first real release, v4, came out in 1981 in a public document called RFC 791. RFC 791: STD 5: Internet Protocol

IPv4 is an Internet Protocol that's written in what's called Dotted Decimal Notation (e.g., 172.17.0.3), where each portion is separated by a dot, and these portions are called octets. For example, 172 is the first octet and 17 is the second octet (more on this later).

Before We Explore What Octets Are, Let's Take a Stroll to the Basics of Binary (Simplified)

Have you ever wondered why your computer or phone requires electricity to function? Though electricity can be used as a raw power source for things like fans or speakers, where it's converted into other forms of energy such as movement or sound, it's good to know that electricity can function differently in your computer's RAM or SSD. Inside your computer are billions of extremely tiny transistors. These transistors form circuits that can create and maintain different electrical states, which the computer interprets as 0s and 1s. In simple terms, 0 represents the absence of the electrical state (OFF), while 1 represents its presence (ON). These states, which we represent with 0s and 1s, are called binary digits (or simply bits).

1 bit has the possibility of representing either 0 or 1, which doesn't represent much information, and that's where multi-bits come in. Every additional bit doubles the number of possible values. What I mean by this is:

1 bit = 0 or 1, 2 bits = 00, 01, 10, or 11

As you can see, just by grouping two bits together, we are able to represent more possible values. To convert to decimal, we can say:

2 bits value	Decimal
00	0
01	1
10	2
11	3

We are no longer representing either 0 or 1. With 2 bits, we can represent values from 0 up to 3 (that's 4 possible values). But can you spot how much the number of values we can represent increased exponentially just by grouping bits? Let's see how much we can represent with 3 bits (don't worry about the conversion method).

3 bits value	Decimal
000	0
001	1
010	2
011	3
100	4
101	5
110	6
111	7

From the table, you can see we are now able to represent 8 values, an exponential increase from the previous example (2 bits). So mathematically, we can say:

bits	Equation	Possible values
1	2^1	2
2	2^2	4
3	2^3	8
4	2^4	16
5	2^5	32
6	2^6	64
7	2^7	128
8	2^8	256

With 2 to the power of 1, we can only represent 2 possible values, but with an increase in power (which is the same as grouping more bits), it becomes possible to represent more values.

An octet is 8 bits. Remember above when I gave an example of an IPv4 address such as 172.17.0.3.

What's an Octet?

An octet is just bits grouped into eight, capable of representing values between 0–255. (We start counting from 0, which is why the range is 0–255, but 8 bits are capable of representing 256 values, and 0 is still a valid value.) Each of the four values separated by a dot in an IPv4 address is an octet, so with that in mind, we'd have 4 octets:

172 → first octet 17 → second octet 0 → third octet 3 → fourth octet

Each of these octets is able to represent a value between 0–255. You'd never come across an IPv4 address where an individual octet crosses 255. Something like 192.258.0.12 is an invalid IPv4 address because we can't represent 258 with 8 bits.

IPv4 addresses are 32-bit values (1 octet is 8 bits, 4 octets is 32 bits), commonly represented to humans as four decimal octets. A traditional conversion of an IPv4 address (172.17.0.3) from decimal notation to binary representation would look like this:

172 → 10101100 17 → 00010001 0 → 00000000 3 → 00000011

So this is how a typical networking pro would see an IPv4.

172.17.0.3 ↓ 10101100.00010001.00000000.00000011

The Anatomy of IPv4

An IPv4 address is two addresses in one. An IPv4 address contains information that allows us to determine which network a device belongs to and which device it is within that network.

But before we break that statement down, there's something important we need to establish; An IPv4 address is fundamentally one 32-bit value. So when we write:

172.17.0.3

we're not actually dealing with four independent numbers, but one 32-bit value that has been divided into four groups of 8 bits so that humans can read and work with it more easily.

I hope you still remember that:

1 octet = 8 bits

So:

4 octets × 8 bits = 32 bits

That's why every valid IPv4 address has four octets so that we can visualize it like this:

172 . 17 . 0 . 3
↓ ↓ ↓ ↓
8 8 8 8 bits

And if we convert each octet to binary:

172.17.0.3

becomes:

10101100.00010001.00000000.00000011

Realistically this is the actual 32-bit structure of the dotted decimal notation. It's safe to say that the dots aren't part of the 32 bits themselves but simply separators that make it easier for us to see the four groups of 8 bits.

But where the anatomy of IPv4 becomes interesting is The Network and Host Portions

The Network and Host Portions

When we say an IPv4 address tells us which network a device belongs to and which device it is within that network, we're talking about two logical portions of those 32 bits:

Network portion | Host portion

For example, assuming we have this:

192.168.1.10/24

The /24 tells us that the first 24 bits are the network prefix (more on it later). For now, lets convert the address to binary:

192.168.1.10

becomes:

11000000.10101000.00000001.00001010

Now we can show where the /24 boundary falls:

11000000.10101000.00000001 | 00001010
<---------- network ----------> <--- host --->

So the first 24 bits represent the network prefix and the remaining 8 bits represent the host portion. So we can think of the address as:

Network: 192.168.1
Host: 10

And that's what I mean when I say an IPv4 address is two addresses in one. It's one 32-bit IPv4 address, but when we apply a prefix length to it, those bits can be interpreted as:

Network prefix + Host portion

But Wait, Where Did `/24` Come From?

You might be wondering why I suddenly added /24 to the IP address. This is important because the IPv4 address by itself doesn't tell us where the network portion ends and the host portion begins.

Take for example:

192.168.1.10

By looking at those four decimal numbers alone, there is no universal rule saying:

192.168.1 = network

10 = host

So we need additional information to know where that boundary is and that's what the /24 provides.

/24 simply means:

The first 24 bits are the network prefix. This is also why you shouldn't memorize something like:

"The first three numbers are the network and the last number is the host."

The Boundary Doesn't Always Fall Between Octets

I think, this is where understanding the binary structure becomes very useful.

Consider IPv4:

192.168.1.10/26

A /26 means the first 26 bits are the network prefix.

Our address in binary is:

11000000.10101000.00000001.00001010

Now lets mark the first 26 bits:

11000000.10101000.00000001.00 | 001010

Notice that the boundary is inside the fourth octet.

The fourth octet:

00001010

has been split into:

00 | 001010

So we have:

26 network bits

and:

6 host bits

because:

32 - 26 = 6

This is why it's important to think about IPv4 as 32 bits, rather than simply four decimal numbers.

Lastly, How Does the Computer Know This?

Now you might be wondering; If the IP address itself doesn't contain /24, how does my computer know what the network boundary is?

If you're using Windows, run:

terminal command: ipconfig /all

You'll see something similar to:

IPv4 Address. . . . . . . . . . . : 192.168.1.10

Subnet Mask . . . . . . . . . . . : 255.255.255.0

Windows doesn't display /24 here. Instead, it displays the subnet mask. But:

255.255.255.0

is another way of saying:

/24

because in binary, 255.255.255.0 is the same as 11111111.11111111.11111111.00000000 because there are 24 1s followed by 8 0s.

The 1s tell the computer which bits belong to the network prefix, while the 0s indicate the bits available for the host portion.

So 192.168.1.10 together with 255.255.255.0 can be written more compactly as: