IP Address Validator

• Step 1: Type or paste an IP address into the input field. The validator accepts both IPv4 addresses (such as 192.168.1.1) and IPv6 addresses (such as 2001:db8::1).

• Step 2: Get the verdict. The result updates instantly as you type, and you can also click "Validate IP Address" to run the check on the current input.

• Step 3: Read the result. A valid address receives a confirmation along with its version (IPv4 or IPv6) and a breakdown of its parts: the four octets for IPv4, or the segments for IPv6. An invalid address receives an error message identifying what is wrong with its format.

• Step 4: Check the classification (IPv4). For IPv4 addresses, the tool also reports the address type: private (Class A, B, or C), loopback, multicast, reserved, or public.

• Step 5: Use the result for its intended purpose: verifying configuration entries, debugging network scripts, testing form validation logic that accepts IP addresses, or learning how IP address notation works.

What this validator checks

• Whether the address is a valid IPv4 or IPv6 format

• Which version (IPv4 or IPv6) the address belongs to

• The address type for IPv4 addresses (private, loopback, multicast, reserved, or public)

• A specific error message for invalid addresses

The classification is a simplified guide based on the first octets of the address. Other special IPv4 ranges described below, such as link-local (169.254.x.x) and documentation addresses, are not listed separately and appear under the general public category, so check the reserved ranges in this article when the exact category matters.

What this validator does not check

• Whether the IP address belongs to any active device

• Whether the IP address is reachable from your network

• Whether the IP address is assigned to any particular organization

• Geolocation or ISP information for the address

IPv4 (Internet Protocol version 4) is the original and still most widely used IP addressing system. An IPv4 address is a 32-bit number written as four decimal numbers (called octets) separated by dots. The basic structure is W.X.Y.Z, where W, X, Y, and Z are each a decimal number from 0 to 255.

Rules for a valid IPv4 address

• Exactly four octets: no more, no fewer. Three-octet or five-octet strings are not valid IPv4 addresses.

• Each octet from 0 to 255 inclusive. The number 256 and above are invalid because each octet represents 8 bits and the maximum 8-bit value is 255 (binary 11111111).

• No leading zeros: 192.168.01.1 is not a valid IPv4 address in strict notation because 01 has a leading zero. Some parsers accept leading zeros but others interpret them as octal notation (causing 010 to be read as 8 rather than 10). Strict IPv4 notation prohibits leading zeros to avoid ambiguity.

• Only digits and dots: letters, hyphens, underscores, and other characters are not valid in an IPv4 address.

• Dots separate octets only: no trailing dot, no leading dot, no consecutive dots.

Valid IPv4 address examples

• 192.168.1.1 (private network address)

• 10.0.0.1 (private network address)

• 172.16.0.1 (private network address)

