← back to blog

Emulator Detection: The Sensors Battery And Build Props That Give It Away

The stock Android emulator that ships with Google’s developer tools gives its virtual phone the number 15555215554 by default. For years, a quick way for an app to know it was running in an emulator was to read the phone number and compare it with that string. Modern detection is far more thorough than one number, but the principle hasn’t changed. An emulator is software pretending to be a phone, and the pretence leaks at every point where a real phone has real hardware: the motion sensors, the battery, the radio, the graphics chip, and the long list of system properties written by whoever built the operating system image. This piece walks through those tells one by one, explains why hiding them is harder than it looks, and draws the line between emulators, rooted phones and real devices hosted somewhere else, without pretending any of them is a guarantee.

What an emulator actually is

An Android emulator runs the Android operating system on hardware that isn’t a phone. Usually that’s a desktop or a server, often with an Intel or AMD processor, running a virtual machine that presents Android with virtual versions of the parts a phone would have.

There are a few families. The official emulator from Google’s development tools is built for app developers to test their software. Consumer emulators designed for playing mobile games on a PC are built on similar ideas with their own tweaks. Some cloud phone products run Android in containers or virtual machines on ARM servers, which avoids the processor mismatch but still has no physical phone parts underneath.

In every case, the operating system believes it has a screen, a touch panel, sensors, a battery, a SIM and a radio. Some of those are simulated. Some are passed through from the host. Some are missing entirely, and Android is told they don’t exist.

That’s the root of every tell in this piece. A real phone’s sensors and battery are physical components with physical noise, drift and wear. An emulator’s are either absent, constant, or generated by software whose output rarely looks like physics.

None of this makes emulators bad tools. They’re excellent for developing and testing apps, which is what the official one exists for. They’re just very poor at being mistaken for a phone by an app that’s checking.

Why apps check at all

Most apps don’t care whether they run on an emulator. The ones that do tend to fall into a few groups.

Banking and payment apps check because emulators are a common tool for fraud and for attacking the app itself. Games check because emulators are used for cheating and running many accounts. Social and messaging apps check because emulators are an efficient way to run fake accounts at scale. Some streaming apps check to enforce content protection.

The check rarely stands alone. An app might collect a set of device signals, send them to its own servers or a fraud vendor, and combine them with the account’s history and network. It might also call Google’s Play Integrity service, which returns a verdict about whether the device looks like genuine, certified hardware.

What happens next varies. Some apps refuse to run. Some let you in but restrict features like payments. Some quietly mark the account and treat everything it does with more suspicion. Few apps tell you which of these happened.

For anyone running accounts on phones, the point is that emulator detection is a mature field. There are open source libraries that do it, commercial SDKs that do it better, and platform level attestation that does it at the hardware level. An emulator that passes one simple check can still fail the next ten.

Motion sensors that don’t move

A real phone has an accelerometer, a gyroscope and usually a magnetometer. Many also have a barometer, a light sensor, a proximity sensor and a step counter. Each is a physical chip, and each produces a stream of readings full of tiny random noise, even when the phone is lying perfectly still on a table.

That noise is one of the most reliable tells there is. A real accelerometer at rest reads roughly the pull of gravity, around 9.8 metres per second squared, on whichever axis points down, with small fluctuations on every axis in every reading. Those fluctuations come from the physics of the sensor and the vibrations of the room.

An emulator’s accelerometer, if it has one, often returns a perfectly constant value. The exact same gravity figure, to every decimal place, reading after reading. Or it returns zero on every axis, which no phone on Earth does. Or it returns values that change in smooth, mathematical patterns when the emulator’s controls tilt the virtual phone.

Apps can read sensors without any special permission. An app that samples the accelerometer for a second or two can see immediately whether the readings have natural noise.

The list of sensors matters too. Android lets an app list every sensor the device reports, along with each sensor’s name, vendor, resolution and power use. Real phones report sensors from real chip makers. Emulators often report sensors with generic or emulator specific vendor names, or report a much shorter list than any real phone of the claimed model would have.

