← All guides · Published November 14, 2026 · Reviewed November 14, 2026 · By the Ingenious AI team · 7 min read

How Do Path Rules Protect Checkout, Login and Admin Pages from AI Agents?

The short answer: path rules attach decisions to places instead of only to agents. An AgentBlock policy holds up to 50 path rules — each a path pattern, a set of agents (or all), and an action of block or allow — and the generated Worker evaluates them per request, logging refusals as BLOCK with the rule named. That is how a retrieval agent stays welcome on your articles and unwelcome on your checkout, login, admin, account and preview paths, where no outside agent has legitimate business.

Build my block kit — free · Test a policy in the simulator first

What is an AgentBlock path rule?

a policy entry matching a path pattern (with wildcards) to an action — block or allow — for a named set of agents or all agents. A policy holds up to 50 rules; the Worker checks them per request and logs path-rule refusals with the rule identified, making private-area fencing auditable.

Identity is not the only axis

Most crawler thinking stops at 'which agents'. But risk lives at the intersection of agent and place. ChatGPT-User fetching your pricing page is distribution; the same agent fetching your password-reset or checkout-confirmation paths is an incident looking for a date. Meta's fetcher documentation made the same point from the other side: user-triggered fetches happen 'on a user's behalf', which is precisely why the paths a user would never legitimately delegate deserve fencing regardless of who asks.

Path rules are the second axis. AgentBlock's policy builder accepts them as structured entries — pattern, agents, action — cleans and caps them (patterns trimmed to 200 characters, up to 30 agents per rule, 50 rules per policy), and emits them into the Worker's path matrix, where a matching rule fires before the agent's general decision.

The five fences almost every site needs

Checkout and payment paths first: they carry order data, payment tokens and confirmation states that no crawler should touch. Login and password-reset paths second: agent traffic there is either a mistake or a probe, and both deserve a refusal with a log line. Admin and wp-admin paths third, for the same reason with higher stakes. Account and customer-data paths fourth. And preview, staging and internal-search paths fifth — the unpublished and the query-spelled URLs that leak structure.

Write each fence for all agents, not per vendor. The set of agents changes quarterly; the set of paths you consider private changes rarely. An all-agents fence on /checkout stays correct when a new retrieval agent appears in the next database version, which is exactly the maintenance property a good rule has.

Ordering, wildcards and the allow exception

Patterns support wildcards so /account/* fences the subtree in one rule instead of fifty. Rules can also allow: a documentation subtree inside an otherwise fenced area, or a partner agent excepted from a general fence for a monitored integration. Allow rules are where discipline matters — every exception should carry a reason in the policy note, because an unexplained allow is tomorrow's mystery during an incident review.

The simulator is the place to test the matrix before it ships. Feed it your key paths and it shows, per agent, the verdict each path draws under the draft policy — public article allowed, checkout refused, preview refused, link preview intact. Surprises are cheap in the simulator and expensive in production logs.

What the log proves afterwards

Path-rule refusals are logged with the rule named — the Worker's event records verdict BLOCK and rule 'path:' plus the pattern — so an audit can distinguish 'agent refused at the fence' from 'agent refused by identity'. In an incident review that distinction is the timeline: fences firing on /reset-password at 3 a.m. is a probe pattern worth escalating; the same count on /blog is a crawler ignoring its general block.

Evidence packs aggregate these per agent and path, which is how a client or an insurer gets a straight answer to 'did anything automated touch our payment pages?' — a count of refusals, with dates, rather than an assurance.

Fences are not authentication

The honest limit, stated because AgentBlock states its limits everywhere: path rules govern named agents under your crawler policy. They are not a substitute for real authentication, authorisation or a web application firewall. An attacker under a browser user-agent does not consult your path matrix. What the fences do is keep the identified, honest agent population — the one that includes user-triggered fetchers acting on someone's behalf — out of places it should never be, and prove they stayed out.

That scope is still valuable precisely because the agent population is growing and well-intentioned. Most future path incidents will not be attacks; they will be delegations — a user's agent fetching one link too deep. Fences written now, at leisure, decide those moments in advance.

Five actions to take today

  1. Fence checkout and payment paths for all agents. One wildcard rule per subtree; no exceptions without a written reason.
  2. Fence login, reset, admin and account paths. Agent traffic there is a mistake or a probe — refuse it and keep the log line.
  3. Fence preview and internal-search paths. Unpublished structure and query-spelled URLs should not be agent-readable.
  4. Test the matrix in the simulator. Run your key paths per agent before deploying; surprises belong in simulation.
  5. Review refusals by rule monthly. Path-rule BLOCK events are your probe detector — read them by pattern, not just by agent.

Worked example: a booking site fences its payment flow

Canopy Bookings, a fictional tour-booking site, allows retrieval agents on its 210 tour pages — AI answers are a growing enquiry source — but its payment flow lives under /book and /pay, its agent portal under /portal, and its reset flow under /reset. Six all-agent path rules fence those subtrees, plus /preview where next season's tours are drafted.

In the first quarter under the kit, the fences fired 318 times: 271 user-triggered fetches refused at /book/* — mostly users asking an AI to 'check my booking', which the fence correctly treated as account work, not content — 39 at /portal/*, and 8 at /reset.

Each refusal was logged with its rule, so when the company's payment provider ran a security review, Canopy produced the fence list and the refusal counts in one evidence export instead of describing its intentions.

Frequently asked questions

How many path rules can a policy hold?

Up to 50 rules per policy. Each rule carries a path pattern (up to 200 characters), up to 30 named agents or a wildcard scope, and an action of block or allow — enough for a considered fence set on any small or mid-sized site.

Do path rules override an agent's general decision?

The Worker evaluates the path matrix per request, so a rule can refuse an otherwise-allowed agent on a fenced path, or allow an otherwise-blocked agent on a specific path where you have a reason. The simulator shows the combined result per path before you deploy.

Should fences name agents or apply to all?

Apply privacy fences to all agents. Your private paths stay private regardless of which new agents the next database version adds, while agent-specific rules are better kept for the public-content decisions that genuinely differ per vendor.

Can path rules protect against hackers?

No — and AgentBlock does not claim otherwise. Path rules govern the identified agent population under your crawler policy. Attackers spoofing browsers are a job for authentication, authorisation and a WAF; fences handle the honest, named, fast-growing agent traffic.

What does a path-rule refusal look like in evidence?

A structured event with verdict BLOCK and the rule identified as 'path:' plus the pattern, alongside agent, path and timestamp. Evidence tooling can therefore report refusals per fence, which is what an auditor or payment provider actually asks for.

Build my block kit — free · Browse the agent database

Related guides

HONEST SCOPE: this policy blocks KNOWN agent user-agents and behaviors listed below. Sophisticated spoofing can bypass any user-agent block (e.g. an agent sending a stock browser UA, or rotating residential IPs). This is a control, not a guarantee.
← Back