{{ valid ? 'Valid' : 'Invalid' }} {{ addressType }} /{{ prefixLength }} Zone {{ zoneId }}
  • {{ w }}
Compressed (display):
Expanded (display):
Field Value Copy
{{ row.label }} {{ row.value }}
Group Hex Decimal Copy
{{ i + 1 }} {{ caseHex(g) }} {{ parseInt(g, 16) }} 

        


      


    

  

                

                

                    

                        

                            Categories:
                                                            
                                    Converter
                                
                                ,                                                             
                                    IP Tools
                                
                                ,                                                             
                                    Networking
                                
                                ,                                                             
                                    Validator
                                
                                                                                    

                        

                            Export to PDF
                            Fullscreen
                        

                    

                

            

        

    


    
    

        

        

            


                

                    

                    
                


                

                

                
            

        

    


    

        

        

            

                
                
                
                
            


            
        

    



    

        

  
  
Internet Protocol version 6 addresses are 128 bit identifiers for devices and destinations on modern networks. This Internet Protocol version 6 address compressor and expander reports whether one address is well formed and shows its compact and full forms. Results appear immediately so you can share a single clear representation.

  
You can paste an address with a prefix such as 64, a zone tag after a percent sign, or an embedded address written as four dotted numbers. The formatter recognizes special ranges and returns the type, the reverse name for lookups, and a binary view for quick checks.

  
An example result shows the compact form with a dotted tail, the full eight group form, and a label that explains when a value is mapped from the older protocol.

  
Pattern checks confirm structure only and do not prove that a host is reachable or that any network prefix is correct. Avoid sharing live addresses in public notes.






  
Technical Details:

  
An IPv6 address is a 128‑bit value written as eight hexadecimal groups. The parser reads one address as a snapshot, normalizes it to a canonical shape, and prepares comparable displays.

  
The computation expands to eight four‑digit groups, compresses the longest run of zero groups, and optionally renders the final 32 bits as dotted decimal. A range check then assigns a human‑readable type label.

  
Results include a compact form, a fully expanded form, the address type, a reverse name for delegation checks, binary bits, and a fixed split into network and interface halves at 64‑bit boundaries.

  
Comparability relies on lowercase for the canonical expanded form and a case selector for displays. The 64‑bit split is a convenience and does not reflect any detected prefix length.


  
Processing pipeline

  
    
    
  1. Trim whitespace from the input string.
    2. 
    
  2. If a slash suffix exists, parse a prefix length 0–128; warn when out‑of‑range or malformed.
    3. 
    
  3. If a percent sign exists, capture the zone identifier; warn if empty.
    4. 
    
  4. If dotted numbers follow the final colon, parse four bytes 0–255 and fold them into the last two groups.
    5. 
    
  5. Expand groups: allow at most one double colon, validate each hextet as one to four hex digits, and fill to eight groups.
    6. 
    
  6. Classify the normalized groups by well‑known ranges; otherwise mark as Global.
    7. 
    
  7. Derive displays: compressed form with longest zero run, optional dotted tail, and case selection for shown text.
    8. 
    
  8. Compute the reverse pointer by reversing hexadecimal nibbles and appending ip6.arpa.
    9. 
  


  

    

      
      
        

          Type
          Condition
        

      
      
        
UnspecifiedAll eight groups are 0000.

        
LoopbackFirst seven groups are 0000 and the last group is 0001.

        
MulticastFirst group is 0xff00 to 0xffff.

        
Link‑localFirst group is 0xfe80 to 0xfebf.

        
Unique‑localFirst group is 0xfc00 to 0xfdff.

        
6to4First group equals 0x2002.

        
TeredoFirst group equals 0x2001 and second equals 0x0000.

        
DocumentationFirst group equals 0x2001 and second equals 0x0db8.

        
IPv4‑mappedFirst six groups are 0000 and the seventh is ffff.

        
GlobalAnything not matched above.

      
    

  


  

    
Worked example

    
Input: ::ffff:192.0.2.1/64

    

      
Expanded: 0000:0000:0000:0000:0000:ffff:c000:0201

      
Compressed (default): ::ffff:c000:201

      
Compressed with dotted tail: ::ffff:192.0.2.1

      
Type: IPv4‑mapped

      
Reverse name: 1.0.2.0.0.0.0.c.f.f.f.f.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.ip6.arpa

    

  


  
Validation & bounds from the code

  

    

      
      
        

          Field
          Type
          Min
          Max
          Step/Pattern
          Error/Warning
        

      
      
        

          IPv6 address
          text
          —
          —
          ^[0-9a-fA-F]{1,4}$ per group; one :: at most; eight groups total without ::.
          Invalid when group count or hex digits fail.
        

        

          Prefix length
          integer
          0
          128
          Parsed from /n at end.
          “Prefix out of range” or “Ignored invalid prefix”.
        

        

          Zone ID
          string
          —
          —
          Captured after %.
          “Empty zone id marker”.
        

        

          IPv4 dotted tail
          quad
          0
          255
          ^(\d{1,3})\.(\d{1,3})\.(\d{1,3})\.(\d{1,3})$; must follow the last colon.
          Invalid when any byte is out of range.
        

        

          Hex case
          enum
          —
          —
          lower or upper for displays.
          None.
        

        

          Binary group bits
          enum
          1
          16
          Allowed: 1, 4, 8, 16.
          None.
        

      
    

  


  
