🌐 IP Address Validator (IPv4 and IPv6)

What is the IP Address Validator?

An IP (Internet Protocol) address is the numeric label that identifies a device on a network. There are two versions in use today. IPv4 is a 32-bit address written as four decimal numbers (octets) from 0 to 255 separated by dots, such as 192.168.1.1, giving about 4.3 billion possible addresses. IPv6 is a 128-bit address written as eight groups of four hexadecimal digits separated by colons, such as 2001:0db8:0000:0000:0000:0000:0000:0001, giving an effectively unlimited supply. Validating an address means checking that it follows these exact rules: the right number of parts, each part within range, and the correct separators, which is exactly what an ip address validator like this one is built to do.

Strict validation matters because almost-correct strings are common and dangerous. A leading zero like 192.168.01.1 is ambiguous (some systems read it as octal), 256.0.0.1 is out of range, and an IPv6 string with two "::" compressions is undefined because the parser cannot tell how many zero groups each one represents. This tool rejects all of those. For IPv4 it requires exactly four octets, each 0 to 255 with no leading zeros. For IPv6 it allows one "::" to compress a run of zero groups, allows an embedded IPv4 tail such as ::ffff:192.0.2.1, and otherwise expects eight valid hex groups.

Knowing the scope of a valid address is just as useful as knowing it is valid. IPv4 reserves whole ranges for special jobs: 10.0.0.0/8, 172.16.0.0/12, and 192.168.0.0/16 are private (RFC 1918) and never appear on the public internet, 127.0.0.0/8 is loopback (your own machine), and 169.254.0.0/16 is link-local (APIPA) assigned automatically when DHCP fails. IPv6 has parallel ranges: ::1 is loopback, fe80::/10 is link-local, fc00::/7 is unique local, and ff00::/8 is multicast. The tool labels these so you can tell at a glance whether an address is routable on the public internet or confined to a local network.

Many developers reach for a regular expression to validate an IP address, and while a regex can catch obvious format errors, writing a fully correct one is harder than it looks. A naive IPv4 pattern like \d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3} will happily accept 999.999.999.999 because it does not check the numeric range of each octet, and it will also accept leading zeros unless the pattern is written carefully with negative lookaheads. IPv6 is worse: a correct regex needs to handle full-length addresses, single "::" compression at any position, and embedded IPv4 tails, which is why most production systems either use a battle-tested library or, like this ip address validator, parse the address field by field instead of relying on one giant pattern.

CIDR (Classless Inter-Domain Routing) notation often shows up next to an IP address, written as a slash followed by a prefix length, such as 192.168.1.0/24 or 2001:db8::/32. The prefix length is not part of the address itself, it describes a whole range of addresses that share the same leading bits, so a validator that checks a single address does not need a CIDR suffix, and adding one to a plain address check should be treated as a separate, invalid input for this tool. Understanding that distinction avoids a common source of false "invalid" reports when people paste a subnet instead of a single host address.

Dual-stack networks, where a device has both an IPv4 and an IPv6 address at the same time, are now the norm rather than the exception, and NAT64 or IPv4-mapped IPv6 addresses (the ::ffff:a.b.c.d form) exist specifically to bridge the two families during the long transition away from IPv4. Recognizing that a string like ::ffff:192.0.2.128 is valid IPv6 with an embedded IPv4 address, rather than rejecting it as malformed, is one of the details that separates a thorough ip address validator from a quick regex check.

When to use it

• Checking that a user-entered IP in a form or config file is actually well-formed before you store or use it.
• Confirming whether an address is private, public, or loopback when debugging a network or firewall rule.
• Validating IPv6 addresses, including compressed "::" forms, that are easy to mistype by hand.
• Teaching or learning the difference between IPv4 and IPv6 notation and the reserved address ranges.
• Sanity-checking a log file, allowlist, or DNS record before deploying it, using an ip address validator instead of eyeballing dozens of entries.
• Verifying an IPv4-mapped IPv6 address (such as ::ffff:203.0.113.1) that a dual-stack service reported.

How to use the IP Address Validator

1. Type or paste an IPv4 or IPv6 address into the input field.
2. Press Validate (or just keep typing, it checks as you go).
3. Read the verdict: valid or invalid, plus the version and scope.
4. For IPv4, note the class and whether it is private or public. For IPv6, see the expanded form and whether it is compressed.
5. Use the IPv4 sample or IPv6 sample buttons to see an example, or Clear to start over.

Formula & method

Worked examples

IPv4 address classes by leading octet

Common reserved IPv4 ranges and what they mean

Common reserved IPv6 ranges

Common mistakes to avoid

• Allowing leading zeros in IPv4 octets. Strings like 192.168.01.1 or 010.0.0.1 look fine but are ambiguous: some libraries read a leading zero as octal, so 010 becomes 8. This validator rejects leading zeros so the meaning is never in doubt.
• Using more than one "::" in IPv6. The double colon stands for a run of zero groups, but it can appear at most once. With two of them, like 2001::25de::cade, the parser cannot tell how many zeros each one represents, so the address is invalid.
• Octets out of range. Each IPv4 octet must be 0 to 255 because it is one byte. Values like 256 or 300 are common typos and are not valid, even though the dotted shape looks correct.
• Confusing a private address with a public one. A valid address is not necessarily reachable from the internet. Ranges like 192.168.x.x and 10.x.x.x are private and only work inside a local network, so check the scope, not just validity.
• Pasting a CIDR range instead of a single address. A string like 192.168.1.0/24 describes a whole block of addresses, not one host. Most single-address validators, including this one, expect just the address without the slash and prefix length.
• Trusting a regex that skips numeric range checks. A quick pattern such as \d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3} matches the shape of an IPv4 address but will also accept 999.999.999.999, since it never checks that each part is 0 to 255. A reliable ip address validator has to parse and range-check every octet, not just match dots and digits.

Glossary

IPv4

A 32-bit IP address written as four decimal octets 0 to 255 separated by dots, for example 203.0.113.5.

IPv6

A 128-bit IP address written as eight groups of four hexadecimal digits separated by colons, for example 2001:db8::1.

Octet

One of the four numbers in an IPv4 address. Each is a single byte, so it ranges from 0 to 255.

Private address

An IP from a range reserved for internal networks (such as 192.168.0.0/16) that is never routed on the public internet.

Loopback

An address that refers back to the local machine itself: 127.0.0.1 in IPv4 and ::1 in IPv6.

Compression (::)

A shorthand in IPv6 where a single double colon replaces one or more consecutive groups of all zeros, allowed only once per address.

CIDR notation

A way to describe an address range as a prefix plus a slash and a bit length, such as 10.0.0.0/8.

IPv4-mapped address

An IPv6 address of the form ::ffff:a.b.c.d that embeds an IPv4 address, used by dual-stack systems to represent IPv4 traffic in IPv6 form.

Frequently asked questions