Bot Traffic IndexThe bot problem, quantified

Headless Browsers: How Bots Fake a Real Browser, and What Gives Them Away

The bot that hits your checkout is not sending raw HTTP requests anymore. It runs a real browser, Chromium, with no window attached, driven by Playwright or Puppeteer through the Chrome DevTools Protocol. It executes your JavaScript, renders your pages, and passes every check that catches a simple script. The only way to spot it is to look for what a real browser has that a headless one does not.

The four tells a real browser never shows

The first tell is the one the WebDriver specification requires. When a browser is driven through automation, navigator.webdriver is set to true. It is a boolean the specification says must be true during any automation session controlled through the Chrome DevTools Protocol, and vanilla Playwright and Puppeteer set it. One line of JavaScript checks it. Stealth libraries overwrite it, which is why it only catches bots running bare, unmodified automation, but a surprising share of bot traffic is exactly that.

The second tell is the empty plugin list. navigator.plugins returns an empty PluginArray, length zero, in headless Chromium. No real desktop Chrome installation reports that: a real Chrome always includes at least the PDF Viewer plugin, and typically several others. The User-Agent is the third: headless Chrome historically stamped HeadlessChrome into the string, about as loud a tell as exists. And the fourth is the graphics stack. A headless instance without GPU passthrough reports its WebGL renderer as Google SwiftShader, a software renderer, where a real Chrome on a MacBook reports something like Apple M2. The canvas fingerprint differs too, because SwiftShader rasterizes text and shapes differently from hardware-accelerated Chrome on a real operating system.

Each of these is a passive signal, measurable without any behavioral heuristics. Any one of them is sufficient for a fingerprinting script to flag the session as automated. And there are smaller smells alongside them: navigator.languages empty, window.outerWidth equal to zero, navigator.connection.rtt equal to zero, all artifacts of a browser with no real window and no real network path. A session that shows three of these at once is not a user with an unusual setup. It is automation.

Why the cheap checks stopped working

The cheap checks are the ones any library can patch, and the bot operators know it. Overwriting navigator.webdriver to return undefined takes less than ten lines of code. Playwright and Puppeteer now mask it by default. The User-Agent is trivially rewritten. And the deeper tell, the residue the Chrome DevTools Protocol leaves behind when it enables a Runtime domain, is subtler: the protocol socket itself is invisible to page JavaScript, and reading its residue reliably takes version-tracking probes that most sites do not run. Related reading: Someone Is Scraping Your Prices Every Hour. Here Is How to Tell..

The numbers show how the balance has shifted. A crawl dataset from Bamberg found navigator.webdriver probed by 34 percent of sites, and at least one automation-only JavaScript property by 46 percent. But three quarters of headless blocks fire on HTTP header signals alone, before a single line of fingerprint JavaScript runs. The detection that matters most now happens before the page loads, not after it.

Stealth tooling has also moved up the stack. Playwright's real-browser mode, using an installed Chrome binary rather than the bundled Chromium, reduces some of the fingerprint differences, though the CDP connection itself introduces artifacts that persistent fingerprinting scripts can detect. And commercial headless browser APIs run real browser instances on virtual machines with genuine GPU stacks, display servers, and network interfaces, so there is no headless leak at all, because the browser is not running headless. It is running exactly as it would on a real user's machine. More on this: Card Testing Bots: Small Charges That Mean a Bigger Attack.

What actually holds up

Detection in 2026 works in four layers, ordered by how hard each is to defeat. First, browser API checks like navigator.webdriver, trivially patched. Second, rendering and GPU fingerprints, harder to spoof because they require a real GPU stack or a convincing fake of one. Third, TLS and HTTP/2 transport fingerprints, which capture the structure of the TLS ClientHello, cipher suite ordering, extension lists, and HTTP/2 frame ordering, and require modified browser builds to fake. Fourth, behavioral motion, which no automation library has replicated reliably at scale: the way a real mouse moves, with acceleration, overshoot, and correction, and the timing between actions.

The durable layer is the fourth. A bot can fake a fingerprint, patch a flag, and rent a real GPU, but it still has to move like a person, and moving like a person is the hardest part of the whole job to automate convincingly. The stores that catch headless browsers reliably are the ones that score the session across all four layers and join the judgments, rather than weighing any single signal in isolation. A perfect device fingerprint wired to navigator.webdriver equal to true reads as someone trying to pass, and that pairing often scores worse than either signal on its own.

Frequently asked questions

What is a headless browser?

A real browser, usually Chromium, run without a visible window and driven by a program through the Chrome DevTools Protocol. Playwright, Puppeteer, and Selenium all work this way.

Does navigator.webdriver catch every headless bot?

No. It catches bots running bare, unmodified automation. Stealth libraries overwrite it, and Playwright and Puppeteer now mask it by default, so it is only the first layer.

What is the most reliable detection signal?

Behavioral motion. API checks are patchable, GPU fingerprints can be faked with a real GPU stack, and TLS fingerprints need modified builds. No automation library has replicated human mouse movement reliably at scale.

Why do headless browsers show SwiftShader as the GPU?

A headless instance without GPU passthrough has no graphics hardware, so it renders with SwiftShader, a software renderer. A real browser reports the actual GPU, like Apple M2 on a MacBook.