PaymentsExplainer

How Pakt puts limits on x402 payments by AI agents

x402 lets an agent pay per API call, but sets no limits. How Pakt checks each x402 payment before it is signed, and what the open beta and Anchorage pilot include.

X402 · PAID API CALLS · CAP $0.50 402 · $0.002 PAKT CHECK SIGNED 200 402 · $2.00 PAKT CHECK REFUSED · NOT SIGNED ONE PROOF PER PAYMENT RECEIPT FOR EVERY DECISION

An agent that does real work needs to buy things: a model call, a web search, a price feed. x402 lets it pay over plain HTTP. It requests a resource, gets a 402 Payment Required reply with the price, pays in USDC and retries. It needs no account, API key or invoice.

What x402 doesn't say is how much an agent may spend, or with whom. The protocol leaves that to whoever builds the wallet, which is why a mandate needs an enforcement point. Pakt is that enforcement point. Every x402 payment an agent makes is checked against rules its owner approved, and only a payment that passes is signed.

This article explains how that works, what the Pakt open beta includes, and how the Anchorage pilot uses it.

What x402 is, in one paragraph

HTTP has had a 402 status code since 1997. Nobody used it.

x402 gives it a job: when a client calls a paid endpoint without paying, the server answers 402 with a small object that says what it costs, which token, which chain and which address to pay. The client signs a transfer authorization for exactly that amount, retries the request with the signature in a header, and a facilitator settles the transfer on chain while the server returns the result. The whole exchange is two HTTP requests. There is no signup and no invoice.

For a human that is a curiosity. For an agent that calls a search API forty times an hour, it is the only payment method that fits.

How an x402 payment goes through Pakt

  1. The agent calls a paid API and gets a 402 with the merchant's terms: the amount, the token, the chain and who gets paid.
  2. It passes the challenge to Pakt unchanged, with the URL it was calling. It doesn't build or sign a payment itself.
  3. Pakt checks the terms against the owner's Pakt. Is this merchant and endpoint allowed? Is it the right token and chain? Is the amount under the per-payment cap? Does it fit the budget, given what the wallet has already spent?
  4. If every rule passes, Pakt builds the payment and signs it from the agent's wallet. If any rule fails, nothing is signed, and the agent gets a refusal that names the rule.
  5. The agent retries its original request with the signed payment header. The merchant settles it, and the agent records the settlement.

Three details matter.

Pakt builds the payment, not the agent. The agent never supplies the amount, recipient, expiry or nonce it wants signed. Pakt reads them from the merchant's terms, checks them and builds the signed authorization from them. A confused or prompt-injected agent can't get a signature on anything other than what was checked.

A retry can't pay twice. The payment's nonce is derived from the request. Sending the same request again produces the same authorization, and it settles at most once.

The budget counts real spending. Pakt counts what actually left the wallet on-chain, not what the agent reports. If it can't read the wallet's complete history for the budget window, it refuses the payment rather than guessing.

Pakt never contacts the merchant and never broadcasts anything. It returns a signed header, and the agent sends it.

Every decision, allowed or refused, comes with a receipt anyone can check: which Pakt decided, which rule applied, and a cryptographic proof that the check ran inside secure hardware.

What's in the open beta

The open beta gives everyone who signs up this experience, on their own account and with their own money.

  • An agent in the app. Sign in at usepakt.ai and you get an agent that researches, answers questions and can trade Hyperliquid perps within your trading Pakt's limits.

  • An agent wallet. Each account gets its own wallet for paying services, separate from the one that signs trades. You fund it with USDC on Base.

  • A default spending Pakt. New accounts start with a limit of $0.50 per payment and $5 per calendar week, paid in USDC on Base to three providers only:

    • BlockRun, for the AI model;
    • Exa, for web search and page contents;
    • Mycelia Signal, for market data.

    Each provider is bound to its own payee address and endpoints, and the AI model is fixed. A payment to anyone else, or an attempt to switch to a pricier model, is refused.

  • Every paid call goes through Pakt, including every model call. Each one appears as a card showing the rule, Pakt's decision, the outcome and the receipt.

Some of these providers don't accept calls straight from a browser. A small relay on usepakt.ai passes those calls through unchanged. It holds no keys and no funds, and it doesn't log what passes through.

How the Anchorage pilot uses it

The pilot with Anchorage Digital runs the same agent loop for an institution. An agent researches BTC, pays per call for data and AI, and trades within limits its owner approved. Here the custodian holds the money.

  • Anchorage Agentic Banking holds the funds and pays merchants over x402. It chooses the payment rail and enforces its own spending cap.
  • Pakt approves each paid request first. Before every paid call, the pilot asks Pakt whether the provider, model and price are allowed, and calls Anchorage's payment tool only after an allow. Each decision gets a receipt.
  • Trading goes through Pakt's full signing path. The Hyperliquid master account sits in Anchorage Porto, and Pakt signs only orders within the trading Pakt's limits.

The two set-ups show Pakt in two positions. In the beta, Pakt signs the payment itself. In the pilot, it approves each request in front of a custodian's own payment system. The rules and receipts are the same in both. The next step with custodians is a deeper integration, where the custodian's payment service requires Pakt's approval itself, rather than relying on the agent's application to ask.

What comes next

Pakt's payment path already supports more than the beta uses. These are built and in testing:

  • USDC on Arbitrum and Ethereum, USDT0 on Arbitrum, and USDT on Ethereum;
  • the Machine Payments Protocol (MPP), including payments on Tempo;
  • payments from the owner's own wallet to approved payees, such as vendors and invoices, including refilling the agent wallet.

Each uses the same pattern: the agent proposes, Pakt checks and builds, and only a payment that passes is signed.

Sources

Join the open beta.

Sign up and give your trading agent limits it can’t breach.

Join the open beta