A model claiming to be a recent flagship with no barometer, no step counter and a single generic accelerometer is describing a phone that doesn’t exist.

A battery that never drains

The battery is the second big physical tell, and it’s one people setting up emulators often forget exists.

Android exposes battery information to any app without permission: the charge level, whether it’s charging, how it’s charging, the battery’s temperature, its voltage, its health and the technology. A real phone’s battery changes all the time. The level drops as you use the phone and rises when you charge it. The temperature moves with use and with the room. The voltage wobbles.

Emulators often report a fixed battery state. A level stuck at 100 percent, or at 50, never changing. Always charging on AC power. A temperature that sits at the same value for days. A voltage that never varies. Some emulators simulate a battery more carefully, but the simulation tends to be too smooth.

Watching the battery over time is easy for an app. It can record the level and temperature every time it opens. After a few sessions, a phone whose battery has never moved by a single percent, and whose temperature is identical to the tenth of a degree every time, looks like a machine.

Real phones in racks have a version of this problem, which is worth being honest about. A phone that lives on a charger sits near full charge all day, and many real people’s phones do that on their bedside table overnight. Some phones have a battery protection setting that stops charging below 100 percent to reduce wear. Those are real behaviours, and a real phone on a charger still reports real temperature changes and real voltage noise. The difference between a real phone on a charger and an emulator is the noise, not the charge level.

Build properties and the system’s own description

Every Android build carries a set of system properties that describe itself. Apps can read many of them through standard interfaces, and some through system files.

These properties include the manufacturer, the brand, the model, the device name, the product name, the hardware platform, the bootloader version and a long build fingerprint string that combines several of them with the Android version and build type. They’re written by whoever built the operating system image, which for a real phone is the phone maker.

Emulator images have their own values. The official emulator’s properties often contain words like generic, sdk, emulator, goldfish or ranchu, which are the names of the virtual hardware platforms it uses. Other emulators have their own tell tale names. The build type may be a developer build rather than a user build. The tags may say test keys rather than release keys.

There are also properties that exist only on emulators, or on the virtual hardware they use. One classic example is a kernel property that’s set when the system is running under QEMU, the virtualisation software the official emulator is built on. There are device files and libraries that only exist on emulators too.

Detection libraries check dozens of these at once. A match on any of them is strong evidence. And they’re cheap to check, because the app is reading the device’s own description of itself.

Why spoofing build props makes it worse

The obvious response is to change the properties. Tools exist for rooted devices and emulators that rewrite the model, manufacturer and fingerprint to match a real phone. On the surface, the emulator now says it’s a particular Samsung or Pixel.

The trouble is that the build properties are a claim, and everything else on the device is evidence.

A device claiming to be a specific Samsung model should have Samsung’s system apps, Samsung’s settings layout and Samsung specific system services. It should report the sensors that model ships with, from the vendors that model uses. Its GPU should be the one in that model. Its screen resolution and density should match the model’s panel. Its processor should be the chip that model uses, which for most modern phones is an ARM design.

An emulator with rewritten properties has none of that. It says Samsung, and then it lists a generic accelerometer, reports a desktop GPU, runs on an x86 processor and has none of Samsung’s software. The claim makes the evidence more obviously wrong, because the app now has a specific model to compare against.

This is the same pattern as antidetect browsers claiming the wrong operating system. A generic emulator that says it’s an emulator is at least consistent. An emulator claiming to be a flagship phone is a contradiction on every line.

Play Integrity adds a layer the properties can’t touch. Its strongest verdicts rely on hardware backed keys inside a real phone’s secure hardware, which an emulator doesn’t have.

The graphics chip names itself

Android apps can ask the graphics driver for its vendor and renderer names through OpenGL ES or Vulkan, much as a web page can through WebGL. On a real phone, the answer names the phone’s GPU. Adreno on many Qualcomm based phones, Mali on many phones with Samsung Exynos or MediaTek chips, and a few others.

