Headless Browser Detection

The navigator.webdriver property is the most fundamental leak point for automation detection. When a browser is controlled by Selenium, Puppeteer, or Playwright, this boolean is set to true by default. Detection scripts can simply evaluate navigator.webdriver === true to flag automated sessions.

• Origin: Part of the W3C WebDriver specification, intended as a compliance signal for servers.
• Evasion: Attackers often override this property using --disable-blink-features=AutomationControlled or by patching the getter with JavaScript proxies.
• Counter-detection: Combine this check with other signals; never rely on this property alone.

The Chrome DevTools Protocol (CDP) is the underlying communication layer that Puppeteer and Playwright use to control Chromium. Its presence can be detected by attempting to connect to the debugging port or by checking for CDP-specific artifacts in the runtime.

• Debug Port: Check if http://localhost:9222/json is accessible from the browser context.
• Runtime.evaluate: Detect if the Runtime domain has been injected by looking for modified Error.stack traces that include CDP-specific call frames.
• WebSocket Connection: Monitor for active WebSocket connections to ws://127.0.0.1 with CDP-specific paths.

Headless Chromium instances append HeadlessChrome to the default User-Agent string, creating an immediate and easily detectable signature. While this string can be overridden, many unsophisticated scrapers neglect to do so.

• Default String: Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) HeadlessChrome/91.0.4472.77 Safari/537.36
• Detection Logic: Parse the UA string for the substring HeadlessChrome.
• Evasion: Attackers pass --user-agent argument with a legitimate browser string. Combine with TLS fingerprinting (JA4) to detect mismatches between the claimed UA and the actual TLS stack.

Headless browsers lack a visible viewport, leading to detectable anomalies in screen dimensions and rendering behavior. These checks exploit the absence of a physical display.

• Window Size: window.outerWidth and window.outerHeight often report 0 in default headless configurations.
• Color Depth: screen.colorDepth may report default values inconsistent with real hardware.
• WebGL Renderer: Querying the WebGL vendor and renderer string via WEBGL_debug_renderer_info often reveals SwiftShader or Google SwiftShader instead of a physical GPU name like ANGLE (NVIDIA GeForce RTX 4090).

Headless modes often disable or stub out features that require a physical user interface, creating detectable gaps in API behavior.

• Permissions API: navigator.permissions.query({name: 'notifications'}) may return denied instantly without prompting, whereas a real browser would show a permission dialog.
• Plugins Array: navigator.plugins.length is often 0 in headless mode, while real Chrome installations include internal plugins like Chrome PDF Plugin.
• Touch Support: navigator.maxTouchPoints may report 0 even on platforms where a real browser would report a value, or the ontouchstart event handler may be absent from window.

Automation frameworks often modify native JavaScript functions to evade detection, but these modifications themselves leave artifacts. Integrity checks verify that core browser APIs remain unaltered.

• Prototype Chain Inspection: Check if navigator.webdriver has been redefined using Object.getOwnPropertyDescriptor(Navigator.prototype, 'webdriver'). A custom getter indicates tampering.
• Function toString: Evaluate Function.prototype.toString.call(window.chrome.runtime.connect). Native functions return function connect() { [native code] }. Automation tools that stub out APIs often fail to replicate this exact string.
• Error Stack Traces: Throw a deliberate error and inspect the stack trace. Automation frameworks inject custom frames that are absent in native browser stacks.

A client-side JavaScript interrogation that verifies the runtime environment has not been tampered with by automation frameworks. These checks detect modifications to native APIs, prototype chains, and the absence of standard browser artifacts.

• Prototype chain inspection: Verifies navigator.plugins and navigator.mimeTypes return proper PluginArray and MimeTypeArray objects, not empty or spoofed arrays
• API integrity: Checks if functions like Function.prototype.toString have been overridden to hide native code modifications
• WebGL fingerprinting: Renders a hidden canvas to detect inconsistencies in the GPU driver stack introduced by headless rendering engines
• Chrome runtime checks: Probes for the presence of chrome.runtime and chrome.csi objects that are absent in headless mode

A defensive mechanism involving invisible page elements hidden from human users via CSS but visible to programmatic parsers. When an automated agent interacts with these traps, it immediately identifies itself as non-human.

• Invisible links: Anchor tags positioned off-screen or styled with display: none that humans never click
• Hidden form fields: Input elements with tabindex="-1" and opacity: 0 that bots auto-fill while humans leave empty
• CSS pseudo-content traps: Elements visible only to headless browsers that don't fully compute layout or execute CSSOM
• Interaction with any honeypot element triggers an immediate block, session termination, or feeding of poisoned data

A probabilistic rating assigned to a session or request by a detection engine, aggregating multiple signals into a single actionable metric. Modern bot management platforms compute this score in real-time at the edge.

• Signal aggregation: Combines IP reputation, TLS fingerprint (JA4), HTTP/2 fingerprint, and behavioral telemetry
• Scoring range: Typically 0-100, where 0 is definitively human and 100 is definitively automated
• Threshold-based actions: Scores above 80 may trigger a CAPTCHA challenge; scores above 95 result in silent blocking
• Machine learning models: Continuously retrained on traffic patterns to adapt to evolving automation frameworks and residential proxy networks

The heuristic examination of request timing, URL traversal logic, and session depth to distinguish the methodical behavior of bots from the stochastic patterns of human browsing.

• Inter-request timing: Bots exhibit unnaturally consistent delays or impossibly fast click-through rates compared to human motor limitations
• URL traversal order: Scrapers follow predictable depth-first or breadth-first link crawling; humans navigate non-linearly
• Session entropy: Human sessions show varied dwell times and random page revisits; bot sessions are rigid and goal-directed
• Mouse and scroll telemetry: Headless browsers lack natural mouse movement curves, hover events, and scroll jitter unless explicitly emulated

A security service deployed at the CDN edge that uses machine learning and multi-layered fingerprinting to detect, categorize, and mitigate automated traffic before it reaches the origin server.

• Real-time classification: Analyzes requests within milliseconds at the edge node, avoiding latency penalties
• Fingerprint aggregation: Combines JA4 TLS fingerprints, HTTP/2 SETTINGS frame analysis, and passive OS fingerprinting
• Action orchestration: Applies graduated responses—allow, challenge, rate-limit, or block—based on bot score and organizational policy
• Threat intelligence integration: Correlates traffic against global botnet databases and known residential proxy exit nodes
• Providers include Cloudflare Bot Management, Akamai Bot Manager, and AWS Shield Advanced