10.0.2.0 Explained: The Private IP Address Hiding Inside Android Emulators and QEMU
One familiar-looking IP address can be a network identifier, a virtual subnet boundary, and a clue that your software is running inside an emulated environment.
When 10.0.2.0 appears in a terminal, emulator log, virtual-machine configuration or networking guide, it is easy to assume you have found the IP address of a particular device. Usually, you have not.
The number sits inside the private IPv4 range reserved for internal networks, but its most recognisable modern use is more specific: Android Emulator and QEMU user-mode networking use 10.0.2.0/24 as a virtual network by default. Android’s current documentation assigns special functions to several addresses inside that subnet, including 10.0.2.1, 10.0.2.2, 10.0.2.3, 10.0.2.15, and, in newer emulator Wi-Fi configurations, 10.0.2.16 and subsequent addresses.
BLUF: What 10.0.2.0 actually is
10.0.2.0 is normally the network address for the private IPv4 subnet 10.0.2.0/24, not an ordinary device address. In Android Emulator and QEMU user-mode networking, that /24 virtual subnet forms a small NAT-based network containing a virtual router, host alias, DNS services and emulator addresses. It is private and not globally routable on the public internet.
The four numbers tell you less than the /24
The easiest mistake is to read 10.0.2.0 as four independent values and assume the final .0 belongs to a machine.
Its meaning depends on the subnet mask.
With a /24 prefix, the mask is:
| Item | Value |
|---|---|
| Network | 10.0.2.0/24 |
| Subnet mask | 255.255.255.0 |
| Network portion | First 24 bits |
| Host portion | Final 8 bits |
| Total addresses | 256 |
| Typical host range | 10.0.2.1–10.0.2.254 |
| Broadcast address | 10.0.2.255 |
The final octet contains the host portion in a /24 subnet. That makes .0 the all-zero host portion and therefore the network identifier, while .255 is the all-ones broadcast address under conventional IPv4 subnetting. Microsoft explains the same network-mask principle: a subnet mask separates the network portion from the host portion of an IPv4 address.
So:
10.0.2.0 = the network
while:
10.0.2.15 = an address within that network
That distinction becomes especially important in virtualization, where software may use the network itself as a label inside its configuration.
Why 10.0.2.0 is private rather than an internet destination
The entire 10.0.0.0/8 block is reserved for private-use networks under RFC 1918. IANA currently lists 10.0.0.0/8 as Private-Use and marks it as not globally reachable. The same private-use framework covers 172.16.0.0/12 and 192.168.0.0/16.
That means 10.0.2.0 belongs to a huge pool of addresses that can be reused independently by homes, companies, laboratories, virtual machines and software environments.
There is no globally unique machine called 10.0.2.0 on the internet.
A company in London and another in Karachi can both build an internal /24 network using 10.0.2.0/24 without causing an internet-wide addressing conflict, because private addresses are intended for local use and are generally translated or otherwise kept inside private environments before traffic reaches the public internet. IANA explicitly notes that private-use blocks can be used by many separate networks.
A private IP does not tell you who owns it
An IP beginning with 10. cannot by itself identify:
- a person;
- a company;
- a specific city;
- an internet service provider;
- a particular computer;
- or a public-facing server.
The same private address can exist simultaneously in countless isolated networks.
That is why attempting a conventional public-IP geolocation lookup on 10.0.2.0 is fundamentally different from looking up a globally routed address.
The Android Emulator connection is where 10.0.2.0 becomes especially interesting
Android developers encounter this range frequently because Android Emulator networking is built around a virtual router.
Google’s current Android documentation states that each emulator instance manages the 10.0.2/24 network address space. Several addresses are pre-allocated for predictable functions.
Android Emulator address map
| Address | Android Emulator role |
|---|---|
10.0.2.0 | Network address for the virtual /24 |
10.0.2.1 | Virtual router / gateway |
10.0.2.2 | Alias to the development machine’s 127.0.0.1 |
10.0.2.3 | First DNS server |
10.0.2.4–10.0.2.6 | Additional DNS servers when used |
10.0.2.15 | Emulated device address over ethernet |
10.0.2.16 | Emulated device address over Wi-Fi in newer emulator behaviour |
127.0.0.1 | Loopback inside the emulated device |
Google says the newer Android Emulator behaviour introduced after version 36.5 can assign Wi-Fi-connected emulated devices starting at 10.0.2.16, 10.0.2.17 and onward.
This gives 10.0.2.0 a very specific role: it represents the virtual network containing those special addresses rather than being the address of the Android device itself.
Why developers use 10.0.2.2 instead of localhost
This is one of the most useful facts hidden inside the 10.0.2.x system.
Suppose a web server is running on your development computer at:
127.0.0.1:3000
From the host operating system, 127.0.0.1 means the host itself.
From inside an Android Emulator, however, 127.0.0.1 refers to the emulated Android device itself.
That creates an immediate problem.
The app may be looking for a service on port 3000, but the service is actually running on your development machine.
Android solves that with the special alias:
10.0.2.2
Google documents 10.0.2.2 as the emulator’s special alias for the host’s loopback interface. In other words, the emulator can use:
http://10.0.2.2:3000
to reach a development server bound to the host’s loopback interface, subject to the host service and firewall configuration.
That is why developers often encounter 10.0.2.2 in API testing instructions even when they have never intentionally configured a 10.0.2.x network.
The QEMU connection explains where the convention came from
Android Emulator networking is closely tied to QEMU’s virtualisation model.
QEMU’s documentation describes user-mode networking as a host-side network backend that requires no administrator privileges, with the default guest-visible network set to 10.0.2.0/24. The guest-visible host address defaults to the second address in the network, which means 10.0.2.2.
The default layout therefore follows a recognisable structure:
10.0.2.0/24
│
├── 10.0.2.1 Virtual router
├── 10.0.2.2 Host-side loopback alias
├── 10.0.2.3 Virtual DNS
├── 10.0.2.4+
│
├── 10.0.2.15 Guest address in traditional configuration
│
└── 10.0.2.255 BroadcastThe important point is that the 10.0.2.x range is functioning as a software-defined network.
It does not have to correspond to a physical Ethernet segment in your office or home.
What happens when an emulator accesses the internet
The Android Emulator does not simply become another machine on your physical LAN.
Google describes each emulator instance as sitting behind a virtual router or firewall service. Outbound traffic is handled through that virtual networking layer, while the host computer provides the underlying internet connection.
Conceptually, the flow looks like this:
Android App
│
▼
Emulated Android Device
10.0.2.x
│
▼
Virtual Router
10.0.2.1
│
▼
Host Networking / NAT
│
▼
Development Computer
│
▼
InternetThe private address is therefore not exposed as a globally routable destination.
QEMU documentation similarly explains that user-mode networking places the virtual machine behind a firewall-like layer and uses DHCP to allocate addresses beginning in the 10.0.2.x range.
Why two Android emulators can both appear as 10.0.2.15
This is where ordinary home-network intuition can become misleading.
A real LAN normally has one subnet with unique host addresses. Two devices cannot both legitimately use the same address on that same Layer 2 network.
Android Emulator instances using isolated virtual routers are different.
Google explains that multiple emulator instances can each sit behind their own virtual router, meaning each instance may use the same guest-side address, including 10.0.2.15, without directly colliding. The isolation happens because the instances are not actually sharing the same underlying virtual LAN.
A simplified model is:
Emulator A
10.0.2.15
│
Virtual Router A
│
Host
│
Virtual Router B
│
Emulator B
10.0.2.15Two 10.0.2.15 addresses can therefore coexist because they exist in different network contexts.
This is a critical distinction between an address and an address-plus-routing environment.
The three addresses most developers should remember
If your interest in 10.0.2.0 comes from Android development, three addresses solve much of the confusion.
10.0.2.0
This identifies the virtual /24 network itself.
It is not normally assigned to an individual host.
10.0.2.1
This is the virtual router or gateway address documented by Android Emulator networking.
10.0.2.2
This is the practical developer shortcut for reaching the host machine’s loopback service from the emulator.
The difference can be summarised simply:
| Address | Think of it as |
|---|---|
10.0.2.0 | The virtual street |
10.0.2.1 | The virtual gateway |
10.0.2.2 | A doorway to the host |
10.0.2.15 | Traditional guest/emulator address |
What 10.0.2.0 is not
Several common interpretations are technically wrong.
10.0.2.0 is not a public internet IP address. It belongs to the RFC 1918 private-use range.
10.0.2.0 is not automatically your computer’s IP address. The address is commonly a network identifier, while the host-facing alias in Android Emulator is 10.0.2.2.
10.0.2.0 does not identify one device worldwide. Private networks can reuse RFC 1918 addresses independently.
10.0.2.0 is not synonymous with 127.0.0.1. Loopback and private-use addressing serve different purposes. IANA lists 127.0.0.0/8 separately as loopback.
10.0.2.0 is not the Android emulator’s individual device address simply because it appears in emulator documentation. The emulator operates inside the subnet; individual addresses are assigned within it.
Could a normal physical network use 10.0.2.0/24?
Yes.
There is nothing inherently exclusive about 10.0.2.0/24 being used by Android Emulator or QEMU.
Because 10.0.2.0 belongs to 10.0.0.0/8, a private network administrator could assign a 10.0.2.0/24 subnet to internal systems. RFC 1918 specifically permits private organisations to use these address blocks without coordinating those private assignments with a global registry.
The distinction is that Android Emulator gives this particular private subnet a documented, pre-defined meaning inside its own virtual networking system.
That is why seeing 10.0.2.0/24 in Android tooling is often a strong clue that you are looking at emulation or QEMU-style user networking rather than an arbitrary office subnet.
The subnet mathematics behind 10.0.2.0/24
For readers learning IPv4, the address is also a useful subnetting example.
A /24 leaves eight bits for host addressing:
2^8 = 256
That produces 256 total addresses in the block.
Under conventional IPv4 subnetting:
256 - 2 = 254
So the traditional usable host range is:
10.0.2.1 through 10.0.2.254
with:
Network = 10.0.2.0
and:
Broadcast = 10.0.2.255
Cisco documents the underlying rule that an all-zero host portion represents the network address and the all-one host portion represents the broadcast address in conventional IPv4 subnetting.
There is an additional nuance: specialised networking systems can reserve, repurpose or assign addresses differently. Android Emulator is a perfect example because it deliberately assigns specific addresses for virtual infrastructure. So the theoretical host range should not be confused with a promise that every address is freely available in every implementation.
A practical troubleshooting checklist for developers
When 10.0.2.0 appears during debugging, the first question is not “Who owns this IP?”
The better questions are:
- Is this an Android Emulator or QEMU environment?
- What subnet mask is being used?
- Is the address a network identifier or a host address?
- Are you trying to reach the host from the guest?
- Is the service bound to
127.0.0.1, a LAN address, or all interfaces? - Could the host firewall be blocking the connection?
- Are multiple virtual machines isolated behind separate NAT instances?
For Android, using 10.0.2.2 for a host-local development server is frequently the critical configuration detail.
For QEMU, user-mode networking may also require explicit forwarding when you need inbound access from the host to a service running inside the guest. QEMU documents hostfwd and related forwarding options for this purpose.
Why 10.0.2.0 keeps appearing in search results and technical forums
The address has an unusually strong association with virtualised development environments.
A Google developer working on an API request can encounter:
10.0.2.2
A QEMU user reading network documentation can see:
10.0.2.0/24
An Android debugging session may reveal:
10.0.2.15
A network engineer studying the address range may instead recognise:
10.0.0.0/8
All four observations can be correct at the same time.
That is the real source of confusion: the same private address block has both generic IPv4 meaning and specialised software meaning.
A useful comparison: 10.0.2.0 versus other private ranges
| Network | Private-use status | Common examples |
|---|---|---|
10.0.0.0/8 | RFC 1918 private | Enterprise networks, VPNs, virtual networks, emulators |
172.16.0.0/12 | RFC 1918 private | Corporate and infrastructure networks |
192.168.0.0/16 | RFC 1918 private | Home routers, small offices |
10.0.2.0/24 | Subnet inside 10.0.0.0/8 | Android Emulator, QEMU user networking |
IANA confirms all three major RFC 1918 blocks remain private-use address space and are not globally reachable in the public routing sense.
The difference is therefore not that 10.0.2.0 belongs to a special public category.
It is that certain software platforms have given 10.0.2.0/24 a predictable internal topology.
The Android Emulator changed some details in newer versions
One detail worth checking in current documentation is emulator Wi-Fi behaviour.
Google’s current Android documentation notes that after Android Emulator version 36.5, multiple emulated devices connected using Wi-Fi can receive addresses beginning with 10.0.2.16, 10.0.2.17 and subsequent addresses. Earlier emulator versions used a more isolated model in which each instance could have its own virtual router and its own 10.0.2.15 guest address.
That means older tutorials may describe 10.0.2.x behaviour that does not exactly match a current emulator configuration.
When troubleshooting, the emulator version matters.
People Also Ask About 10.0.2.0
What is 10.0.2.0 used for?
10.0.2.0 is commonly used as the network address of the 10.0.2.0/24 private subnet. Its best-known software use is Android Emulator and QEMU user-mode networking, where the subnet contains predefined virtual gateway, DNS, host-alias and guest addresses. It is not normally the individual IP assigned to a device.
Is 10.0.2.0 a private IP address?
10.0.2.0 is part of the private 10.0.0.0/8 IPv4 address block. RFC 1918 reserves the entire 10.0.0.0 through 10.255.255.255 range for private internets, and IANA lists it as Private-Use rather than globally reachable address space.
Is 10.0.2.0 the same as 10.0.2.2?
10.0.2.0 and 10.0.2.2 have different roles in a /24 network. 10.0.2.0 identifies the subnet itself, while Android Emulator documents 10.0.2.2 as a special alias that lets the emulated device reach the development machine’s loopback interface.
What is 10.0.2.2 on Android Emulator?
10.0.2.2 is the Android Emulator’s special host-loopback alias. It corresponds to 127.0.0.1 on the development computer from the emulator’s perspective. Developers commonly use it when an API, web server or test service is running locally on the host computer.
What is 10.0.2.15?
10.0.2.15 is a traditional Android Emulator guest address within the virtual 10.0.2.0/24 network. Google’s documentation lists it for the emulated device when connected using ethernet, while newer Wi-Fi configurations can use addresses beginning at 10.0.2.16.
Can 10.0.2.0 be accessed from the public internet?
10.0.2.0 is not a globally routable public destination. It is part of the RFC 1918 private-use range, which exists for internal networks and can be reused across separate private environments. Public-facing services normally require a globally routable address or another mechanism such as NAT, proxying or port forwarding.
When one IP address is really a map of a virtual network
The most useful way to think about 10.0.2.0 is not as a mysterious computer address.
It is a network boundary.
In generic IPv4 terms, 10.0.2.0/24 describes a private subnet. In Android Emulator and QEMU, that same subnet becomes a controlled virtual environment with predictable infrastructure:
10.0.2.1 for the virtual gateway,
10.0.2.2 for the host-loopback alias,
10.0.2.3 and related addresses for DNS,
and guest addresses such as 10.0.2.15 or newer Wi-Fi allocations starting from 10.0.2.16.
Once that structure is understood, the number stops looking like an unexplained IP and starts looking like what it really is: the label for a private virtual subnet whose individual addresses perform different jobs.
Editorial Disclaimer
Networking implementations can vary between Android Emulator releases, QEMU versions, host operating systems and custom virtual-network configurations. This article describes the documented default and commonly encountered behaviour of 10.0.2.0/24; a specific device or virtual machine may use a different network, address, routing rule or forwarding configuration.