On an emulator, the answer is often one of three things. A name that identifies the emulator’s own graphics translation layer. A software renderer name. Or the name of the host computer’s desktop graphics card, passed through.

All three are tells. The first two say emulator outright. The third says a desktop graphics card, like one from Nvidia or AMD’s desktop lines, inside something claiming to be a phone. No phone contains one.

The GPU also shapes what rendering tests produce. An app that draws a test scene and hashes the output gets a result that belongs to the GPU and driver that drew it. A real phone’s output matches the family for its GPU. An emulator’s output matches the host’s graphics or a software renderer.

Beyond the name, GPUs report their supported extensions and limits, just as they do in browsers. Mobile GPUs have characteristic sets. Desktop GPUs and translation layers have different ones.

So even an emulator that spoofs the renderer name to say Adreno still has to match an Adreno’s extensions, limits and rendering output. That’s far harder than editing a string, and most tools don’t attempt it.

The processor underneath

Almost every phone sold today runs an ARM processor. Many emulators run on x86 computers.

Android handles this with translation. The emulator image may itself be built for x86, with a translation layer that lets ARM apps run. Or it may be an ARM image running on x86 through slower full emulation. Either way, the device reports information that gives the architecture away.

Android tells apps which instruction sets the device supports. A real modern phone reports ARM 64 bit, and often 32 bit ARM as well. An x86 based emulator reports x86 variants, sometimes with ARM listed as supported through translation. An app can read that list directly.

The processor’s own description is readable too, through system files that list the CPU model, features and core count. An Intel or AMD model name inside something claiming to be a phone is a clear contradiction.

Timing is a subtler clue. Translated or emulated code runs at different speeds for different operations than native code does. An app that times a few specific operations can spot the pattern. That’s more effort than most apps spend, but some fraud SDKs do it.

ARM based cloud phones, running Android in containers or virtual machines on ARM servers, avoid most of this. Their processor genuinely is ARM. They still have the sensor, battery, radio and often GPU problems, because there’s no phone hardware under them. They’re a different compromise, not an escape from detection.

The radio and the SIM

A phone is, among other things, a radio. Android gives apps information about the mobile network through its telephony interfaces, some of it with no permission at all and some behind the phone state permission.

Without special permissions, an app can usually read the network operator’s name and code, the SIM operator’s name and code, the SIM’s country, and the type of network the phone is attached to, such as 4G or 5G. With more permissions it can read more.

Emulators often present default values here. The official emulator reports a network operator called “Android” with a test operator code. Some emulators report no SIM at all. Others report a SIM and network combination that doesn’t match any real carrier in the claimed location.

Signal strength is another clue. A real phone’s signal readings fluctuate constantly as conditions change. An emulator’s are often fixed.

Some apps also look at cell information, which with location permission can include the identity of nearby cell towers. An emulator either returns nothing or returns simulated values that don’t correspond to real towers.

A device with no SIM isn’t automatically suspicious. Plenty of real tablets and some phones have no SIM, and plenty of phones run on Wi-Fi alone. But a device claiming to be a phone on a particular carrier, with an operator name of “Android” and a signal that never moves, is telling the app what it is.

Touch input, cameras and the small tells

Beyond the big hardware components, a set of smaller signals add up.

Touch input is one. When a real finger touches a screen, the touch event includes a contact size and often a pressure value, and both vary with every tap. When an emulator receives a click from a mouse, the event often has a fixed size and pressure, identical every time. Apps that care about bots already look at touch patterns, and a fixed contact size across thousands of taps is easy to spot.

Cameras are another. A real phone lists its cameras with real characteristics like resolution and focal length. An emulator either lists none, lists a virtual camera fed by the host’s webcam, or lists one with generic characteristics.

