Explainer · addressing

IP address classes (A, B, C, D, E) explained

For twelve years, the shape of every IPv4 network was decided by the first few bits of its address. The scheme was elegant, it was simple, and it wasted the address space so badly that it had to be torn out. Here is what classful addressing was, why it failed, and why you still hear people say “a class C” decades after it stopped meaning anything to a router.

The short version

Classful addressing is obsolete. It was the original 1981-era scheme for dividing the IPv4 address space, and it was formally replaced by CIDR in 1993. No router built in the last three decades makes a forwarding decision based on an address's class. If you are learning networking today, learn prefixes and subnet masks — the classes are history, not practice. But they are history you will keep bumping into, so it is worth knowing what they actually were.

What classful addressing was

An IPv4 address is 32 bits, conventionally written as four decimal octets like 192.0.2.14. Those 32 bits always split into two parts: a network portion that identifies which network the host lives on, and a host portion that identifies the machine within it. The only question is where the boundary falls.

The original IPv4 specification answered that question with a lookup table. The leading bits of the address told you the class, and the class told you exactly where the network/host boundary sat. Start the address with a 0 bit and it was a class A, with the boundary after 8 bits. Start it with 10 and it was a class B, boundary after 16 bits. Start with 110 and it was a class C, boundary after 24 bits. The boundary was never negotiable and never carried in a routing update — a router could look at any address in isolation and know its network mask, because the mask was a function of the address itself.

That is the defining property of a classful system, and it is exactly the property that CIDR abolished.

The five classes

Class A — 1.0.0.0 to 126.255.255.255

Leading bit 0. Default mask 255.0.0.0, a /8. Eight bits of network, twenty-four bits of host: roughly 16.7 million addresses per network. There were only 126 of these to hand out, and they went to the likes of national telecoms, early research institutions and a handful of large corporations. If you have ever wondered why one company appears to own all of 17.0.0.0/8, this is why.

The range stops at 126, not 127, because 127.0.0.0/8 is reserved for loopback — the address block a machine uses to talk to itself. It is technically inside the class A bit pattern but was carved out and never allocated. 0.0.0.0/8 at the other end was reserved too, which is why the range starts at 1.

Class B — 128.0.0.0 to 191.255.255.255

Leading bits 10. Default mask 255.255.0.0, a /16. Sixteen bits of network, sixteen bits of host: 65,534 usable hosts per network, across 16,384 possible networks. This was the block that universities, large enterprises and government departments received, and — as we will see — it is the block that broke the whole model.

Class C — 192.0.0.0 to 223.255.255.255

Leading bits 110. Default mask 255.255.255.0, a /24. Twenty-four bits of network, eight bits of host: 254 usable hosts per network, but more than two million networks available. This is the size most people picture when they think about a “normal” network, and it is the reason /24 is still the most common prefix length on the internet.

Class D — 224.0.0.0 to 239.255.255.255

Leading bits 1110. This block is multicast: addresses here identify a group of interested receivers rather than a single host, and they have no network/host split at all, so the idea of a default mask does not apply. Multicast is still very much alive — it underpins things like service discovery on a local network and IPTV distribution — but it was never really a “class” in the same sense as A, B and C. It just happened to occupy the next available bit-pattern.

Class E — 240.0.0.0 to 255.255.255.255

Leading bits 1111. Reserved for future use and experimental purposes, and never allocated for general internet use. There have been recurring proposals to reclaim the block, but a great deal of deployed software hard-codes class E as invalid, so in practice it stays off-limits. Note that 255.255.255.255, the limited broadcast address, lives at the very top of this range.

Why classful addressing failed

The scheme had two fatal problems, and by the early 1990s both were visibly on course to end the internet.

Problem one: catastrophic waste

There were only three usable network sizes: enormous, large, and small. Nothing in between. That meant almost every allocation was a bad fit.

Consider an organisation with 300 machines — a mid-sized company, a small college campus. A class C gives 254 usable hosts, which is not enough. So the organisation gets a class B instead, and receives 65,534 host addresses. It will use 300 of them. The rest are burned: allocated, unusable by anyone else, gone from the global pool. Repeat that across thousands of organisations and the address space drains at a rate that has almost nothing to do with how many machines are actually connected.

