Bot Detection API for Headless Browsers, Automation & AI Agents
Puppeteer with stealth patches, Playwright behind residential proxies, Selenium farms on cloud VMs — they all look like users to your server logs. Sentinel reads the device underneath the traffic and returns device.automation, VM and emulator signals, and datacenter origin in one call, in under 40ms. No CAPTCHA in front of anyone.
What you're up against
Headless browsers with stealth patches
Off-the-shelf stealth plugins scrub navigator.webdriver, fake plugin lists, and spoof WebGL strings, so the JavaScript checks most sites rely on come back clean. The framework underneath is still Puppeteer — but nothing in the request says so.
CAPTCHAs that only stop humans
Solver farms clear a CAPTCHA for fractions of a cent, and modern vision models solve them outright. What's left is a challenge that costs you real-user conversion while the bots pay a rounding error to walk through.
Rate limits that never fire
Bot fleets rotate through residential proxy pools, so every request arrives from a fresh, clean-looking IP. Per-IP throttles and geo rules see a thousand different visitors where there is one script in a loop.
AI agents that browse like people
LLM-driven agents type plausibly, wait between clicks, and follow multi-step flows — behavioral heuristics tuned for dumb scripts don't trip. The tell isn't the behavior anymore; it's the automated environment the behavior runs in.
What Sentinel does for you
- Flag Puppeteer, Playwright, and Selenium sessions with
device.automation— stealth patches included - Detect emulators and virtual machines behind device farms with dedicated reason codes
- Correlate device signals with network origin: datacenter ASN, provider name, proxy and VPN flags in the same response
- Route on machine-readable reason codes —
automation_detected,emulator_detected,virtual_machine,datacenter_asn— instead of a black-box score - Verdict in under 40ms, invisible to real users — no challenge pages, no puzzle-solving
drop in scalper-bot activity in our illustrative composite scenario of a travel platform whose inventory was being held hostage by automated checkout scripts
[ Read Full Case Study ]Where the check goes
Put the check in front of whatever the bots are hammering: signup, login, checkout, or any form POST. The client snippet rides along in your page and collects device evidence; your server asks Sentinel for a verdict before the protected action runs, and routes on the reasons array.
// Score the request before the protected action runs const verdictRes = await fetch('https://sntlhq.com/v1/evaluate', { method: 'POST', headers: { 'Authorization': 'Bearer ' + process.env.SENTINEL_KEY, 'Content-Type': 'application/json' }, body: JSON.stringify({ token: req.body.sentinel_token }) }); const risk = await verdictRes.json(); if (risk.device && risk.device.automation) return res.status(403).json({ error: 'Request rejected' }); if (risk.reasons.includes('virtual_machine')) flagForReview(risk.reasons); // soft signal — route, don't block
Don't take the docs' word for it — run your own connection through the live scanner on the homepage, or point a headless browser at it and watch the verdict flip. Both are keyless previews with a reduced signal set — the full API adds device intelligence and multi-account linking.
The signals that matter here
Automation frameworks, read below the patches. Stealth plugins rewrite the JavaScript surface that naive checks inspect — but the device layer reads the environment underneath: rendering quirks, timing characteristics, and hundreds of low-level attributes that patched Puppeteer and Playwright sessions don't consistently fake. When automation is present, the response carries device.automation: true and the automation_detected reason code — a hard signal your server can block on. The same layer covers the broader headless-browser landscape, from vanilla headless Chrome to hardened forks.
Emulators and VMs: where bot farms actually live. Scaled operations don't run on someone's laptop — they run on Android emulator grids and cloud-provisioned virtual machines. Sentinel returns emulator_detected and virtual_machine as separate reason codes with separate weights: an emulator is a strong fraud tell, while a VM alone is soft evidence (developers and corporate VDI users live in VMs too), so the score reflects the difference instead of flattening both into "bot".
Datacenter-origin correlation. Bots overwhelmingly originate from datacenters, so every verdict pairs the device evidence with network origin: network.datacenter, the named hosting provider, and proxy/VPN/Tor flags — built on provider-published IP ranges refreshed continuously, not a stale ASN dump. The correlation matters in both directions: a clean-looking browser POSTing from an AWS range is worth a second look, and an automation-flagged device on a residential proxy is still flagged — the device evidence doesn't wash off with a better IP.
Reason codes, not a black box. Every verdict ships the individual signals and a reasons array — automation_detected, emulator_detected, virtual_machine, datacenter_asn, proxy_detected — so your policy lives in your code, not ours. Block hard automation, send VM-only traffic to review, exempt your own monitoring: no CAPTCHA required at any point, which also means no conversion tax on the humans. That routing flexibility is what separates a usable bot signal from a score you have to trust blindly — especially against AI agents whose behavior looks human even when their environment isn't.
What this won't catch — honestly. No bot detection API stops everything, and vendors who claim otherwise are selling you a fairy tale. A human at a real browser doing the abusive work manually — a paid click farm, a CAPTCHA-farm worker walking through your flow — presents genuine human signals, because they are one; you catch those operations on volume patterns and multi-account linking, not automation flags. A brand-new framework can have a window before its artifacts are profiled. And the device layer needs the client snippet to run — a bot that only hits your raw API endpoints and never loads your page yields network signals (datacenter, proxy, blocklist) but no device verdict. Treat Sentinel as the strongest layer in a stack that still includes rate limits and business-logic checks, not a replacement for all of them.
Common questions
Put a real bot signal in front of your forms
Free tier: 1,000 requests/hour. No card, no expiry. Detects headless browsers, automation frameworks, emulators, and datacenter origin.