Bluetooth and Wi-Fi hardware leave their own traces. An emulator often reports no Bluetooth adapter, or one with an obviously virtual identity. Its Wi-Fi may be a simulated network with a default name.

Installed apps say something too. A real phone from a carrier or a manufacturer ships with a set of preinstalled apps. An emulator image has a minimal set, often with developer tools. Some emulator products preinstall their own launcher or helper app, whose package name is a direct giveaway.

Uptime is a small one. Emulators are often started fresh, so the system has been running for minutes. Real phones commonly run for days between restarts.

No single one of these settles anything. Together they make an emulator very hard to mistake for a phone.

A worked example with a spoofed model

Here’s a hypothetical that shows how the tells stack up in one device.

An operator runs a consumer PC emulator, the kind built for mobile gaming, on a Windows desktop. To look less like an emulator, they install a module that rewrites the build properties so the device claims to be a recent Samsung flagship.

Here’s what a checking app sees.

The build properties say Samsung, a specific flagship model, a release build. So far that holds.

The sensor list shows an accelerometer and a gyroscope from a generic vendor, and nothing else. The flagship it claims ships with a barometer, a step counter, a magnetometer, light and proximity sensors from named suppliers. The accelerometer returns the same value on every reading.

The battery reads 100 percent, charging on AC, at a temperature that hasn’t changed all week.

The GPU renderer names the desktop’s Nvidia card. The flagship uses an Adreno or a Mali, depending on the region.

The supported instruction sets list x86 variants, with ARM available through translation.

The operator name is a default value. Signal strength is fixed.

There are none of Samsung’s system apps, and the emulator’s own helper app is installed.

Play Integrity returns a failing device verdict.

So one device has a model claim and roughly eight separate pieces of evidence contradicting it. The spoofed properties didn’t hide the emulator. They gave the app a precise model to compare everything else against.

If this device were left on its default identity, it would still be detected, but it wouldn’t be contradicting itself on every line. That’s a small difference, and neither version is going to look like a phone.

Why hiding tools keep losing ground

There’s a whole category of tools built to hide emulators and root from apps. They’re worth understanding, because their existence leads people to think the problem is solved.

These tools work by intercepting the questions an app asks and changing the answers. Ask for the build properties, get Samsung’s values. Ask whether a root file exists, get told it doesn’t. Ask for the sensor list, get a longer one.

The limits are structural. Every answer has to be faked separately, and every faked answer has to agree with every other one. The detecting side only needs to find one question the tool forgot, or one pair of answers that don’t match. That asymmetry favours the detector.

Some questions can’t be faked at the app level at all. Hardware backed attestation relies on keys inside the phone’s secure hardware that no software on the device can read or forge. Timing differences between native and translated code are properties of the machine. Sensor noise has to be generated with a realism that matches a particular physical chip.

And every popular hiding tool becomes a target. Detection libraries study it and add checks for its specific behaviour, so using it adds a new fingerprint of its own.

None of this means hiding tools never work. They work against apps that don’t check much. Against apps that check seriously, they tend to buy time rather than solve the problem.

Rooted phones sit in the middle

A rooted phone is a real phone whose owner has unlocked the ability to run code with full system privileges. It’s a very different case from an emulator, and it’s worth keeping the two apart.

A rooted phone has real sensors, a real battery, a real radio, a real GPU and a real ARM processor. On every hardware test above, it passes, because the hardware is real. Its build properties are genuine, unless the owner has changed them.

What gives a rooted phone away is the software state. Unlocking the bootloader, which is usually the first step to rooting, changes what the phone’s secure hardware reports. Play Integrity’s device level verdict typically fails on a phone with an unlocked bootloader. Root management apps and their files can be detected, though the tools that hide root are in a constant contest with the apps looking for it.

So a rooted phone looks like a real phone that’s been modified. An emulator looks like something that isn’t a phone at all. Apps treat those differently. Some tolerate rooted phones and block emulators. Some block both. Banking apps often refuse rooted devices outright.

