ForHosting KIT · Developer Utilities

IPv6 to binary converter

The IPv6 to binary converter reveals every bit behind an IPv6 address. Enter compressed notation such as 2001:db8::1, a fully expanded address, or a valid IPv4-embedded IPv6 address.

● BetaFree · in your browser
Use it from WebAPIEmailTelegramApp soon

The result expands all eight hextets and converts each one into exactly sixteen binary digits, preserving leading zeroes. You receive both a readable space-grouped representation and one continuous 128-bit value, making the output useful for networking lessons, prefix comparisons, subnet exercises, documentation, and exact programmatic checks without manual hexadecimal arithmetic.

How hexadecimal IPv6 becomes 128 binary bits

An IPv6 address contains 128 bits divided into eight hextets. Each hextet holds four hexadecimal digits, and every hexadecimal digit maps to exactly four binary digits. That makes one complete hextet sixteen bits wide and the eight-hextet address exactly 128 bits wide. The converter first expands the input to eight groups of four hexadecimal characters, then converts each group independently while retaining every leading zero. For example, the hextet 0001 becomes 0000000000000001, not simply 1. Keeping that fixed width is essential because the position of a bit carries meaning in an address. The binary_groups field provides eight separate sixteen-bit strings, while binary joins those groups with spaces for reading. The binary_128 field removes the separators for software or worksheets that require one continuous bit string. The expanded address and hextets fields let you trace each binary group back to its hexadecimal source, so the conversion remains easy to audit rather than appearing as an unexplained wall of digits.

Using the result to understand prefixes and masks

IPv6 prefixes select a number of bits starting from the left side of the 128-bit address. A /32 prefix selects the first two binary hextets, a /48 selects the first three, and a /64 selects the first four. Prefix lengths that are not multiples of sixteen stop inside a hextet, which is where a full binary view becomes especially helpful. With a /52, for instance, the network portion contains three complete hextets plus the first four bits of the fourth hextet. You can place two converter outputs side by side, count from the left, and see exactly where their network bits agree or differ. The tool performs conversion only; it does not apply a CIDR mask or claim that two addresses share a network. This deliberate separation makes it suitable for teaching because learners can mark the boundary themselves. For production membership checks, use a dedicated prefix checker after understanding the representation. Always count the continuous binary_128 value when precision matters, since spaces in the readable binary field are visual hextet separators and do not consume bits.

Accepted notation, normalization, and input errors

You may enter standard compressed IPv6 notation, fully expanded notation, or an IPv6 address with an embedded dotted-decimal IPv4 ending. A double colon may replace one run of one or more zero hextets, and leading zeroes may be omitted within individual hextets. The converter normalizes all accepted forms into lowercase, eight-hextet expanded notation before producing binary. Strict validation prevents a plausible-looking but incorrect result. Multiple double-colon markers, too many or too few groups, hexadecimal groups longer than four characters, non-hexadecimal characters, and invalid IPv4 octets are rejected. A bare IPv4 address is not silently treated as IPv6. CIDR suffixes such as /64 are also rejected because this capability converts an address rather than a network expression. Zone identifiers such as %eth0 are excluded because they describe local interface scope and are not part of the 128 address bits. When an error occurs, correct the address syntax and submit it again; the converter never guesses missing structure beyond the compression rules defined for IPv6.

Teach IPv6 prefix boundaries

Show students precisely which high-order bits a /48, /56, /64, or non-hextet-aligned mask selects.

Compare network bits

Place two complete bit strings side by side to locate their first difference and reason about their shared prefix.

Prepare technical documentation

Add an auditable expanded and binary representation to subnet plans, lab notes, or troubleshooting records.

How much does one conversion cost?

Each API request costs $0.002. The same deterministic conversion is also available free in the browser.

Does the output always contain 128 bits?

Yes. Every hextet is padded to sixteen bits, and binary_128 always contains exactly 128 binary digits.

Can I enter a compressed IPv6 address?

Yes. Standard double-colon compression and omitted leading zeroes are expanded before conversion.

Why are there spaces in the binary result?

Spaces separate the eight sixteen-bit hextets for readability. Use binary_128 when you need an uninterrupted value.

Does the converter accept an address with /64?

No. Enter only the IPv6 address; a CIDR suffix describes a prefix and is outside this conversion input.

Everything on this page is available programmatically. This section is for teams who want to wire it into their own systems; everyone else can just use the tool above.

POSThttps://api.kit.forhosting.com/dev/ipv6-to-binary

Prefer to automate it? One authenticated POST creates the task; the result comes back by webhook or a signed link. The same capability also runs here on the web, by email and from Telegram — and soon from our app too.

curl -X POST https://api.kit.forhosting.com/dev/ipv6-to-binary \
  -H "Authorization: Bearer $KIT_KEY" \
  -H "Content-Type: application/json" \
  -d '{"address":"2001:db8::1"}'
{
  "address": "2001:db8::1"
}
{
  "task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
  "type": "dev.ipv6_to_binary",
  "status": "queued",
  "_links": {
    "result": "/tasks/tsk_…/result"
  }
}

The API is asynchronous: the call returns a task_id immediately and the result arrives by webhook. Polling is capped at 1 req/s per task.

Per request$0.002

Published price — no tokens, no invented credits. A failed task is never charged.

HTTPCodeMeaning
401unauthorizedMissing or invalid API key.
402insufficient_balanceYour balance doesn't cover the task price.
404unknown_typeThat task type doesn't exist.
429rate_limitedToo many requests. Use the webhook instead of polling.

Read the full KIT documentation →