IPv4 to IPv6 Mapping Tool
Generate the IPv4-mapped IPv6 representation of any IPv4 address — the ::ffff: form used by dual-stack applications, socket APIs, web servers, reverse proxies, SIEMs, and logging libraries. This shows how an IPv4 address is represented inside IPv6; it does not assign IPv6 connectivity or create a native IPv6 address. Everything runs locally in your browser.
Advanced / legacy representations
These forms are not IPv4-mapped IPv6 addresses and are rarely used today — shown for reference only.
How the IPv4 to IPv6 Mapping Tool works
This tool builds the IPv4-mapped IPv6 representation of an IPv4 address entirely in your browser using JavaScript. Nothing is sent to a server — the mapping happens on your device, so it is fast, private, and works offline once the page has loaded. It shows how an IPv4 address is written inside IPv6; it does not assign IPv6 connectivity or produce a native IPv6 address.
Validation
Enter a single IPv4 address such as 192.168.1.1. The tool checks that it has four parts and
that every octet is a whole number from 0 to 255, and shows a clear, plain-language message if anything is
out of range — so you can fix the address as you type.
Mapped representations
Each valid address is shown as the IPv4-mapped ::ffff: address in both dotted and hexadecimal
notation, plus the fully expanded form for documentation and parsers that need a fixed length. Copy any
single result, or copy them all at once. Two rarely-used legacy forms (6to4 and IPv4-compatible) are tucked
into an optional Advanced panel.
The math
An IPv4 address is 32 bits — four 8-bit octets. To build the hexadecimal form, the first two octets become
one 16-bit hextet and the last two become another. So 192.168.1.1 (c0 a8 01 01)
becomes the hextets c0a8 and 0101, giving ::ffff:c0a8:0101.
Address type
The tool also classifies the address — private (RFC 1918), public, loopback, link-local, multicast, and other special-use ranges — so you can see at a glance what kind of address you are working with.
What is IPv6?
IPv6 (Internet Protocol version 6) is the current generation of the internet's addressing
system, designed to succeed IPv4. An IPv6 address is 128 bits long and written as eight
groups of four hexadecimal digits, such as 2001:0db8:0000:0000:0000:0000:0000:0001, which
compresses to 2001:db8::1. That 128-bit space provides roughly 340 undecillion addresses — enough
to give every device on Earth a globally unique address many times over.
What is an IPv4-mapped IPv6 address?
An IPv4-mapped IPv6 address packs a 32-bit IPv4 address into the low 32 bits of an IPv6 address, prefixed
with ::ffff:. It lets a dual-stack application use a single IPv6 socket while still seeing the
original IPv4 address of an IPv4 client — for example ::ffff:203.0.113.5.
Why IPv6 exists
IPv6 was standardised because IPv4's ~4.3 billion addresses could not keep up with the explosion of internet-connected devices. Beyond more addresses, IPv6 adds stateless auto-configuration, a simpler header for faster routing, and removes the dependence on network address translation (NAT).
Note: mapping an IPv4 address into ::ffff: notation is just a change of
representation. It does not assign IPv6 connectivity to anything or make an IPv4-only host reachable over the
IPv6 internet.
Why ::ffff: exists and where these addresses appear
The ::ffff: prefix exists so that software with a single IPv6 stack can also handle IPv4 peers
without maintaining two separate code paths. On a dual-stack host, an IPv6 socket can accept IPv4 connections,
and the operating system hands the application the client's IPv4 address in IPv4-mapped form —
for example ::ffff:203.0.113.5. That is why the same IPv4 address can suddenly show up wearing an
IPv6 prefix.
Where you'll see IPv4-mapped IPv6
- Dual-stack applications handling both IPv4 and IPv6 clients
- Socket APIs on an IPv6 listener accepting IPv4 connections
- Web servers such as Nginx and Apache recording
::ffff:client IPs - Reverse proxies and load balancers forwarding IPv4 clients
- SIEMs and log analysis ingesting mixed IPv4/IPv6 source fields
- Programming libraries that normalise addresses to IPv6 internally
Why developers and admins care
Recognising the ::ffff: prefix saves real debugging time. A firewall rule, allowlist, or log
query written only for dotted-decimal IPv4 can silently miss the same address in mapped form, and
access-control checks may behave differently for 203.0.113.5 versus
::ffff:203.0.113.5. Knowing the two are the same address — and being able to generate the
mapped form here — makes those rules and parsers easier to get right.
IPv4 exhaustion and why the transition matters
IPv4 provides about 4.3 billion addresses (2³²). That seemed limitless in the 1980s, but the regional internet registries began running out of free IPv4 blocks in the 2010s. The shortage is why IPv4 addresses are now bought and sold, why most home and office networks hide many devices behind a single public address using NAT, and why IPv6 — with its vastly larger address space — was created.
IPv4 vs IPv6 at a glance
- Address size: 32-bit (IPv4) vs 128-bit (IPv6)
- Notation: dotted decimal vs hexadecimal groups
- Pool: ~4.3 billion vs ~340 undecillion
- NAT: widely required vs generally unnecessary
- Auto-config: DHCP vs built-in SLAAC + DHCPv6
Private vs public IPv4
Private ranges — 10.0.0.0/8, 172.16.0.0/12, and
192.168.0.0/16 — are reserved for internal networks and are not routed on the public internet.
Public addresses are globally unique and reachable. This tool labels each address so
you can tell which kind you are working with; mapping a private address into ::ffff: form keeps
it private.
Dual-stack, NAT64, and common migration scenarios
Because IPv4 and IPv6 are not directly interoperable, networks rely on transition mechanisms to run both during the long migration. Understanding them helps you place IPv4-mapped addresses in context.
- Dual-stack: devices and services run IPv4 and IPv6 at the same time, choosing whichever the other end supports.
- NAT64 / DNS64: let IPv6-only clients reach IPv4-only servers by synthesising IPv6 addresses and translating packets at a gateway.
- 6to4 & tunnelling: older mechanisms that carry IPv6 traffic across IPv4 networks using prefixes such as
2002::/16.
- Logging & firewalls: dual-stack servers often record IPv4 visitors in
::ffff:form — handy to recognise when reading logs or writing rules. - Application sockets: a single IPv6 listening socket can accept IPv4 clients, which is exactly where IPv4-mapped addresses appear.
- Documentation: the expanded form is useful for ACLs and templates that expect a fixed-length address.
Important: mapping an IPv4 address into ::ffff: notation does not make
an IPv4-only service reachable over IPv6. Real reachability needs an actual IPv6 address on the server, AAAA
DNS records, IPv6 routing, or a translation layer such as NAT64 — not a notation change.
Privacy: processed locally in your browser
Every mapping this tool performs happens entirely in your browser. The IPv4 address you enter is handled exclusively by JavaScript in your browser tab — never transmitted to a server, never logged, and never stored anywhere outside your device.
Technical verification: open your browser's developer tools (F12), select the Network tab, and map an address. You will see zero outgoing requests — the tool works entirely through in-memory JavaScript.
Frequently asked questions
What is the IPv4 to IPv6 Mapping Tool?
It generates the IPv4-mapped IPv6 representation of a 32-bit IPv4 address such as
192.168.1.1. The result, written ::ffff:192.168.1.1 (or
::ffff:c0a8:0101 in hexadecimal), is the dual-stack form that socket APIs, web servers,
reverse proxies, SIEMs, and logging libraries use to represent an IPv4 peer inside an IPv6 address. The
tool does not generate a native IPv6 address or assign IPv6 connectivity — it only shows how an IPv4
address is represented inside IPv6.
What is an IPv4-mapped IPv6 address?
An IPv4-mapped IPv6 address embeds a 32-bit IPv4 address in the last part of a 128-bit IPv6 address,
prefixed by ::ffff:. For example, 192.168.1.1 becomes
::ffff:192.168.1.1, or equivalently ::ffff:c0a8:0101 in hexadecimal. Dual-stack
operating systems use this format so a program on an IPv6 socket can accept IPv4 connections and still see
the original IPv4 address. It is purely notation — it does not move traffic onto the IPv6 network.
Does this convert my network to IPv6?
No. The tool only rewrites a single IPv4 address into IPv6 notation. It does not change your network, enable IPv6 on any device, or make an IPv4-only service reachable over IPv6. Real IPv6 connectivity requires IPv6 addresses assigned to your interfaces, IPv6 routing and DNS (AAAA records), and a transition mechanism such as dual-stack or NAT64 on the path between client and server.
Why was IPv6 created?
IPv6 was created mainly because IPv4 only provides about 4.3 billion addresses, far too few for today's internet of phones, servers, IoT devices, and cloud workloads. The regional registries ran out of free IPv4 blocks years ago. IPv6 uses 128-bit addresses, offering roughly 340 undecillion addresses, and also improves auto-configuration, simplifies routing, and removes the need for widespread network address translation.
What does ::ffff: mean in an IPv6 address?
The ::ffff: prefix marks an IPv4-mapped IPv6 address. The :: is IPv6 shorthand
for a run of zero groups, and the ffff hextet that follows signals that the final 32 bits
should be read as an embedded IPv4 address. So ::ffff:192.168.1.1 is the full address
0000:0000:0000:0000:0000:ffff:c0a8:0101, which represents 192.168.1.1 inside the
IPv6 address space.
Can IPv6 replace IPv4?
Eventually, but not instantly. IPv6 and IPv4 are not directly interoperable, so the two protocols run side by side during a long transition. Most networks use dual-stack, where devices have both an IPv4 and an IPv6 address, or transition technologies such as NAT64 and DNS64 so IPv6-only clients can still reach IPv4-only services. IPv4 will remain in use for many years while IPv6 deployment continues to grow.
What is the difference between IPv4 and IPv6?
IPv4 uses 32-bit addresses written as four decimal octets, like 192.168.1.1, giving about 4.3
billion addresses. IPv6 uses 128-bit addresses written as eight groups of hexadecimal, like
2001:db8::1, giving an effectively unlimited supply. IPv6 also builds in stateless address
auto-configuration, simplifies header processing for routers, and was designed so that network address
translation is no longer required to conserve addresses.
Is my data uploaded when I use this tool?
No. The entire conversion runs in JavaScript inside your browser. The IPv4 address you type is never sent to a server, logged, or stored anywhere outside your own browser tab. You can confirm this by opening your browser's developer tools, switching to the Network tab, and mapping an address — you will see no outgoing requests, and the tool keeps working even with your network disconnected after the page loads.
Can private IPv4 addresses be converted?
Yes. Any valid IPv4 address can be expressed in IPv6 notation, including RFC 1918 private ranges such as
10.0.0.0/8, 172.16.0.0/12, and 192.168.0.0/16, plus loopback
(127.0.0.0/8) and link-local (169.254.0.0/16) addresses. The conversion is purely
a change of notation — a private address stays private, and mapping it to ::ffff: form does
not make it routable on the public internet.
Why do some systems show IPv4 addresses as IPv6?
On a dual-stack host, applications often open an IPv6 socket that also accepts IPv4 connections. When an
IPv4 client connects, the operating system reports its address in IPv4-mapped form, such as
::ffff:203.0.113.5, so logs, web servers, and firewalls may display IPv4 visitors with the
::ffff: prefix. It is the same IPv4 address, simply shown in IPv6 notation because the
listening socket is an IPv6 socket.