The class B pool was the acute crisis. It was the only size that fitted most real organisations, and with just 16,384 networks in it, it was projected to run out within a few years — long before the class A or class C pools did. IPv4 exhaustion, which we now associate with the 2010s and with the long migration to IPv6, was first forecast as a class B exhaustion problem.

Problem two: routing table growth

The obvious fix — stop handing out class Bs, give people several class Cs instead — made the second problem worse. Under classful routing, each class C is an independent network with its own entry in the global routing table. Give an organisation sixteen class C blocks and you have added sixteen routes that every backbone router in the world must carry, even if all sixteen are contiguous and all sixteen reach the same place. There was no mechanism to say “these sixteen adjacent networks are all this way” as a single route.

Backbone routing tables were growing faster than router memory could keep up. The system was going to fall over from routing-table bloat at roughly the same time it ran out of class Bs.

How CIDR replaced it

The answer, standardised as CIDR — Classless Inter-Domain Routing — in RFC 1519 in 1993, was almost embarrassingly simple: stop deriving the boundary from the address, and carry it explicitly instead.

Under CIDR, an address is always accompanied by a prefix length: /22, /29, /13, whatever it happens to be. The leading bits of the address no longer mean anything to a router. The boundary can fall anywhere in the 32 bits, and routing protocols carry the prefix length alongside every route so nobody has to guess.

Two things fall out of that change immediately.

Right-sized allocations. The 300-machine organisation now gets a /23 — 510 usable hosts, a comfortable fit — instead of a class B with 65,000 wasted addresses. The same flexibility applies inside a network too: VLSM (variable-length subnet masking) lets you carve one allocation into subnets of different sizes, so a point-to-point link between two routers can be a /30 with exactly two usable addresses, while a user LAN in the same organisation is a /22. Under classful rules every subnet of a network had to be the same size. Our CIDR calculator does this arithmetic for you if you want to see how a prefix expands into a range.

Aggregation. Because the boundary is arbitrary, many small adjacent networks can be advertised as one larger route — supernetting. Those sixteen contiguous class Cs collapse into a single /20 announcement. This is what keeps the global routing table merely large rather than impossible, and it is why address registries allocate in contiguous blocks: contiguity is what makes aggregation possible.

CIDR did not save IPv4 — the address space still ran out, and we now live with private addressing, NAT and a slow crawl toward IPv6. But it bought roughly two decades, which was enough time to design and deploy a successor.

So why do people still say “class C”?

Three reasons, none of them good.

The harm comes when the shorthand leaks into thinking. If you assume that 10.4.7.0 is “a class A and therefore a /8,” you will misread a diagram where it is actually a /24 subnet inside a larger private block. An IPv4 address on its own tells you nothing about its boundary — it has not done so since 1993. Always read it together with the prefix or mask that accompanies it.

Frequently asked questions

Are IP address classes still used?

No. CIDR replaced classful addressing in 1993, and modern routers, routing protocols and registries are entirely classless — every route carries an explicit prefix length. The class letters survive as informal shorthand, in legacy documentation, and in exam questions. Nothing in a router's forwarding decision depends on the leading bits of an address any more.

What are the class A, B and C ranges and default subnet masks?

Class A ran from 1.0.0.0 to 126.255.255.255 with a default mask of 255.0.0.0 (/8). Class B ran from 128.0.0.0 to 191.255.255.255 with a default mask of 255.255.0.0 (/16). Class C ran from 192.0.0.0 to 223.255.255.255 with a default mask of 255.255.255.0 (/24). Class D (224.0.0.0 to 239.255.255.255) is multicast with no host/network split, and class E (240.0.0.0 to 255.255.255.255) is reserved. Class A stops at 126 because 127.0.0.0/8 is reserved for loopback.

Why did classful addressing fail?

The fixed boundaries fit almost nobody. An organisation with 300 machines was too large for a class C (254 usable hosts) and so received a class B with 65,534 host addresses it would never use. Across thousands of allocations, the address space drained far faster than real usage justified. At the same time, routing tables grew unmanageably because contiguous small networks could not be aggregated into one route. CIDR fixed both by letting the network/host boundary fall anywhere.

Related reading