Does the output use :: compression like a normal IPv6 address?

No — this tool always writes out all 8 hex groups in full (no RFC 5952 "::" zero-run compression is applied). The address is still fully valid and equivalent, just less abbreviated than the conventional shortest form.

Why not apply :: compression automatically?

Compression rules (only the longest zero run, only once, skipped if it's a single group) add real complexity for a marginal readability gain here; keeping every group explicit also makes it easier to see exactly which 16 bits produced each group.

What format does binary input need to be in?

Either one continuous 128-character string of 0s and 1s, or the same digits split into 8 space-separated 16-bit groups — spaces and underscores are stripped automatically before parsing.

Are leading zeros shown in each output group?

No — each 16-bit group is converted with `.toString(16)`, which naturally drops leading zeros (e.g. a group of all zeros becomes "0", not "0000"), matching how IPv6 groups are conventionally written.

Binary to IPv6 Address Converter - 128-bit Binary to IPv6

Overview

Introduction

128 raw bits are hard to read at a glance, but grouped into 8 hextets they become a standard IPv6 address again.

This tool reverses the IPv6-to-binary process, turning a full 128-bit sequence back into readable colon-hex notation.

What Is Binary to IPv6 Address Converter?

A converter that reconstructs an IPv6 address from exactly 128 bits, split into 8 groups of 16 bits each.

It's the inverse of the IPv6 Address to Binary Converter, though the output here is always the full, uncompressed 8-group form rather than a "::"-shortened one.

How Binary to IPv6 Address Converter Works

Input is stripped of spaces/underscores, validated as exactly 128 binary digits, then sliced into 8 consecutive 16-bit chunks.

Each chunk is parsed as a base-2 integer and formatted with `.toString(16)` into a hex group; the 8 groups are joined with colons to form the final address.

When To Use Binary to IPv6 Address Converter

Use it to check a manual binary-to-IPv6 conversion exercise during networking study.

It's also useful for recovering a readable address from 128 bits captured in a packet trace, spec example, or homework problem.

Often used alongside IPv6 Address to Binary Converter and Binary to IP Address Converter.

Features

Advantages

Accepts both continuous and pre-grouped binary input.
Reports the exact bit count on invalid input rather than silently padding or truncating.
Produces a genuinely valid IPv6 address, just without optional "::" abbreviation.

Limitations

Does not apply RFC 5952 "::" zero-run compression, so the output is always the longer, fully-expanded 8-group form rather than the conventional shortest representation.
Only handles pure 128-bit IPv6 addresses; it doesn't reconstruct embedded IPv4-in-IPv6 notation.

Examples

128 bits for an address that used :: compression

Input

0010000000000001 0000110110111000 0000000000000000 0000000000000000 0000000000000000 0000000000000000 0000000000000000 0000000000000001

Output

2001:db8:0:0:0:0:0:1

These are the same bits 2001:db8::1 expands to; converting back produces the full 8-group form rather than re-compressing the zero run with "::".

128 bits for the loopback address

Input

0000000000000000 0000000000000000 0000000000000000 0000000000000000 0000000000000000 0000000000000000 0000000000000000 0000000000000001

Output

0:0:0:0:0:0:0:1

Seven all-zero groups followed by a group of binary value 1 reconstruct as "0:0:0:0:0:0:0:1", the uncompressed equivalent of "::1".

Best Practices & Notes

Best Practices

If you need the conventional shortest form, manually compress the longest run of consecutive "0" groups into "::" after conversion.
Cross-check against the IPv6 Address to Binary Converter to confirm a clean round trip.

Developer Notes

Uses the shared `isValidBinaryString`/`stripBinaryFormatting` helpers for input validation, then plain `parseInt(chunk, 2).toString(16)` per 16-bit group — no BigInt is needed since each group's value fits well within `Number`'s exact integer range.

Binary to IPv6 Address Converter Use Cases

Verifying manual binary-to-IPv6 conversion exercises for networking study
Recovering a readable IPv6 address from raw bits found in a protocol trace or spec example
Teaching how IPv6's 128-bit address space maps onto 8 hex groups

Common Mistakes

Expecting an automatically "::"-compressed output — this tool always shows the full 8-group form.
Entering a bit count that isn't exactly 128, which can't represent a single IPv6 address.

Tips

Try all 128 zero bits to see the unspecified address "0:0:0:0:0:0:0:0" (conventionally written as ::).
Pair this with the IPv6 Address to Binary Converter to explore how different addresses map to different bit patterns.

Binary to IPv6 Address Converter