• 8.8.8.8 (Google's public DNS server)

• 1.1.1.1 (Cloudflare's public DNS server)

• 127.0.0.1 (loopback address)

• 255.255.255.255 (broadcast address)

• 0.0.0.0 (unspecified address)

Invalid IPv4 address examples

• 256.168.1.1 (first octet 256 exceeds the maximum of 255)

• 192.168.1 (only three octets)

• 192.168.1.1.5 (five octets)

• 192.168.01.1 (leading zero in third octet)

• 192.168.1.a (letter in fourth octet)

• 192.168..1 (consecutive dots, missing octet)

• .192.168.1.1 (leading dot)

• 192.168.1.1. (trailing dot)

Not all valid IPv4 addresses serve the same purpose. Understanding the reserved and special ranges helps interpret the address type the validator reports.

Private address ranges (RFC 1918)

These ranges are reserved for private networks (home networks, corporate intranets, data center internal networks) and are not routable on the public internet. Routers on the internet do not forward packets to these addresses.

• 10.0.0.0 to 10.255.255.255 (10.0.0.0/8): the traditional Class A private range. 16,777,216 addresses. Used for large corporate networks.

• 172.16.0.0 to 172.31.255.255 (172.16.0.0/12): the traditional Class B private range. 1,048,576 addresses. Used for medium corporate and data center networks.

• 192.168.0.0 to 192.168.255.255 (192.168.0.0/16): the traditional Class C private range. 65,536 addresses. Most commonly used in home routers and small office networks.

Loopback address

127.0.0.0 to 127.255.255.255 (127.0.0.0/8) is reserved for loopback. Traffic sent to any address in this range is looped back to the sending device without going out to the network. 127.0.0.1 is the standard loopback address (also called localhost) used to refer to the local machine.

Link-local addresses (APIPA)

169.254.0.0 to 169.254.255.255 (169.254.0.0/16) is assigned automatically by a device when it cannot obtain an IP address from a DHCP server. On Windows this is also called APIPA (Automatic Private IP Addressing). A device with a 169.254.x.x address typically cannot reach the internet or other network resources, indicating a DHCP configuration problem.

Multicast addresses

224.0.0.0 to 239.255.255.255 (224.0.0.0/4) is reserved for multicast communications, where a single packet is delivered to multiple destinations simultaneously. It is used by routing protocols, streaming protocols, and service discovery mechanisms. This range was historically called Class D.

Reserved and broadcast addresses

240.0.0.0 to 255.255.255.254 (historically Class E) is reserved for future use and is not used on the public internet. The address 255.255.255.255 is the limited broadcast address, which sends to all hosts on the local network segment and is not routable beyond the local subnet.

Documentation and example addresses

192.0.2.0/24, 198.51.100.0/24, and 203.0.113.0/24 are reserved for documentation and example use in books, tutorials, and RFCs. This is equivalent to using "example.com" for domain names in documentation.

Other special ranges

A few other ranges are also set aside, such as 0.0.0.0/8 ("this network") and 100.64.0.0/10 (shared address space used by some internet providers for carrier-grade NAT). Addresses in these ranges are valid IPv4 but are not ordinary public addresses.

Public addresses

All other IPv4 addresses not in the reserved ranges above are public addresses, routable on the internet and assigned to organizations by the Internet Assigned Numbers Authority (IANA) and regional internet registries (ARIN, RIPE, APNIC, LACNIC, AFRINIC).

IPv6 (Internet Protocol version 6) was developed to replace IPv4 due to the exhaustion of the IPv4 address space. While IPv4 provides approximately 4.3 billion unique addresses (2^32), IPv6 provides approximately 340 undecillion addresses (2^128), a number so large that address scarcity is effectively no longer a concern.

The basic structure

An IPv6 address is a 128-bit number written as eight groups of four hexadecimal digits, separated by colons:

2001:0db8:0000:0000:0000:0000:0000:0001

Rules for a valid IPv6 address

• Exactly eight groups when fully expanded, separated by colons. Each group is up to four hexadecimal digits (0 through 9 and a through f, case-insensitive).

• Leading zeros within a group can be omitted: 0001 can be written as 1, and 0db8 can stay 0db8 or be written as db8.

• One or more consecutive groups of all zeros can be replaced with a double colon (::), but this abbreviation can appear at most once in an address. The double colon expands to fill as many groups of zeros as needed to complete the full eight groups.

IPv6 abbreviation examples

• Full: 2001:0db8:0000:0000:0000:0000:0000:0001. Remove leading zeros: 2001:db8:0:0:0:0:0:1. Apply :: to the consecutive zero groups: 2001:db8::1

• Full: fe80:0000:0000:0000:0202:b3ff:fe1e:8329. Remove leading zeros: fe80:0:0:0:202:b3ff:fe1e:8329. Apply :: to the consecutive zero groups: fe80::202:b3ff:fe1e:8329

• Loopback: 0000:0000:0000:0000:0000:0000:0000:0001. Abbreviated: ::1

• Unspecified: 0000:0000:0000:0000:0000:0000:0000:0000. Abbreviated: ::

Invalid IPv6 address examples

• 2001:db8::1::2 (double colon appears twice, not permitted)

• 2001:db8:0:0:0:0:0:0:1 (nine groups instead of eight)

• 2001:db8:xyz::1 (xyz contains invalid characters, only hex digits allowed)

• 2001:db8:0000:0000:0000:0000:0000 (only seven groups, one missing, and no :: to fill the gap)

• :::1 (triple colon is not valid notation)

IPv4-mapped IPv6 addresses

IPv6 includes a notation for representing IPv4 addresses: ::ffff:192.168.1.1. This is a valid IPv6 address that maps to the IPv4 address 192.168.1.1. Systems that support dual-stack networking use this notation to represent IPv4 connections in an IPv6 context. Simple validators may not accept this mixed notation even though it is valid.

IPv6 has its own set of reserved and special address ranges, analogous to IPv4's reserved ranges. Note that the classification panel of this tool currently covers IPv4 addresses only, so use this section as a reference for IPv6 categories.

• Loopback: ::1 (the short form of 0:0:0:0:0:0:0:1) is the IPv6 loopback address, equivalent to IPv4's 127.0.0.1. Traffic sent to ::1 is looped back to the local device.

• Unspecified: :: (all zeros) is the unspecified address, equivalent to IPv4's 0.0.0.0. It is used by a device before it has been assigned an address.

• Link-local (fe80::/10): addresses beginning with fe80 through febf are link-local. These are automatically configured on every IPv6-capable interface and are only valid within a single network segment (link). They cannot be routed between networks.

• Unique local addresses (fc00::/7): addresses beginning with fc or fd, roughly equivalent to IPv4's private address ranges (RFC 1918). They are intended for local communications within a site or organization and are not globally routable.

• Global unicast (2000::/3): addresses beginning with 2 or 3, the equivalent of public IPv4 addresses. They are globally routable on the internet.

• Multicast (ff00::/8): addresses beginning with ff, used for one-to-many communications.

• Documentation (2001:db8::/32): reserved for documentation and example use in tutorials and RFCs, equivalent to IPv4's 192.0.2.0/24 documentation range. The IPv6 examples in Thetoolity's tool use this documentation range deliberately.

• Address length: IPv4 uses 32 bits, providing approximately 4.3 billion unique addresses. IPv6 uses 128 bits, providing approximately 340 undecillion (3.4 times 10^38) unique addresses.

• Notation: IPv4 uses four decimal octets separated by dots (192.168.1.1). IPv6 uses eight groups of hexadecimal digits separated by colons (2001:db8::1), with abbreviation rules for consecutive zero groups.

• Address space exhaustion: the IPv4 address space was effectively exhausted around 2011, when IANA allocated its last address blocks to regional registries. IPv4 addresses are now scarce and expensive on secondary markets. IPv6 was designed specifically to solve this exhaustion problem.

• Header complexity: IPv4 packet headers have variable length and include a checksum field that routers must process. IPv6 headers have a fixed length (40 bytes) and removed the header checksum, making router processing simpler.

• NAT (Network Address Translation): because IPv4 addresses are scarce, most home and corporate networks use NAT: a router gives private IPv4 addresses to all internal devices and translates them to a single public IP address for internet traffic. IPv6's vast address space removes the need for NAT for address conservation, because every device can have a globally unique routable address.

• Adoption: despite being standardized in 1998, IPv6 adoption remained slow for many years. In recent years, roughly 40 to 50 percent of users reaching Google have done so over IPv6, according to Google's published statistics, which you can check for current figures. Major ISPs, cloud providers, and mobile networks have deployed IPv6, but IPv4 remains in wide use across the internet.

Web development contexts

IP addresses appear throughout web development: server configurations, API access control lists, firewall rules, reverse proxy configurations, rate limiting and allow-lists that restrict by IP, database connection strings, SSH configuration, and network debugging. Validating an IP address before using it in configuration prevents typos that cause misconfiguration.

Regular expressions for IP validation

Developers often write regular expressions to validate IP addresses in application code. A common but imprecise approach is to match the pattern of four numbers separated by dots, which can pass invalid addresses like 999.999.999.999. A correct IPv4 pattern must also verify that each octet is between 0 and 255. Many older patterns also allow leading zeros such as 01 or 001, which strict notation does not permit. A stricter formulation:

^(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}$

IPv6 regular expressions are significantly more complex due to the :: abbreviation rule and the multiple valid notations for the same address. In most programming languages it is safer to use the built-in IP parsing function of the standard library than to write your own pattern.

CIDR notation

CIDR (Classless Inter-Domain Routing) notation expresses a block of IP addresses as a base address followed by a slash and a prefix length: 192.168.1.0/24. The prefix length (24 in this example) indicates how many bits of the address are fixed as the network portion. The remaining bits (8 in a /24) identify individual hosts within the block. Common CIDR ranges:

• /8: 16,777,216 addresses (the size of a traditional Class A block)

• /16: 65,536 addresses (the size of a traditional Class B block)

• /24: 256 addresses (the size of a traditional Class C block, a typical small network)

• /32: exactly 1 address (a single host)

CIDR notation is used in firewall rules, routing tables, subnet configuration, and security group policies in cloud platforms like AWS, Google Cloud, and Azure.

DNS and IP addresses

Domain names (like example.com) are mapped to IP addresses through the Domain Name System (DNS). When a browser loads a website, it first queries DNS to find the IP address of the server, then connects to that IP address. An A record maps a domain to an IPv4 address. An AAAA record maps a domain to an IPv6 address.

Server logs

Web server access logs record the IP address of every visitor. Log analysis tools parse these addresses to identify traffic patterns, detect attacks, and block malicious sources. Validating IP address strings encountered in log files helps ensure they are genuine IP addresses rather than injection attempts.

Thetoolity brings together a growing collection of free, fast, and clean online tools for network engineers, system administrators, developers, students, and anyone working with network configuration. Our IP address validator handles both IPv4 and IPv6 format validation instantly in your browser, identifies the address version, and helps you understand address categories.

No accounts. No subscriptions. No cluttered interfaces. No data stored or transmitted. Just a clean, instant IP address format check.

Explore the full collection at Thetoolity.com and find generators, converters, calculators, checkers, and testers, all free and all instant.