JPKCom DB

IP Tools — Manual

Every IP Tools feature field by field: My IP, subnet calculator for IPv4 and IPv6, converter, ULA generator, range ↔ CIDR, IANA classification, reference.

Back to the overview: IP Tools · Open the tool live: www.jpkc.com/tools/ip/

This manual describes each of the six tabs in full: what input it expects, what it outputs, and how to read the values. Tab, field, and button names are given exactly as they appear in the interface.

My IP — your current IP address

The first tab (My IP) shows the IP address your request arrives with at the server. Unlike the other tabs, it relies on a small piece of server-side PHP, because a browser can't know its own public address. It displays:

  • The address itself, shown large, with a Copy IP button.
  • Two badges: the type from the classification (e.g. Public (globally routable), Private network, Shared address space (Carrier-Grade NAT), Global unicast) and the version (IPv4 or IPv6).
  • Detail cards depending on version. IP Version, Type, and Description are always there — the description gives range, label, and RFC, for instance 192.168.0.0/16 – Private network (RFC 1918); only a public IPv4 address shows without an RFC, as 0.0.0.0/0 – Public (globally routable). For IPv4 you also get Decimal (the address as a 32-bit integer), Hexadecimal (0x…), Binary (four octets as a bit string), and IPv4-mapped IPv6 (::ffff: plus two hex groups); for IPv6, Expanded (the full eight-group form) and Compressed (the short form per RFC 5952).
  • Proxy Headers Detected — a note block that only appears when your request came through a load balancer or CDN. It recognizes X-Forwarded-For (the first entry of the list), X-Real-IP, and CF-Connecting-IP (Cloudflare); each value has to be a valid IP address or it's discarded. These headers can reveal your original IP even when the direct connection IP differs. The classification, however, always applies to the direct connection IP, not to a header value.

The classification is the same as in every other tab; see IANA classification.

IANA classification

Wherever the tool shows an address type (My IP, IP Type in the subnet calculator, Address type in the converter), it looks the address up in the IANA Special-Purpose Address Registries for IPv4 and IPv6. When more than one entry matches, the longest prefix wins — so 192.0.0.9 is Port Control Protocol anycast (/32), not just IETF protocol assignments (/24). The output takes the form range – label (RFC); a public IPv4 address appears as 0.0.0.0/0 – Public (globally routable) without an RFC.

Besides the well-known ranges (RFC 1918, loopback, link-local, CGN 100.64.0.0/10, documentation, multicast), the table covers among others:

  • IPv4: benchmarking 198.18.0.0/15, IETF protocol assignments 192.0.0.0/24 including DS-Lite (192.0.0.0/29), PCP and TURN anycast, NAT64/DNS64 discovery (192.0.0.170/31), AS112 DNS, Automatic Multicast Tunneling, the deprecated 6to4 relay 192.88.99.0/24, MCAST-TEST-NET (233.252.0.0/24), local network control multicast (224.0.0.0/24), administratively scoped multicast (239.0.0.0/8), 240.0.0.0/4, and the limited broadcast 255.255.255.255.
  • IPv6: IPv4-mapped, the deprecated IPv4-compatible ::/96, NAT64 (64:ff9b::/96 and the local-use 64:ff9b:1::/48), discard-only 100::/64, Teredo 2001::/32, benchmarking 2001:2::/48, ORCHID/ORCHIDv2, Drone Remote ID 2001:30::/28, the documentation prefixes 2001:db8::/32 and 3fff::/20, 6to4 2002::/16, SRv6 5f00::/16, ULA fc00::/7, link-local, the deprecated site-local fec0::/10, and multicast with link-local and site-local scope.

An IPv4 address that matches no entry counts as Public (globally routable). For IPv6, only 2000::/3 is called Global unicast; an address outside it and outside every special range (say 4000::1) is shown as Reserved by IETF (outside 2000::/3).

Input: what the tool accepts

All tabs share the same, deliberately strict parser. It rejects invalid input with a specific message instead of quietly reinterpreting it:

  • IPv4: exactly four numbers from 0 to 255, separated by dots. Leading zeros as in 010.1.1.1 are rejected, because some systems (inet_aton, ping) read 010 as octal 8 — the message tells you the unambiguous spelling right away. A bare integer like 3232235777 isn't valid input.
  • IPv6: groups of one to four hex digits; :: may appear only once and has to stand for at least one group of zeros (1:2:3:4:5:6:7::8 is invalid, and so is 1:::2). The last 32 bits may be written as a dotted IPv4 address (::ffff:192.0.2.1, 64:ff9b::192.0.2.33). A zone ID such as fe80::1%eth0 and square brackets ([2001:db8::1]) are accepted.
  • Networks (subnet calculator, CIDR → Range): the prefix is required. Without /… the tool reports "Add the prefix length, e.g. /24 (IPv4) or /64 (IPv6)." The prefix has to be a number from 0 to 32 (IPv4) or 0 to 128 (IPv6); /24abc is rejected. For IPv4 you can give a dotted subnet mask instead of the prefix, and it has to be contiguous (255.255.255.0, not 255.0.255.0).

