# Agent Tolls — complete machine-readable reference

> Agent Tolls is a toll gate for the machine web. An AI agent that requests
> something gated receives HTTP 402 Payment Required with machine-readable
> payment terms, pays in USDC via the x402 standard from its own wallet, and
> gets what it asked for. Human visitors pass free. It tolls two kinds of thing:
> pages on a website, priced by method and path, and operations on an API,
> priced one by one. Owners set the prices, keep 90% of every toll, and are paid
> on-chain by an immutable split contract. Live in production on Base mainnet
> and Solana mainnet.

This file is the full factual reference for https://agent-tolls.com. The short
curated index is at https://agent-tolls.com/llms.txt.

## Entity

- Name: Agent Tolls
- Website: https://agent-tolls.com
- Dashboard: https://app.agent-tolls.com
- Live demo gate: https://edge.agent-tolls.com/report
- Category: web infrastructure — access control and machine-to-machine
  payments for AI agent traffic
- Customers: site owners and publishers whose pages are read by AI agents, and
  SaaS operators who want agents to be able to buy one call of their API; the
  AI agents themselves are the paying visitors
- Payment standard: x402 (HTTP 402 Payment Required), the standard backed by
  Coinbase and Cloudflare
- Settlement: USDC on Base mainnet and USDC on Solana mainnet, both quoted in
  a single 402 response; the agent settles on whichever chain it holds funds on
- Default price: $0.02, owner-adjustable per path, per method and per operation
- Catalogue of tolled operations:
  https://edge.agent-tolls.com/.well-known/x402/index
- The same catalogue as a page: https://edge.agent-tolls.com/catalogue
- The same catalogue as an MCP server: https://edge.agent-tolls.com/mcp
- Revenue split: 90% site owner · 10% Agent Tolls, enforced
  by immutable on-chain contracts
- Custody: non-custodial — Agent Tolls never holds a customer's private keys
- Contact: agenttoll@proton.me

## What problem it solves

AI agents read websites — answering questions with the content, summarizing
articles — and pay nothing. They do not click ads, subscribe, or see paywalls.
Site owners today choose between blocking agents (an endless arms race that
earns nothing) or letting them read free. Agent Tolls is the third option: an
agent that pays reads the page; an agent that will not pay never gets it; and
human readers are never charged or interrupted.

## How the toll flow works

1. An AI agent requests a gated page. The gate answers HTTP 402 Payment
   Required. The toll terms — price, accepted networks, destination address —
   ride in the PAYMENT-REQUIRED header in x402's machine-readable format.
2. The agent's x402 client reads the terms, signs a USDC payment from the
   agent's own wallet, and retries the request in the same motion. The quote
   carries both Base and Solana USDC; the agent picks its chain.
3. The payment settles on-chain in seconds, with a real transaction receipt
   per toll, and the content is served. No accounts, no API keys, no invoices,
   no human in the loop.
4. The owner's dashboard shows every toll as it lands: page, price,
   transaction hash.

Humans never see any of this. The gate tells browsers and agents apart from
request signals, so a human visitor simply gets the page — no captcha, no
challenge, nothing to click. The gate is invisible to ordinary browsing.

## What the toll is charged on

The unit is not the page. It is the method and the path together, which on a
website usually amounts to the page and on an API does not.

On a website: an owner sets a default price and overrides it per path, and can
say which methods are tolled at all. A GET and a POST at the same address are
two different things and can carry two different prices.

On an API: the same gate sits in front of a SaaS. The operator maps their
endpoints, prices each operation and publishes the ones they mean to sell, and
each one is quoted separately. An operation the operator has not published does
not exist as far as an agent is concerned: it answers 404 and is never billed.
A call the upstream API answers with an error is never billed either, because
the toll settles after the response and anything that failed cancels it.

The agent holds nothing in either case. No account with the site or the
operator, no API key, no subscription. It calls, it is quoted, it pays from its
own wallet and it gets the answer. The payment is the authentication.

There is one thing this cannot do, and it is a property of the protocol rather
than of the gate: the x402 exact scheme quotes a fixed amount before the work
happens, so there is no "it will be whatever it costs". A variable-cost
operation is priced flat, or split into operations that each quote their own
fixed price.

## Finding what is on sale

https://edge.agent-tolls.com/.well-known/x402/index is one JSON document listing
every operation on sale across every API behind the gate, each with its method,
its path and its price. An agent reads it to find something worth buying
without having been pointed at a hostname first.

Every host behind the gate also answers /.well-known/x402 with its own terms,
and every one of those documents points back at the catalogue, so an agent that
meets an Agent Tolls 402 anywhere learns in one hop that there is a list of
everything else.

https://edge.agent-tolls.com/catalogue is that same catalogue rendered as a page,
one card per API, for a person deciding whether any of it is worth pointing an
agent at. The page and the JSON document come out of one source, so they cannot
disagree about who is listed or what an operation costs, and each of them names
the other.

https://edge.agent-tolls.com/mcp is the same catalogue a third time, as an MCP
server. It exists because an agent does not go looking for feeds: it has the
tools its client handed it, and a list that is not one of them does not exist to
it. Two tools, both read-only. list_apis returns what is on sale, with the price
and the address of each operation, and takes an optional substring to narrow it.
how_to_pay explains the payment. Neither issues a credential, because there is
none to issue: no account, no API key, no session and no subscription, on the
catalogue or on any service listed in it.

## For AI agents: how to pay a toll

