An IP address is just 32 bits

Before any subnetting trick makes sense, you have to see an IP address for what it really is underneath the dots. Let's start there.

3 quick questions · about 2 min · no sign-up

Question 1 of 3

Take the address 192.168.1.10. Those four numbers separated by dots — what is each one really?

• An 8-bit number (an octet), so the whole address is 32 bits
• A single digit from 0 to 9
• A whole number that can be anything, with no fixed size
• I'm not sure

You said: An 8-bit number (an octet), so the whole address is 32 bits

Exactly. Each of the four parts is one octet — 8 bits — and 4 octets stacked together make 32 bits total. The dots are just there for human eyes; the machine sees one 32-bit string.

You said: A single digit from 0 to 9

Not a single digit — each part can go up to 255 (look at the 192). Each one is an 8-bit number called an octet, and four of them stacked make 32 bits. The dots are only for readability.

You said: A whole number that can be anything, with no fixed size

It is a whole number, but it has a hard ceiling: each part is exactly 8 bits, so it maxes out at 255. Four of these 8-bit octets stack into one 32-bit address.

You said: I'm not sure

Here's the key fact: each part is an octet — an 8-bit number maxing out at 255. Four octets stacked together make 32 bits, and that 32-bit string IS the address. The dots are just for us.

Another way to see it

Another way to see it: a computer only stores 1s and 0s. 192.168.1.10 is really 11000000.10101000.00000001.00001010 — 32 bits in a row. We chop it into four 8-bit chunks and write each chunk as a decimal number (0-255) so it's readable. That's all the dotted form is: a friendlier costume over 32 bits.

So the whole address is 32 bits in four 8-bit chunks. Next, let's open up one chunk and see the binary inside.

Question 2 of 3

One octet holds 8 bits. So how many different values can a single octet represent, and what's the range?

• 256 values, from 0 to 255
• 255 values, from 1 to 255
• 8 values, one per bit
• I'm not sure

You said: 256 values, from 0 to 255

Right. 8 bits give 2^8 = 256 combinations, and counting from 0 means the range is 0 to 255. That's exactly why no part of an IP address ever goes above 255.

You said: 255 values, from 1 to 255

Close, but 0 counts too. 8 bits give 2^8 = 256 combinations, and including 0 the range is 0 to 255 — 256 values in total. That 0 is why you'll see octets like the .0 in a network address.

You said: 8 values, one per bit

It's not 8 — each bit is independently 0 or 1, so 8 bits give 2^8 = 256 combinations. Counting from 0, the range is 0 to 255. That's why an octet never exceeds 255.

You said: I'm not sure

8 bits give 2^8 = 256 combinations. Counting from 0, the range runs 0 to 255 — that's 256 values. That ceiling of 255 is exactly why no octet in an IP address goes higher.

Now the real test — let's convert an actual octet into its 8 bits.

Question 3 of 3

Each bit in an octet has a place value: 128, 64, 32, 16, 8, 4, 2, 1 (left to right). The octet 192 = 128 + 64. So what is 192 in binary?

• 11000000
• 00000011
• 11110000
• I'm not sure

You said: 11000000

That's it. 128 and 64 are the two leftmost place values, so you switch on the first two bits and leave the other six off: 11000000. You just converted an octet to binary by hand.

You said: 00000011

That has the bits at the wrong end. The big place values (128, 64) sit on the LEFT, so 128 + 64 turns on the first two bits: 11000000. 00000011 would be 2 + 1 = 3.

You said: 11110000

Too many bits on. 128 + 64 only needs the first two: 11000000. Turning on four would add 32 + 16, giving 128 + 64 + 32 + 16 = 240, not 192.

You said: I'm not sure

Walk the place values 128, 64, 32, 16, 8, 4, 2, 1. Since 192 = 128 + 64, switch on just the first two bits and leave the rest off: 11000000. That's the whole conversion.

The takeaway

An IPv4 address is one 32-bit string written as four 8-bit octets (each 0-255), and you can convert any octet to binary using the place values 128-64-32-16-8-4-2-1 — like 192 = 11000000. Every subnetting move from here is just manipulating these bits.

Next step

Now you can read an address as 32 bits — but bits alone don't tell you where the network ends and the hosts begin. That's the mask's job, up next.