Skip to content
Blog

PerimeterX bot protection: HUMAN deployment checks

A deployment-readiness guide for PerimeterX bot protection, now HUMAN Bot Defender: what to verify on sensor, CSP, challenges, timeouts and rollback before go-live.

Centinel Analytica
Published
PerimeterX bot protection: HUMAN deployment checks

PerimeterX bot protection is now HUMAN Bot Defender, and a good deployment means confirming three things on your own site. The Sensor loads on every protected page. The Enforcer sits on every route you care about. And you know what each module does in monitor mode, in active blocking, and when the Detector is slow. This guide is a checklist for operators and buyers, not an alternatives list.

HUMAN and PerimeterX merged in July 2022, so older runbooks, vendor tickets and internal wikis still say "PerimeterX" or "PX". Treat them as the same product. The checks below apply whether you inherited it, are mid-rollout, or are evaluating it. Every mode name and default mentioned here is HUMAN's own. Confirm it against the official Enforcer documentation for your specific module before you rely on it.

PerimeterX bot protection today: HUMAN Bot Defender in brief

HUMAN Bot Defender is a behavior-based bot management product for web apps, mobile apps and APIs (HUMAN docs). HUMAN says it can be deployed on your existing infrastructure. In practice that means the Enforcer is installed on a web application, load balancer or CDN you already run.

The merger matters operationally for one reason: names drift. You may see px prefixes in config keys, "PerimeterX" in contracts and "HUMAN" in the console. Write down which names map to which assets in your estate, so the person who inherits this in a year doesn't have to guess.

The rest of this article assumes you already have, or are about to have, an account and a pilot scope. If you're still comparing vendors, our bot management buyer's comparison is the better starting point.

Sensor, Detector and Enforcer: what each part must do on your site

HUMAN describes three elements (HUMAN docs). Each has a different owner on your side and a different failure mode.

PartWhat HUMAN says it isWhat you must verify
SensorA JavaScript snippet on your site that loads the HUMAN Sensor in the browserIt loads on every protected page and collects data
DetectorCloud-based, scores risk from Sensor and Enforcer data using machine learning and behavioral analyticsIt receives data from both sides, and you know what happens when it is slow
EnforcerA lightweight module on your web app, load balancer or CDN that carries out enforcementIt covers every route and origin that matters

HUMAN's docs say that for each activity, the Enforcer sends an async request to the Detector. That detail drives the timeout question later in this post. A Sensor without an Enforcer collects data but stops nothing. An Enforcer without a working Sensor leaves the Detector with less browser evidence to score.

Assign an owner to each part. Frontend or tag-management teams usually own the Sensor snippet. Platform or DevOps owns the Enforcer. Security owns the policy and the console. Unowned parts are where deployments rot.

Inventory protected routes and client types before go-live

Write the route and client inventory before anyone touches enforcement settings. Getting started typically involves mapping your application and its activity. That mapping goes faster, and your later checks mean more, when you arrive with a list.

Build the list in two columns.

Routes: login, signup, password reset, checkout, search, product or article pages, pricing, public APIs, internal APIs called by your own apps, webhook receivers, feeds and sitemaps. Mark each as browser-driven, API-driven or both.

Client types: desktop and mobile browsers, native mobile apps (HUMAN points to its SDK docs for the mobile Sensor), partner integrations, payment provider callbacks, uptime monitors, your own QA automation, and search or AI crawlers you intend to admit.

Then mark which routes can never show a challenge. A JSON API called by your mobile app can't render an interstitial page. If your inventory shows a route like that, find out in advance how the module you chose handles it. Don't learn it from support tickets.

The inventory also becomes your test plan. Every row is a test case for the checks below.

Check sensor delivery, CSP and origin coverage

HUMAN's Sensor is fetched by a JavaScript snippet that you add to the site. The same page says that after a few hours your Bot Defender dashboard should show data arriving from the Sensor. An empty dashboard after that window is a failed deployment, not a slow one.

Run these checks in order:

  1. Page coverage. Load a sample of each template from your inventory in a clean browser profile and confirm the snippet fires. Single-page apps and pages served by a separate checkout domain are the usual gaps.
  2. Tag-manager and cache behavior. If the snippet goes in through a tag manager, confirm it loads before the user can act on login and checkout. If a CDN caches HTML, confirm the snippet survives in the cached copy.
  3. CSP. If you send a Content-Security-Policy header, the Sensor script and its network calls must be allowed by it. Test with the browser console open and look for blocked script or connect violations. Check HUMAN's current documentation for the exact domains and directives your integration needs. Don't copy them from an old ticket.
  4. First-party delivery. Some integrations can proxy sensor requests through your own domain, which helps when ad blockers or browser restrictions interfere with cross-domain calls. The endpoint and timeout settings differ by module, so read the Enforcer docs for yours.
  5. Origin coverage. List every hostname that can reach your application: the www host, the API host, the staging host that is accidentally public, and the raw origin IP. If traffic can bypass the layer where the Enforcer runs, it bypasses enforcement. Confirm the origin only accepts traffic from your CDN or load balancer.

