Reverse PTR Name Builder (IPv6)

The Reverse PTR Name Builder for IPv6 converts IPv6 addresses into their ip6.arpa nibble-format reverse DNS names used for PTR records. Enter an address like 2001:db8::1 and the tool returns the full 74-character reverse name 1.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.8.b.d.0.1.0.0.2.ip6.arpa. Each hexadecimal digit becomes a separate DNS label, producing names that are impractical to construct by hand.

Understanding IPv6 Reverse DNS

IPv6 reverse DNS works on the same principle as IPv4 reverse DNS, but the format is dramatically different. Where IPv4 reverses four octets to build names in in-addr.arpa, IPv6 reverses 32 individual hexadecimal digits (called nibbles) to build names in ip6.arpa. The result is a DNS name that is typically 73-74 characters long, with 32 single-character labels separated by dots. Constructing these names by hand is not just tedious, it is practically guaranteed to produce errors.

The nibble format exists because IPv6 addresses are 128 bits long, represented as 32 hexadecimal digits. Each digit corresponds to 4 bits, and DNS delegation for IPv6 reverse zones happens at nibble boundaries. This means zone delegation is clean at prefix lengths that are multiples of 4 (like /32, /48, and /64) and requires special handling at non-nibble boundaries. A typical organization with a /32 allocation manages a reverse zone defined by the first 8 nibbles of their allocation, with the remaining 24 nibbles forming individual PTR record names within that zone.

This tool handles the entire conversion automatically. You enter any valid IPv6 address in any format -- compressed, fully expanded, or mixed -- and the tool normalizes it, reverses the nibbles, and produces the complete ip6.arpa name. It also identifies zone delegation boundaries for common prefix lengths, which is essential when setting up reverse zones in BIND, Knot, or PowerDNS.

How to Build an IPv6 Reverse PTR Name

1. Enter an IPv6 address in any format -- compressed, expanded, or mixed (e.g., 2001:db8::1)
2. The tool expands the address to its full 32 hex digits
3. Each digit is reversed and separated by dots, with .ip6.arpa appended
4. Copy the generated PTR name for use in your reverse DNS zone file

IPv6 Reverse DNS Name Examples

Reverse Zone Names by Prefix Length

When to Use the IPv6 PTR Name Builder

• Setting up IPv6 reverse DNS zones -- Constructing the zone name and individual PTR record names for BIND, Knot, or PowerDNS
• Email server configuration -- Mail systems increasingly perform reverse lookups on IPv6 sender addresses; missing PTR records cause delivery failures
• Verifying dig -x queries -- Confirming the correct nibble-format name before troubleshooting reverse resolution
• ISP reverse delegation requests -- Providing the exact zone name when requesting delegation of your IPv6 reverse space
• Bulk PTR record generation -- Processing multiple IPv6 addresses for automated zone file creation
• Audit documentation -- Recording the reverse names for all IPv6 addresses in your allocation

How IPv6 Reverse DNS (Nibble Format) Works

IPv6 reverse DNS uses the ip6.arpa domain with a nibble-based naming scheme. Unlike IPv4 where octets are reversed, IPv6 reverses individual hexadecimal digits (nibbles).

Conversion Process

1. Expand the address: Convert any compressed IPv6 address to its full 8-group, 32-digit form. 2001:db8::1 becomes 2001:0db8:0000:0000:0000:0000:0000:0001.

2. Remove colons: Strip the group separators to get a flat 32-character hex string: 20010db8000000000000000000000001.

3. Reverse the string: Reverse the order of all 32 characters: 10000000000000000000000008bd01002.

4. Separate with dots: Place a dot between every character: 1.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.8.b.d.0.1.0.0.2.

5. Append the suffix: Add .ip6.arpa to get the full reverse name.

Zone Delegation Boundaries

IPv6 reverse zones are delegated at nibble boundaries, which correspond to prefix lengths that are multiples of 4. Common delegation points:

• /32 allocation (typical for an organization): 8 nibbles define the zone, leaving 24 nibbles for PTR records within the zone
• /48 allocation (typical site prefix): 12 nibbles define the zone, with 20 nibbles for records
• /64 subnet: 16 nibbles for the zone, 16 nibbles for host records

For prefix lengths that are not multiples of 4 (such as /33 or /47), delegation requires special handling similar to IPv4 classless delegation, though this is uncommon in practice.

PTR Record in a Zone File

For the zone 8.b.d.0.1.0.0.2.ip6.arpa (representing 2001:db8::/32), a PTR record for 2001:db8::1 would be:

1.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0  IN  PTR  host.example.com.

The left side contains the 24 nibbles that follow the zone's 8 nibbles, covering the remaining portion of the full 32-nibble address.

IPv6 Reverse DNS in Practice

The biggest practical challenge with IPv6 reverse DNS is the sheer length of the names. A single transposed character in a 32-nibble name creates a PTR record for the wrong IP address, and it is nearly impossible to spot the error by visual inspection. This is why automated tools are essential for IPv6 reverse DNS management. Never construct these names by hand in production zone files.

For email delivery, IPv6 reverse DNS is increasingly critical. Major providers including Gmail, Outlook, and Yahoo perform FCrDNS checks on IPv6 sender addresses, and messages from IPv6 addresses without valid PTR records are routinely rejected. If your mail infrastructure uses IPv6 (which is becoming more common), ensure every outbound IP has a matching PTR record. Use this tool to build the correct ip6.arpa name, then verify the record with dig -x after deployment.

When managing IPv6 reverse zones for large allocations, be strategic about what you populate. A /48 allocation has 2^80 possible host addresses, and you obviously cannot create PTR records for all of them. Focus on addresses that are actually in use: server interfaces, mail relays, DNS resolvers, and any other hosts that interact with systems that perform reverse lookups. Many organizations use SLAAC or DHCPv6 for client devices, and those devices typically do not need individual PTR records unless they run services that require reverse DNS.

Frequently Asked Questions

Why are IPv6 reverse names so long?

IPv6 addresses are 128 bits, represented as 32 hexadecimal digits. Since each digit becomes a separate DNS label in the nibble format, the reverse name contains 32 single-character labels plus the ip6.arpa suffix. This produces names that are typically 73-74 characters long, making manual construction extremely error-prone.

Can I use compressed IPv6 addresses as input?

Yes. The tool accepts any valid IPv6 representation, including compressed forms like 2001:db8::1, fully expanded forms like 2001:0db8:0000:0000:0000:0000:0000:0001, and mixed notation. All formats are normalized to the full 32-digit expansion before conversion.

Do I need IPv6 PTR records for email delivery?

Yes, if your mail server sends email from an IPv6 address. Major email providers including Gmail, Outlook, and Yahoo check reverse DNS for IPv6 senders. Messages from IPv6 addresses without valid PTR records are commonly rejected or flagged as spam.

What is the difference between in-addr.arpa and ip6.arpa?

in-addr.arpa is used for IPv4 reverse DNS, where the four octets of an IPv4 address are reversed. ip6.arpa is used for IPv6 reverse DNS, where the 32 hexadecimal digits are reversed individually. They serve the same purpose (mapping IPs to hostnames) but use different formats because IPv4 and IPv6 addresses have different structures.

Can I delegate reverse zones at non-nibble boundaries like /33?

In theory, yes, but it requires workarounds similar to IPv4 classless delegation (RFC 2317). In practice, nearly all IPv6 reverse zone delegations happen at nibble boundaries (/32, /48, /64) because these are the standard allocation sizes. RIRs and ISPs allocate IPv6 space at nibble-aligned boundaries specifically to avoid this complication.

Related Tools

• Reverse PTR Name Builder (IPv4) - Build in-addr.arpa PTR names from IPv4 addresses
• BIND Zone A/AAAA Generator - Generate BIND zone A and AAAA records from CSV
• Hostname Validator - Validate hostnames per RFC 1123 standards
• Zone File Linter - Check zone files for syntax errors and duplicates
• FQDN Validator - Validate fully qualified domain names