Why a desktop browser cannot pass as a phone
AntiBrow does not offer mobile device profiles. If a real mobile fingerprint is a hard requirement, several other vendors in this category advertise mobile emulation as a feature; check the sourced comparison at pricing and comparisons before choosing on that basis, since what "mobile" means in practice varies between them. This post explains why we have not built it. It is a limit of the approach, not a roadmap item.
What "mobile mode" in a desktop browser actually changes
The mobile emulation built into desktop developer tools, and the "mobile profile" features some antidetect browsers layer on top of it, work the same way: resize the viewport, adjust the user agent string, and synthesize touch events on top of a pointer device that is still a mouse or trackpad. That is useful for checking how a layout responds to a narrow viewport. It is not a phone, and the properties it leaves untouched are the ones a fingerprinting script actually checks.
What is easy to fake
Touch events and pointer capabilities are software constructs already. ontouchstart, the PointerEvent pointer type, and matchMedia("(pointer: coarse)") can all be set to whatever a script wants reported, because they are just values a page reads, not signals tied to a physical input device. The same goes for viewport dimensions and a user agent string's literal text. None of it requires touching hardware.
What does not move with it
- Device pixel ratio and screen metrics. A real phone's
window.devicePixelRatioand screen dimensions come from a specific, dense physical display. Overriding the reported value on a desktop machine still leaves every other rendering signal, including actual glyph rasterization at that claimed density, produced by the desktop's real display pipeline underneath. - The mobile GPU and its WebGL renderer string. Phones report GPU vendor and renderer strings from mobile chip families through
WEBGL_debug_renderer_info, and the deeperWebGLparameter set (extension list, precision formats, shader compiler behaviour) is produced by that chip's actual driver. Rewriting the renderer string alone leaves everything downstream of it still generated by a desktop GPU driver, and the two do not agree once a script checks past the string itself. - Mobile-specific codecs. Hardware-accelerated decode paths and supported codec profiles differ between mobile chipsets and desktop GPUs, and
MediaCapabilitiesor codec probing can surface that difference directly. - Sensor APIs.
DeviceOrientationEventandDeviceMotionEventexpose accelerometer and gyroscope data on a real phone. A desktop machine has no such sensors: either the values are absent, which is itself the signal of a non-mobile device, or they are synthesized, which tends to look too clean and too static compared to the constant small motion a handheld device actually produces. - Battery behaviour. Where battery state is still exposed to a page, a phone's charge and discharge pattern under normal use looks nothing like a plugged-in desktop, and the pattern shows up over a session, not in a single reading.
- The real mobile user agent and client hints.
Sec-CH-UA-MobileandSec-CH-UA-Platformare a second channel, queried independently of thenavigator.userAgentstring, and both have to agree with each other and with everything else on the page. Setting the UA string without also aligning the client hints, and aligning both with the GPU and sensor picture, is the kind of mismatch a consistency check exists to catch. - App-based attestation. On some platforms, integrity checks like Play Integrity or App Attest verify at the operating system and hardware level that a genuine device and an unmodified app are present, using a signed chain that originates below the browser entirely. No browser-level emulation can produce that chain, because it is not a browser property to spoof in the first place.
Why this is the same problem as every other fingerprinting post
The theme running through this whole category is coherence, not disguise: a profile has to agree with itself across dozens of independently checked properties, or the mismatch is what gets flagged, not the disguise itself. A desktop machine claiming to be a phone has to win that argument on screen density, GPU identity, codec support, sensor presence and OS-level attestation all at once, using a browser process that is, underneath every check, still running on desktop hardware. That is a wider set of contradictions to defend than a same-class device profile ever has to. We cover the specific property pairs worth checking for this kind of mismatch in the fingerprint consistency checklist.
What to use instead if mobile is the requirement
If a workflow genuinely needs a mobile fingerprint rather than a mobile-shaped viewport, real mobile hardware, or a cloud service granting access to actual phones rather than emulated ones, is the tool that matches the job. Real hardware produces a genuinely consistent mobile fingerprint because every property above comes from an actual phone, not from a script asserting values on top of a machine that is not one. That is a better answer than any desktop browser's mobile mode, ours included, and worth treating as the default rather than a fallback.
Check it yourself
Open any "mobile profile" in a trial account and run it through a fingerprinting check alongside a real phone's browser. Compare WEBGL_debug_renderer_info, devicePixelRatio, Sec-CH-UA-Mobile, and whether DeviceMotionEvent returns real motion data or nothing. The gaps show up quickly. See pricing and comparisons for what vendors actually offer here, with sources.
Try it on the free tier.
Unlimited local profiles, no credit card. Check it against the detectors yourself.