Written for somebody who wants to defeat this, because that is the only useful way to describe a detector’s limits.
| Signal | What defeats it | Cost |
|---|---|---|
| No sub-resources | Fetch the stylesheets and images | Bandwidth, nothing else |
| Single page, under 10s | Fetch two pages and wait | Time |
| Timezone mismatch | Set the browser timezone from the exit address’s geolocation | Perhaps twenty lines of code |
| Datacentre + browser UA | Use residential proxies | Already the default for anyone serious |
| No JS on HTML | Run a real browser engine | Also already the default |
- Automation markers — you must patch the browser. Patched Chromium builds that hide the webdriver flag and the driver properties exist and are actively maintained, so this is possible, but it means building and shipping a custom browser rather than installing a library.
- The headless renderer — you must give the container a real GPU, or convincingly spoof the WebGL renderer string without breaking anything else WebGL reports.
- The engine claim — you must stop lying about your User-Agent. There is no cheap fix: the engine either implements the feature or it does not. You can only pass by making the User-Agent honest, which then makes you trivially identifiable by that honest User-Agent.
- No interaction — you must synthesise plausible input. Doable, and detectably wrong when done badly: straight-line mouse paths and uniform scroll velocity are exactly what the mouse-entropy signal looks at.
- The fingerprint cluster — you must give every session a genuinely distinct header fingerprint. This is the expensive one, and it is expensive for a structural reason.
Figure 1 — why the fingerprint is hard to beat. The tuple is eleven correlated header values, and they have to be mutually consistent as well as distinct. Randomising them independently produces combinations no real browser sends, which fires the mismatch rules instead.
The capture committed to the Loghound repository is worth studying because it defeats every existing tool. That fleet does everything right:
- It fetches sub-resources. Images, stylesheets, scripts, the favicon. The no-sub-resources rule does not fire.
- It executes JavaScript. Every one of its thirteen addresses requests the site’s third-party analytics beacon with a full payload — screen resolution, language, a timezone. That endpoint is only ever reached by code that ran in a JavaScript engine, so the no-JS rule does not fire either — and, this is the important part, the site’s own analytics counted all thirteen as human visitors.
- The User-Agents are ordinary. Nothing in any blocklist.
- The addresses are spread across unrelated networks, which defeats any per-address rate limit.
- One of them even sends an interaction event and downloads a large file — engagement, by any conventional measure.
What gives it away is plane 2: five of those addresses, in five different networks, share a byte-identical header fingerprint, and three of them began a session in the same second. The fingerprint page has the numbers.
Real, non-headless browsers on residential addresses, a complete and self-consistent fingerprint per session, human-like input, no reused exit address — that will be classified as human by Loghound. Everything here raises the cost of scraping by a large factor. None of it makes scraping impossible, and any tool claiming otherwise is selling something.
The realistic goal is to make cheap scraping visible, and to make expensive scraping expensive enough that it stops being worth doing to you specifically. False positives is the same honesty pointed the other way.