IPv4 vs IPv6: What's the Difference and Why It Matters

An IP address (Internet Protocol address) is a numeric label assigned to every device that talks on a network. It plays two roles at once: it identifies a host and it tells routers how to reach it, much like a street address identifies a building and helps the mail find it.

When you visit a website, your computer does not connect to a name like example.com directly. It first asks DNS to translate that name into an IP address, then opens a connection to that address. The version of IP determines what those addresses look like and how many of them can exist.

IPv4 uses 32-bit addresses, written as four numbers (called octets) separated by dots, each ranging from 0 to 255 — for example 198.51.100.10. This dotted-decimal format is the one most people recognize.

Thirty-two bits gives 2³², or roughly 4.29 billion unique addresses. In 1981 that felt limitless. But once phones, laptops, servers, cameras, and countless other devices all needed to be online, the supply ran short. The regional registries that hand out address blocks began exhausting their free pools in the 2010s, and IPv4 addresses are now a scarce, traded commodity.

IPv6 expands the address from 32 bits to 128 bits. That yields 2¹²⁸ possible addresses — about 3.4 × 10³⁸, a number so large it is effectively inexhaustible for any foreseeable use.

An IPv6 address is written as eight groups of four hexadecimal digits, separated by colons, for example 2001:0db8:0000:0000:0000:0000:0000:0001. Because that is tedious, two abbreviation rules keep it readable:

• Drop leading zeros within any group: 0db8 becomes db8, and 0000 becomes 0.
• Collapse one run of all-zero groups into a double colon ::. This may be used only once in an address, because otherwise it would be ambiguous how many zero groups it stands for.

Applying both rules, the address above shortens all the way to 2001:db8::1.

The two protocols solve the same problem but differ in nearly every detail:

Property	IPv4	IPv6
Address size	32 bits	128 bits
Format	Dotted decimal (198.51.100.10)	Hex, colon-separated (2001:db8::1)
Total addresses	~4.29 billion (232)	~3.4 × 1038 (2128)
NAT	Widely used to stretch the address pool	Rarely needed; every device can have a public address
Header	Variable length, more fields	Fixed 40-byte base header, streamlined for faster routing
Autoconfiguration	Typically via DHCP	Built-in stateless autoconfiguration (SLAAC), plus DHCPv6

IPv6 was deliberately designed to remove pain points that had accumulated around IPv4, not just to add more addresses.

IPv6 exists primarily because the world ran out of IPv4 addresses. Before it arrived, engineers extended IPv4's life with two major workarounds, both of which are still in use:

• NAT (Network Address Translation) lets many devices behind a router share a single public IPv4 address. Your home network almost certainly does this. It conserves addresses but breaks the original idea that any host can reach any other directly, complicating peer-to-peer and incoming connections.
• CIDR (Classless Inter-Domain Routing) replaced the rigid old class-A/B/C blocks with flexible prefixes like 203.0.113.0/24, so address space could be allocated in right-sized chunks and routing tables stayed manageable.

These bought time, but they treated the symptom. IPv6's enormous address space is the actual cure: enough addresses to give every device a unique, publicly routable identity without resorting to NAT.

There is no flag-day switchover. The two protocols run alongside each other, and most of the internet supports both:

• Dual-stack means a host, server, or network runs IPv4 and IPv6 at the same time, choosing whichever the other end supports.
• Happy Eyeballs (RFC 8305, updating RFC 6555) is the browser behavior that races an IPv6 connection against an IPv4 one and uses whichever responds first, so a slow or broken path on either protocol does not stall the page.
• CGNAT (carrier-grade NAT) is NAT applied at the ISP level, sharing one public IPv4 address among many customers — a common stopgap where IPv4 is scarce.
• Tunneling wraps one protocol's traffic inside the other to cross networks that only speak one of them.

For most users the result is invisible: your connection quietly uses IPv6 where available and falls back to IPv4 where it is not.

DNS is where IP versions become concrete for a domain. Two record types do the address mapping:

• An A record points a hostname at an IPv4 address, such as 198.51.100.10.
• An AAAA record (spoken "quad-A") points a hostname at an IPv6 address, such as 2001:db8::1. The four A's are a nod to IPv6 addresses being four times the size of IPv4's.

A dual-stack site publishes both: an A record and an AAAA record for the same name. A visitor's device then picks the protocol it can use. For the full mechanics, see the dedicated guide on A and AAAA records.

If you run a website, the practical question is whether to add an AAAA record so IPv6 users can reach you natively. In most cases the answer is yes, if your hosting and CDN support it:

• A large and growing share of users — especially on mobile networks — reach the internet over IPv6. Serving them natively avoids extra CGNAT hops.
• Major hosts and CDNs offer IPv6 by default or as a one-click option, so adding an AAAA record is often trivial.
• Publishing both A and AAAA is safe thanks to dual-stack and Happy Eyeballs: clients that cannot use IPv6 simply use the A record.

The one rule worth following: only publish an AAAA record if that IPv6 address actually works end to end. A broken IPv6 path can slow some users down before they fall back to IPv4, so test before you ship it.

You can inspect all of this directly:

• Run a domain through the DNS lookup to see its published A records (IPv4) and AAAA records (IPv6) side by side, along with the rest of its zone.
• Take any address — IPv4 or IPv6 — to the IP lookup to see who it is allocated to, which network announces it, and where it routes.
• For the registration details behind a domain name itself, use the WHOIS lookup.

Comparing a domain's A and AAAA records is the quickest way to tell whether a site is IPv4-only or fully dual-stack.