Subnet Calc — subnet calculator for IPv4 and IPv6

The Subnet Calculator breaks a network down into all its parts — for IPv4 with broadcast, masks, and host range, for IPv6 with the address range and the split into sub-networks.

Input

In the Network: address with prefix length (or IPv4 subnet mask) field you enter a network in one of these forms:

  • IPv4 with a CIDR prefix: 192.168.1.50/24
  • IPv4 with a dotted subnet mask: 10.0.0.1/255.255.255.0
  • IPv6 with a prefix: 2001:db8:abcd::/48

The Quick buttons load ready-made examples with one click: 192.168.1.1/24, 10.0.0.1/8, 172.16.0.1/12, 192.168.0.100/28, 10.10.10.10/30, 2001:db8:abcd::/48, and fd00:1234::/56. Press Enter or Calculate to run.

The address doesn't have to be the start of the network. If bits beyond the prefix are set (as in 192.168.1.50/24), the tool calculates with the network the address belongs to and shows the note Host bits are set — the network is 192.168.1.0/24. at the top of the table.

Output for IPv4

The result has three blocks:

Binary Breakdown — a bit-by-bit view of the IP address, subnet mask, network address, and broadcast across all 32 bits. The network bits are colored distinctly from the host bits, so you can see at a glance where the prefix ends.

Subnet Details — a table of every derived value; addresses and masks have a copy button:

  • IP Address — your input with its prefix.
  • Network Address — the first address of the subnet (all host bits = 0).
  • Broadcast — the last address (all host bits = 1).
  • Subnet Mask — the mask in dotted notation.
  • Wildcard Mask — the inverse of the mask (for ACLs and OSPF).
  • First Usable Host and Last Usable Host — the usable host range.
  • Usable Hosts — the number of usable hosts.
  • IP Class — the classic network class (A–E) of the network address.
  • IP Type — the IANA classification, e.g. 192.168.0.0/16 – Private network (RFC 1918).
  • Total Addresses — the total number of addresses in the block (2 to the power of (32 − prefix)).

Two special cases are handled cleanly: a /31 is treated per RFC 3021 as a point-to-point link with 2 usable hosts (network and broadcast addresses count), and a /32 as a single host with 1 address. For all other prefixes the usual formula applies: usable hosts = 2 to the power of (host bits) − 2.

Subnet Splits — a preview of how the subnet could be divided further. For prefixes shorter than /30, the tool shows the next four narrower prefixes (prefix +1 through +4, up to /30), each with the host count per sub-network and up to four concrete example subnets; if there are more than four, it adds the total number of sub-networks. If the subnet is already /30 or narrower, a note appears that no useful further splits are possible.

Output for IPv6

For an IPv6 prefix, Subnet Details shows these rows:

  • Address — the address you entered, in RFC 5952 notation with its prefix.
  • Network — the network with its prefix, e.g. 2001:db8:abcd::/48.
  • First address and Last address — start and end of the range. IPv6 has no broadcast address.
  • Expanded network — the network address in its full eight-group form.
  • Addresses — the number of addresses, written out exactly and as a power of two (… (2^80) for a /48).
  • /64 subnets — how many /64 networks the prefix contains; only shown for prefixes up to /64.
  • Address type — the IANA classification.

For IPv6, the Binary Breakdown only shows the note "Binary view is shown for IPv4 only." The Subnet Splits follow the usual boundaries /48, /52, /56, /60, and /64: the tool takes the next up to four of them that are narrower than your prefix and lists the number of sub-networks for each, plus the first four examples. If your prefix is /64 or narrower, it shows prefix +1, +2, and +4 instead; for a /128 it says "A /128 is a single address."

After the first calculation, the tab hides the How Subnetting Works explainer box to make room for the result.

Converter — IP address converter

The IP Address Converter turns a single address into every common notation. You enter an address in the IPv4 or IPv6 Address field; the tool detects the version itself. Run it with Convert or Enter; the Examples buttons load 192.168.1.1, 8.8.8.8, ::1, ::ffff:192.168.1.1, or 2001:db8::1. Whenever you open the tab with an empty field, it fills in your own IP from the My IP tab and converts it right away. If the input is invalid, the error message "Invalid IP address: …" states the exact reason.

IPv4 input