I/O formats

  

    

      
      
        

          Input
          Accepted families
          Output
          Encoding/Precision
          Rounding
        

      
      
        

          Address string
          IPv6 with optional /n and optional %zone; optional dotted tail after the last colon.
          Compressed and expanded strings; type; reverse name; binary bits.
          Hexadecimal groups; dotted decimal for tail; 128 bits.
          None.
        

        

          Exports
          Info CSV; analysis JSON.
          Files named ipv6_info.csv and ipv6_analysis.json.
          UTF‑8 text.
          None.
        

      
    

  


  
Privacy & compliance

  
Processing is browser‑based; no requests are sent to external services. Copies use the local clipboard, and downloads are generated on the device. No data is transmitted or stored server‑side.






  
Step‑by‑Step Guide:

  
Internet Protocol version 6 address validation and formatting, from one pasted value to clear outputs.

  
    
    
  1. Paste or type one address into the field.
    2. 
    
  2. Optionally append /n for a prefix length.
    3. 
    
  3. Optionally append %zone for a link‑local scope.
    4. 
    
  4. If applicable, use four dotted numbers after the final colon for an embedded tail.
    5. 
    
  5. Open Advanced to choose hex case and a binary grouping size.
    6. 
    
  6. Use the tabs to view groups, binary, and JSON, then copy or download as needed.
    7. 
  

  
Example: fe80::1234%eth0/64 → type “Link‑local,” network half “fe80:0000:0000:0000,” interface half “1234:0000:0000:0000.”

  
    
    
  • Use consistent casing when comparing displays.
    • 
    
  • Prefer a binary group of 16 for easy hextet alignment.
    • 
    
  • Keep one address per run to avoid mix‑ups.
    • 
  

  
Pro tip: copy the reverse name into a lookup tool to check delegation.






  
FAQ:

  

    Is my data stored?
    
No network calls are made. Parsing, validation, copying, and downloads all happen on your device. Nothing is uploaded or retained by a server.

  

  

    Which address types are detected?
    
Unspecified, Loopback, Multicast, Link‑local, Unique‑local, 6to4, Teredo, Documentation, IPv4‑mapped, or Global when none of the specific patterns match.

  

  

    What input formats are accepted?
    
One address at a time. You may add a /n suffix for prefix length, a %zone suffix, and an embedded dotted‑quad after the last colon.

  

  

    Can I work offline?
    
Yes. Everything runs locally; copy and download features continue to work without connectivity.

  

  

    How are compact and full forms chosen?
    
Expansion creates eight four‑digit groups. Compression picks the longest zero run and removes leading zeros. In ties, the first longest run is used.

  

  

    How do I check a reverse name?
    
Copy the generated ip6.arpa pointer and query it with your preferred resolver or diagnostic tool.

  

  

    What does “Global” mean here?
    
It means the value does not match any special range tested by the classifier and is treated as globally scoped.

  

  

    Is there a cost or license?
    
No pricing or licensing behavior is encoded in the package. Refer to the site hosting this tool for terms.

  






  
Troubleshooting:

  
    
    
  • Input contains more than one double colon; use at most one.
    • 
    
  • A group has more than four hex digits; shorten it to four or fewer.
    • 
    
  • Dotted tail has a byte above 255; correct each dotted number to 0–255.
    • 
    
  • Prefix length is outside 0–128; remove it or use a valid value.
    • 
    
  • Zone identifier is blank after the percent sign; remove the percent or provide a name.
    • 
    
  • Binary grouping looks odd; choose 16 to align with hextets.
    • 
    
  • Copy buttons do nothing; allow clipboard access for the page.
    • 
    
  • Downloads do not appear; check pop‑up or download blockers.
    • 
    
  • Type shows Global unexpectedly; verify that the address is not in a special range.
    • 
    
  • Reverse name looks wrong; confirm you copied the entire string including ip6.arpa.
    • 
  

  





  
Advanced Tips:

  
    
    
  •  Use lowercase for canonical comparisons and uppercase only for display preferences.
    • 
    
  •  When comparing networks, use the expanded form to avoid ambiguity from compression.
    • 
    
  •  Keep the dotted tail off unless you need parity with mixed protocol tooling.
    • 
    
  •  Copy the CSV to capture both the network and interface halves for audits.
    • 
    
  •  Group binary in 8 or 16 bits to align with bytes or hextets.
    • 
    
  •  For readability, compress only the single longest run of zeros as the tool does.
    • 
  






  
Glossary:

  

    
Hextet

    
One of eight 16‑bit groups written in hexadecimal.

    
Prefix length

    
Number of leading bits that identify the network.

    
Zone ID

    
Local interface or scope tag after a percent sign.

    
IPv4‑mapped

    
An IPv6 form that embeds a dotted‑quad from the older protocol.

    
Reverse name

    
Nibble‑reversed form ending with ip6.arpa.

    
Link‑local

    
Range used on a single link and not routed.