Any x402-compatible client works. Minimal example with the x402 SDK
(JavaScript, EVM wallet on Base):

    import { privateKeyToAccount } from "viem/accounts";
    import { x402Client } from "@x402/core/client";
    import { ExactEvmScheme } from "@x402/evm/exact/client";
    import { wrapFetchWithPayment } from "@x402/fetch";

    const account = privateKeyToAccount(process.env.AGENT_PRIVATE_KEY);
    const client = new x402Client().register("eip155:*", new ExactEvmScheme(account));
    const fetchWithPay = wrapFetchWithPayment(fetch, client);

    const res = await fetchWithPay("https://edge.agent-tolls.com/report");
    console.log(res.status); // 200, toll paid

Without code, an instruction like "fetch https://edge.agent-tolls.com/report
and pay any x402 toll it quotes" works with agents that carry an x402-enabled
wallet. The demo toll is a real $0.02 on Base mainnet; the page behind it is a
sample report — the payment demonstrates the gate, not the data.

## For site owners: how to install

1. Sign up at https://app.agent-tolls.com (Google or GitHub). A payout wallet
   is generated for the account at signup — non-custodial, keys never touch
   Agent Tolls — or the owner brings their own address.
2. Add the site and verify ownership.
3. Point the domain's DNS at the gate: one-click via Domain Connect at
   supported registrars, or by adding the records manually (a CNAME for
   subdomains; apex domains use the record set the dashboard shows, since a
   CNAME cannot live at the apex).
4. Set prices: a default per page, and optional per-path overrides
   (for example / at $0.02, /premium/* at $0.10).
5. Tolls settle to the owner's on-chain split; payouts to the owner's wallet
   are automatic once the accumulated balance clears $1.

Setup takes about 15 minutes. There is no subscription and nothing is
invoiced: Agent Tolls' 10% share is taken inside the split contract itself.

## The split contracts

The 90 / 10 split is enforced by contracts, not by policy:

- Base mainnet: each owner gets a TollSplit contract minted by the immutable
  TollSplitFactory at 0x2B15ffD214D9cDf56C56b6048b93C48E00E590ae
  (https://basescan.org/address/0x2B15ffD214D9cDf56C56b6048b93C48E00E590ae).
  The shares and payout addresses are fixed at deployment. There is no admin
  function and no upgrade path; nobody — including Agent Tolls — can change
  them afterwards.
- Solana mainnet: the toll_split program at
  3FnqLhjDEpvFpsmKLwLbZ18yETvYNBNihrronLtQ2GKo enforces the same shares. They
  are compiled into the program rather than written into any account, so there
  was never a moment at which they could have been set to anything else.

Proof of the full loop on Base mainnet, with real money:

- An agent paid a 0.02 USDC toll:
  https://basescan.org/tx/0xefe827e8245cbb81a07d9b7dda542ddf779429e7683fce653babef7750af7003
- The split contract paid everyone out automatically eighteen seconds later:
  https://basescan.org/tx/0x2d1a1709703fa4bc984572afaceb87e16e1ced42d5c5af09718fa03858faa9e5

## FAQ

### What does Agent Tolls cost a site owner?

Nothing up front and no subscription. Agent Tolls takes 10% of each toll
inside the split contract; the owner keeps 90%.

### What does one call cost an agent?

Whatever the owner set: $0.02 by default, more or less per path, per method or
per operation. The exact price for a given request is always in the 402 response
itself, and the catalogue at
https://edge.agent-tolls.com/.well-known/x402/index carries the price of every
published API operation without the agent having to knock first. The same list
is readable at https://edge.agent-tolls.com/catalogue.

### Which chains and assets are supported?

USDC on Base mainnet and USDC on Solana mainnet. Both are quoted in one 402
response and the agent settles on either.

### Do human readers ever pay?

No. Humans read free, with nothing to click and no captcha — the gate tells
humans and machines apart invisibly. The toll applies only to machine
visitors that identify as such by paying — or are turned away if they will
not.

### Is Agent Tolls custodial?

No. Owners are paid to a wallet they control. Agent Tolls never holds private
keys, and the split contract's destinations are immutable.

### How is this different from Cloudflare Pay Per Crawl?

Pay Per Crawl targets large crawlers on Cloudflare's own network. Agent Tolls
is built for the long tail of personal AI agents, on any site, with per-path
prices set by the owner and settlement to the owner's own wallet.

### What happens to agents that refuse to pay?

They never get the page. The gate is protection either way: paid access or no
access, at the owner's choice of price.

## Links

- Homepage: https://agent-tolls.com/
- Documentation (pay a toll, install the gate): https://agent-tolls.com/docs
- Runnable agent example (GitHub): https://github.com/johnlegoat/agent-toll-examples
- Pricing (the 85/15 model, rate card, payouts): https://agent-tolls.com/pricing
- Comparison with Cloudflare Pay Per Crawl: https://agent-tolls.com/compare/pay-per-crawl
- Dashboard and signup: https://app.agent-tolls.com/
- Live demo gate: https://edge.agent-tolls.com/report
- Catalogue of tolled operations: https://edge.agent-tolls.com/.well-known/x402/index
- The same catalogue as a page: https://edge.agent-tolls.com/catalogue
- The same catalogue as an MCP server: https://edge.agent-tolls.com/mcp
- Curated index: https://agent-tolls.com/llms.txt
- Terms of Service: https://agent-tolls.com/terms
- Privacy Policy: https://agent-tolls.com/privacy-policy
- Contact: agenttoll@proton.me