For an IPv4 address, the results table gives you:

  • Dotted decimal (IPv4) — the normal dotted notation.
  • Hexadecimal — the address as 0x… (8 hex digits).
  • Decimal integer — the address as a 32-bit integer (e.g. 192.168.1.1 → 3232235777).
  • Binary (octets) — four octets as a bit string.
  • IPv4-mapped IPv6 — the embedding into IPv6 in mixed notation, ::ffff:192.168.1.1.
  • IPv4-mapped IPv6 (hex) — the same address as two hex groups, ::ffff:c0a8:0101.
  • NAT64 (64:ff9b::/96) — the address in the NAT64 well-known prefix per RFC 6052, 64:ff9b::192.168.1.1.
  • 6to4 prefix — the corresponding 2002:…::/48 prefix (RFC 3056).
  • Reverse DNS — the name for the PTR lookup, e.g. 1.1.168.192.in-addr.arpa.
  • Address type — the IANA classification.

IPv6 input

For an IPv6 address, the table always gives you:

  • Compressed IPv6 (RFC 5952) — the canonical short form: lower case, no leading zeros, the longest run of zero groups (two or more) as ::.
  • Expanded IPv6 — the full eight-group form with four hex digits each.
  • Address type — the IANA classification.
  • Decimal integer (128-bit) — the entire address as a 128-bit integer (computed via BigInt).
  • Reverse DNS — the name under ip6.arpa: all 32 hex digits in reverse, separated by dots.

Context-dependent rows appear in addition:

  • Zone ID — when you entered a zone ID (fe80::1%eth0). It names the network interface and only means something on your own machine.
  • Mixed notation, Embedded IPv4, and IPv4 decimal — for addresses with an embedded IPv4: IPv4-mapped (::ffff:0:0/96), NAT64 (64:ff9b::/96 and 64:ff9b:1::/48), and the deprecated IPv4-compatible ::/96. Mixed notation writes the last 32 bits as IPv4, e.g. 64:ff9b::192.0.2.33.
  • Embedded IPv4 (6to4) — for a 6to4 address (2002::/16), the IPv4 from bits 16 to 47.
  • Teredo server and Teredo client (public IPv4:port) — for a Teredo address (2001::/32), the tool decodes per RFC 4380 the Teredo server's IPv4 as well as the client's public IPv4 and port, which the address stores inverted.

Every value row except Address type has a copy button.

IPv6 ULA — generator for private IPv6 addresses

The IPv6 ULA Generator produces a private IPv6 address, the IPv6 counterpart to the RFC 1918 ranges (10.x, 172.16.x, 192.168.x).

What a ULA is

Unique Local Addresses (ULA) per RFC 4193 are meant for use inside private networks. They use the fd00::/8 prefix. The key point: the 40-bit Global ID is randomly generated so it is statistically unique worldwide. That lets two networks be merged without address conflicts — a clear advantage over the fixed IPv4 private ranges. (The other half of the range, fc00::/8, is reserved for future central allocation; the usable part today is fd00::/8.)

How the ULA is generated

Clicking Generate Random ULA pulls five cryptographically random bytes from the browser function crypto.getRandomValues — those are the 40 bits of the Global ID. From them the tool builds the ULA prefix following the fixed scheme fd + Global ID. The tab generates a first ULA automatically when you open it. It outputs four cards, each with a copy button:

  • /48 Prefix (assign to your site) — the prefix you assign to your location, e.g. fdxx:xxxx:xxxx::/48.
  • /64 Example Subnet (first subnet) — the first /64 sub-network (…:0001::/64).
  • Example Host Address — a sample host address in that sub-network (…:0001::1).
  • Global ID (random, 40 bits) — the raw 40-bit Global ID as hex.

Below that, an Address Structure graphic shows the bit layout of the 128-bit address by color: fd as the 8-bit prefix, the 40-bit Global ID, the 16-bit Subnet ID, and the 64-bit Interface ID.

The ULA structure in detail

The info block at the end of the tab lays out all 128 bits in full:

Bits Field Value
7 Prefix 1111110
1 L-bit 1 (locally assigned)
40 Global ID random (crypto)
16 Subnet ID your choice (0–65535)
64 Interface ID EUI-64 or random

The first eight bits (seven prefix bits plus the set L-bit) together produce the fixed value fd. The block also lists typical use cases (internal services, lab/test environments, addresses independent of ISP assignment, conflict-free merging of two networks) and explains the EUI-64 derivation of the Interface ID: insert FF:FE into the middle of the 48-bit MAC and flip bit 7 — example 00:1A:2B:3C:4D:5E → 021a:2bff:fe3c:4d5e.

IP Range — range ↔ CIDR

