TL;DR: how to detect bots on your website
- Stack three layers: network (IP, ASN, TLS fingerprint), browser (fingerprint, headless flags), behavior (mouse, timing, sequence).
- Any single layer gets bypassed. Residential proxies beat IP reputation. Stealth Playwright beats browser fingerprints. Only behavior catches LLM agents.
- Combine into one session trust score you can act on live. Allow 0-30, step up 31-70, block 71-100.
Why bot detection has become harder
Traditional bots sent raw HTTP requests with no browser context. Catching them was straightforward: look for missing headers, odd user agent strings, or request rates no human could produce.
Modern bots are different. AI agents such as OpenAI Operator, Claude for Chrome, Playwright, Puppeteer, and Selenium run inside real browser engines. They render JavaScript, execute event handlers, and produce request patterns that look, at a basic level, like real users. Puppeteer and Playwright drive Chromium directly. Selenium controls a fully rendered browser. User agent checks and simple header inspection do not separate these from human visitors.
The problem has shifted from spotting cheap impostors to identifying sophisticated actors that have gone to deliberate lengths to look human.
Network signals: what they catch and their limits
Network signals are the outermost detection layer. They are fast and cheap, and they filter bulk, low-effort traffic before anything more expensive runs.
User agent strings
The user agent header names the browser and operating system making the request. Many simple scrapers send generic or revealing user agent strings, which makes them easy to flag.
The limit is obvious: any HTTP client can set any user agent string it likes. A bot that sends Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 is indistinguishable from a real Chrome user at the network layer. User agent filtering catches lazy bots and little else.
Request rate
Scripted floods, credential stuffing, and aggressive scrapers often generate request rates no human could match. Rate limiting and anomaly detection on requests per second or per session catch those patterns.
The gap is that human-speed AI agents, increasingly common in 2026, make requests at rates that sit inside normal human ranges. An AI agent working through a form might take 8 to 15 seconds per action, well within ordinary user behavior.
IP reputation
IP reputation lookups flag known datacenter ranges and VPN exit nodes, which helps filter commodity bot traffic routed through cloud infrastructure.
Residential proxies bypass this entirely. Our guide on how to detect VPN and proxy traffic covers proxy detection in full.
Automated bots testing stolen credential lists at scale remain a primary breach vector. The Verizon Data Breach Investigations Report found that 39% of 2025 breaches involved stolen credentials, the payload those bots deliver.
| Data breach vector (2025) | Share |
|---|---|
| Breaches involving stolen credentials | 39% |
| Other vectors | 61% |
Source: Verizon Data Breach Investigations Report.
Browser signals: what they catch and their limits
Browser signals examine the JavaScript environment inside the browser to judge whether it matches a real, human-operated browser.
Headless browser flags
The most basic check reads navigator.webdriver, which is set to true in browsers driven by the WebDriver protocol, including Puppeteer and Selenium. Reading this property catches out-of-the-box, unconfigured bot setups.
The limit is that this is a one-line patch. Any production-grade framework sets navigator.webdriver to false before running page logic, so the flag alone only catches development-stage tests.
Missing browser APIs
Real browsers expose a consistent set of JavaScript objects: window.chrome, navigator.plugins, navigator.mimeTypes, and other APIs that reflect a working browser. Headless or minimal environments often omit these, or expose them in a way that differs from a real browser.
The same caveat applies: sophisticated bots patch these properties. The detection value comes from checking combinations of APIs and their internal consistency rather than any single property.
Canvas and WebGL fingerprint entropy
When a browser renders a canvas element or a WebGL scene, the output varies slightly with the graphics hardware, driver version, and rendering pipeline. A real device with a GPU produces output with natural entropy across these dimensions.
Bots running in minimal or virtualized environments often produce low-entropy canvas and WebGL output because they lack real GPU hardware. Abnormally uniform or low-entropy fingerprints are a meaningful sign that the rendering environment is not a real user device.
cside analyzes 100+ signals, including canvas entropy, font rendering characteristics, WebGL fingerprint, screen metrics, and navigator properties, to produce a stable device fingerprint that holds up across incognito mode, VPN connections, and cookie clearing. Combining that many signals makes it very hard for a bot to fake a passing result on every dimension at once.
Behavioral signals: the hardest to fake
Behavioral signals watch how a user interacts with the page rather than what the browser environment looks like. They cost the most to generate, because they need real interaction to measure, and they are also the hardest for bots to fake convincingly.
Mouse movement patterns
Real users move a mouse along curved, accelerating paths. The physics of human hand movement produce characteristic acceleration curves, overshoots, and micro-corrections. Bots generating synthetic mouse events tend to produce perfectly straight lines, perfectly smooth curves, or statistically impossible patterns such as zero-variance velocity.
Timing variance in mouse movement is especially revealing. Human movement has natural jitter at the millisecond level. Scripted movement does not.
Event timing patterns
Real users have reaction-time variance. The gap between a page loading and a user clicking a button, starting to type, or scrolling is never perfectly consistent, because it reflects genuine cognitive processing time.
Bots execute actions at precise, repeatable intervals. The timing between DOM events from an automated script has a statistical signature that differs measurably from human-generated event streams.
Interaction entropy
Did the user actually read the page before submitting the form? Did the cursor move to the field before a value appeared in it? Did any scroll events precede the click? Real users leave an interaction trail. Bots that jump straight to form submission with no prior interaction produce a session profile with abnormally low entropy.
Why you need all three categories combined
No single category is enough for reliable bot detection in 2026. Network signals are bypassed by residential proxies, browser flags are patched by production-grade frameworks, and behavioral signals need enough page interaction to produce meaningful data.
The combination is what makes detection hold. A bot might pass every network check, patch the obvious browser flags, and even produce plausible interaction timing on a simple page. Producing a passing result across 100+ signals at once, including GPU-derived canvas entropy, natural micro-timing variance in mouse movement, and a TLS handshake fingerprint TLS fingerprint that matches the declared browser, is extremely hard to pull off at the automation layer.
cside combines all three categories into a single API response. One call returns a bot score derived from the full signal set, a device fingerprint ID for velocity analysis, and individual signal verdicts for teams that want to build custom logic on the raw data.
How AI agents are different
AI agents such as OpenAI Operator, Claude for Chrome, Playwright, and Puppeteer are a specific detection challenge. They run inside real Chromium, so they pass most browser-level checks. Their network characteristics look normal, and their browser APIs are present and consistent.
Where they fail is session-level behavior. AI agents complete tasks, they do not browse. Their session cadence is task-shaped: go to a specific element, perform an action, move to the next step. Real human sessions have exploration, attention drift, re-reads, and inconsistency. An agent session is optimized and purposeful in a way that produces a statistically distinct profile.
cside identifies named AI agents including OpenAI Operator, Claude for Chrome, Playwright, Puppeteer, and Selenium through a mix of browser environment analysis and session cadence signatures. It returns a real-time verdict that flags AI-agent and automated sessions as part of the API response.
Put bot detection in your critical flows
Bot detection is not one check. It is a composite of network, browser, and behavioral signals scored together against a consistent fingerprint. cside delivers that composite verdict in a single API call, with named AI agent detection included, so you can run it in your signup, login, or checkout flow. cside AI agent detection and bot detection both run from a single script tag, and the free tier covers 1,000 API calls per month with no credit card required.
Further reading