If your front door is Nginx or HAProxy, our guides on Nginx real IPs and safe rollout and HAProxy stick tables and rate limits cover the client-IP and rollout mechanics that decide whether any Enforcer sees the true visitor address.

Verify challenge handling, legitimate automation and rollback

Test the unhappy path before the happy one. A deployment that blocks bots but also blocks your payment webhook is a worse day than the bot problem.

Challenges. For each browser route, confirm a challenged real user can complete the flow and land where they intended. For each non-browser route, confirm what the client receives and whether your own app can parse it. An HTML challenge page returned to a JSON client breaks the client in ways that look like an outage. We cover that failure pattern for another vendor in Cloudflare API challenge: diagnose HTML instead of JSON. The diagnosis steps transfer.

Legitimate automation. List every automated client you want to keep: uptime checks, payment and shipping webhooks, partner feeds, your QA suite, search crawlers. For each, decide how it will be identified and what the policy is. Test one of each class. Don't widen exceptions by IP range when a narrower rule works.

Rollback. Write down, before go-live, who can switch the Enforcer out of blocking, how long that takes, and whether it is a config change or a deploy. Rehearse the switch once in staging. A rollback nobody has practiced is a plan on paper.

Finally, define success as completions, not blocks. Login success rate, checkout conversion and API error rate should hold steady while suspicious traffic drops.

Timeouts, failure behavior and monitor versus active blocking: confirm per module

Don't assume one set of defaults across all HUMAN integrations. Failure behavior, timeout values and the name of the blocking switch are properties of the specific Enforcer module you run, whether that is a CDN integration, a web server module or an application SDK.

Here is what to confirm in the official Enforcer documentation for your module:

  • Mode. HUMAN describes monitor and active blocking modes. Find the exact setting name for your module, its shipped default and where it is set. Some modules use a mode string, others a boolean. Confirm it matches what you believe production is running.
  • Detector call timeout. HUMAN's overview says each activity triggers an async request to the Detector. Find the timeout on that call and what the module does when it expires: allow the request, block it, or fall back to a cookie-based decision. Read this as documented behavior for your module, not a general truth.
  • Sensor delivery timeout. If you use first-party sensor delivery, find its timeout and endpoint settings.
  • Failure under load. Ask what happens during a Detector outage or a regional network issue. Test it in staging by blocking egress from the Enforcer to HUMAN and watching what real users experience.

Also confirm who is in the loop. Establish clear expectations around calibration and when you will be notified that initial tuning is complete. Ask for the date you should expect that notification. Keep the Enforcer in monitor mode until it arrives and your own route tests pass.

If you want a structured way to prove a vendor out before enforcing, our bot protection proof of concept guide lays out the test design.

Where Centinel fits beside an existing CDN or Enforcer

Centinel Analytica is bot and AI crawler protection that tells real visitors from scrapers that look like them, then applies allow, challenge or block policy through your existing CDN or edge. It works alongside Cloudflare, CloudFront, Akamai and Fastly, and your CDN or WAF stays in place.

That makes it relevant in two situations for a team running HUMAN. First, you're in an evaluation and want a second opinion on traffic your current setup treats as clean. Second, your main exposure is crawler traffic. On a typical news site, Centinel's published research found 84% of requests claiming to be GPTBot were fake. If your policy admits "verified" crawlers by user agent, check that claim.

The practical step is the same either way: run your route and client inventory against the traffic you actually receive.

Run the inventory, then book the audit

A PerimeterX or HUMAN deployment is only as good as the checks behind it: routes mapped, Sensor and CSP verified, origins closed, automation exempted narrowly, and module-specific failure behavior read from the official docs. Do those first. Then see what your traffic looks like from the outside.

Frequently asked questions

Is PerimeterX the same as HUMAN Bot Defender?

Yes. HUMAN and PerimeterX announced a merger on July 27, 2022. Older config keys, contracts and documentation may still say PerimeterX or px. Map those names to current HUMAN assets in your runbook so new team members are not confused by the mix.

How do I know the HUMAN Sensor is working on my site?

HUMAN's getting-started guide says your Bot Defender dashboard should show Sensor data a few hours after the snippet goes live. Also load each page template in a clean browser, check the console for CSP violations, and confirm the snippet appears in cached HTML.

What happens if the HUMAN Detector is slow or unreachable?

It depends on the Enforcer module. HUMAN says each activity triggers an async request to the Detector, but timeout values and the allow-or-block fallback are documented per integration. Read your module's official docs, then test in staging by cutting the Enforcer's connection to HUMAN.

Should I start in monitor mode or active blocking?

HUMAN describes both modes, and its getting-started guide has the Enforcer set to active blocking or monitor after tuning. Starting in monitor lets you compare flagged traffic against your route inventory before any user is affected. Confirm the exact setting name and default for your module in HUMAN's Enforcer docs.

Can Centinel Analytica run beside a CDN or existing bot product?

Centinel Analytica works alongside Cloudflare, CloudFront, Akamai and Fastly, and applies allow, challenge or block policy through your existing CDN or edge, so your CDN or WAF stays in place.