For account work, rooting to spoof device identifiers is a common idea, and it tends to replace one problem with another. The hardware becomes believable. The integrity state becomes the tell.

Real hosted devices

The third option is a real, unrooted phone that happens to live somewhere else, in a rack, reached remotely. That’s what a cloud phone is when it’s built on physical handsets.

On every hardware test in this piece, a real hosted phone passes, because it’s a phone. Sensors report real noise. The battery reports real temperature and voltage. The GPU is the phone’s own. The processor is ARM. The build properties are the manufacturer’s. On a stock, locked phone with current updates, the integrity verdicts reflect genuine certified hardware.

A hosted phone still has tells of its own. They’re the ordinary ones a real person’s phone might have.

A phone in a rack never moves. Its accelerometer shows gravity on one axis with real noise, forever. A person’s phone gets picked up. Whether any app scores stillness over weeks, I don’t know, and I’d be guessing to claim otherwise.

A phone on a permanent charger sits near full. Plenty of real phones do that at night, fewer do it all day, every day.

Phones in the same rack may see the same Wi-Fi networks and nearby devices, which ties them together if an app with location permission scans for them. That’s a separate topic, and it’s about placement rather than emulation.

And the network the phone uses still has to fit its SIM, its carrier and the account’s story. A real phone on a mismatched connection has a different problem, not an emulator problem.

Testing a device before you trust it

If you’re evaluating any Android device for account work, whether it’s an emulator, a rented cloud phone or a handset you own, you can check most of these tells yourself.

Install a sensor viewer app and watch the accelerometer with the device at rest. Real sensors show constant small noise on all three axes. Constant or zero values mean simulated sensors. Check the sensor list against the list the claimed model should have.

Open the battery details, in settings or through a device info app. Watch the level, temperature and voltage over an hour. Real batteries move.

Use a device info app to read the build properties, the GPU renderer, the supported instruction sets and the CPU description. Compare each against the claimed model’s real specifications.

Check the SIM and network information. Operator names should be real carriers. Signal readings should fluctuate.

Run a Play Integrity checker app and read the verdicts. Remember that a pass is evidence of certified hardware and software, not proof an account will be safe.

Write it all down with the date. Devices get updated, and a check from last month may not describe the device today.

What to do with this

If you’ve been running accounts in emulators, the practical takeaway is to be realistic about what they can do. They’re fine for learning, for testing app flows, and for work where the app doesn’t care. For apps that check, an emulator starts with a set of tells that are hard or impossible to remove, and spoofing its identity usually adds contradictions rather than removing them.

If you’re using rooted phones, know that the hardware story is solid and the integrity story isn’t. Decide whether the apps you care about tolerate that.

If you’re using real hosted phones, the hardware and integrity stories hold. Your attention goes to the things a real phone still has to get right: the network matching the SIM, placement, sensible behaviour, and one identity per device.

Whatever you use, check the device yourself rather than relying on a provider’s description. The tests above take an afternoon and tell you what an app will see.

The honest limit

Emulator detection is a contest that keeps moving. Apps add checks, emulators patch them, apps add more. I can describe what the public detection libraries and platform attestation look at, and why each signal differs between an emulator and a phone. I can’t tell you exactly which checks a given app runs today or how it weighs them. Nobody outside that app’s team can.

What doesn’t move is the underlying physics. A phone has components that produce noisy, drifting, wearing readings because they’re physical. Software that pretends to have those components has to invent the readings, and invented readings tend to be too clean, too constant or too different from the model they claim.

A real device doesn’t have to invent anything. That doesn’t make an account on it safe, and it doesn’t excuse anything the account does. It just means the device layer is telling the truth.

I run Singapore mobile proxy and cloud phone farms myself, with real handsets on real SIMs, which is why the device layer on the identities I care about most is real rather than simulated. If you want the rest of the mobile picture, start on the Multi Account Ops home page.

Get new guides and videos first — join the Telegram channel.

need infra for this today?