The IP Range Calculator converts both ways between an address range and CIDR blocks — for IPv4 and IPv6. The tab is split into two cards.

Range → CIDRs

You enter a Start IP (IPv4 or IPv6) and an End IP and click Calculate CIDRs (or press Enter). The Quick buttons fill both fields with examples: 192.168.1.0–192.168.1.255, 10.0.0.0–10.0.0.63, 192.168.1.1–192.168.1.30, 10.0.1.0–10.0.3.255, and 2001:db8::–2001:db8::1:ffff. Both addresses have to be the same version, and the start address must not come after the end address — otherwise the tool reports an error. The tool computes the minimal list of CIDR blocks that exactly cover the range. The algorithm is greedy: at the current start address it finds the largest aligned block that doesn't run past the end, subtracts it, and repeats. A range whose size isn't a power of two therefore always needs several CIDRs.

It outputs a summary (range, total number of addresses, number of CIDR blocks) and a table with CIDR, First, Last, and Addresses per block; each row's copy button copies the CIDR block. A Copy all CIDRs button copies the whole list line by line, handy for firewall rules.

CIDR → Range

Here you enter a prefix in the CIDR notation (IPv4 or IPv6) field (e.g. 10.0.0.0/22) and click Show Range or press Enter. There are Quick buttons for 10.0.0.0/8, 172.16.0.0/12, 192.168.0.0/16, 192.168.1.0/24, and 2001:db8:abcd::/48. The prefix is required; if bits beyond the prefix are set, the tool calculates with the network the address belongs to and says so ("Host bits are set — using the network …").

For IPv4, the table shows:

  • CIDR, Start (network), End (broadcast)
  • First usable and Last usable
  • Usable hosts
  • Subnet mask and Wildcard mask
  • Total addresses

Below it you see the block's share of the whole IPv4 address space ("Share of the whole IPv4 address space"): as a percentage from 0.01 percent upward, as a fraction for smaller blocks (a /22 is 1/4,194,304), plus a bar.

For IPv6, the table shows CIDR, Start, End, and Total addresses — written out exactly and as a power of two. Every row has a copy button.

Reference — lookup tables

The Reference tab is a pure lookup resource with no input. It contains:

  • IPv4 Special Address Ranges — a table of reserved and private IPv4 ranges with range, CIDR, host count, type, and RFC: the three private ranges (10/8, 172.16/12, 192.168/16, RFC 1918), loopback (127/8), link-local/APIPA (169.254/16), shared/CGN (100.64/10), IETF protocol (192.0.0.0/24), the documentation ranges (TEST-NET-1 through -3), benchmarking (198.18/15), multicast documentation (233.252.0.0/24), multicast (224/4), reserved (240/4), broadcast (255.255.255.255), and "this network" (0/8).
  • IPv6 Special Address Ranges — the key IPv6 prefixes: loopback (::1/128), unspecified (::/128), IPv4-mapped (::ffff:0:0/96), NAT64 (64:ff9b::/96), ULA (fc00::/7), link-local (fe80::/10), multicast (ff00::/8), global unicast (2000::/3), documentation (2001:db8::/32 and 3fff::/20), 6to4 (2002::/16), discard-only (100::/64), Teredo (2001::/32), benchmarking (2001:2::/48), and the deprecated site-local (fec0::/10).
  • IPv4 Classful Network Classes — the classic classes A through E with range, default mask, number of networks, and hosts per network.
  • IPv4 CIDR Quick Reference — a complete table of every prefix from /0 to /32 with subnet mask, host count, the number of sub-networks of a /24, and notes. The All and Common buttons switch between every prefix and just the common ones (/8, /12, /16, and /20 through /32).
  • Key Concepts — short explanations of IPv4 vs. IPv6, CIDR, NAT, subnet vs. wildcard mask, VLSM, and IPv6 Prefix Delegation.

The two special-range tables are a selection for quick lookup. The fuller list the tool actually classifies addresses against is described in IANA classification.

Limits and notes

  • IPv4 and IPv6 almost everywhere. The subnet calculator, the converter, and both range directions handle both versions. IPv4-only are the Binary Breakdown, broadcast, masks, and usable hosts (concepts IPv6 doesn't have in that form), the share of the address space, and the IPv4 CIDR Quick Reference.
  • Everything except My IP runs purely in the browser. There's no API, no data transfer, and the tool stores nothing; the ULA randomness comes from crypto.getRandomValues.
  • US number format. Large values use a comma as the thousands separator (1,024).
  • My IP only reflects your request. The address (and any proxy headers) come from the live request and are not stored.

For the introduction and the big picture, see the overview; for concrete calculations, the examples. You can try everything directly in the tool.