Skip to main content
The spending and request limits an agent is most likely to hit.

Spending

Every payment is checked against all three, and the tightest one declines it. A payment above the daily cap or the per-payment limit is declined outright, however much budget is left. The per-payment limit is checked when the agent submits the payment, and again when the payment’s funds are reserved, at the conversion rate in force then, so a rate change in between can decline a payment that was within the limit at submit. This holds for fixed-price payments and for payments the merchant charges by metered usage. To spend beyond them, a person pays directly. Revoking an agent’s identity stops it immediately, with no grace window. See Pause or revoke an agent. The two Anchorage limits are separate controls, and both apply to every payment: the daily cap bounds what an agent spends across a UTC day, and the per-payment limit bounds any one payment. The daily cap is checked per request against the agent’s running total for the day, so the two controls bind in different places. A payment over the per-payment limit is declined even on an agent that has spent nothing that day, and a payment within the per-payment limit is declined by the daily cap once that day’s total is already close enough to it. A payment that would go past the agent’s budget cap is declined with budget_limit_reached, or on inference with payment_declined; the per-payment limit sits above budgets and holds either way.

Requests

A few steps around connecting and paying are rate-limited:
  • Registering an MCP client and revoking a token are rate-limited: repeated registration or revocation attempts are refused once they arrive faster than the limit allows. A normal connect — one registration, one consent — stays well inside the limit. A request that hits this limit comes back as a standard HTTP 429 with a Retry-After header and the X-RateLimit-Limit, X-RateLimit-Remaining, and X-RateLimit-Reset headers, so a client can wait exactly as long as the response asks and then retry.
  • Getting or refreshing an access token is limited per network address. After about 100 token requests in a minute from one address, further token requests from that address through the same entry point get HTTP 429 for up to three minutes. The count is approximate and is kept separately for each entry point to the service, so don’t rely on an exact threshold. Clients that share a network address share the limit. A client that refreshes its token when it expires uses one request an hour.
  • The first time an agent pays a site that no merchant in the catalog covers yet counts against that agent’s limit. Once a catalog merchant covers a site’s domain name, calls to any URL on it, including a new path or a path with a new id in it, don’t count against this first-contact limit. A site not yet in the catalog, including one your agent’s own first payment added, counts each new URL the first time it is paid. A site addressed by IP address, or by a name that isn’t a full domain name, counts each new URL that doesn’t fit a URL pattern the catalog already lists for that site. Several calls to a new site at the same moment can each count before the first one finishes. A payment tool call that hits this limit returns an error naming the limit; retry shortly.
  • Paying a URL is rate limited per agent. An agent can count on a burst of at least 300 requests to pay a URL, then at least 5 a second. A request counts even when the URL turns out to be free. A request over the limit is stopped before anything is fetched or paid, with an error naming the limit. Wait a moment and send the same request again with the same idempotency key.
  • Minting API keys is rate limited per user. You can mint many keys in quick succession, and once that allowance is spent, further mints are refused for a short while.
  • Typed judgments are rate limited per agent and across all callers, and too many requests waiting on a slow provider are refused too. A request over the limit gets HTTP 429; retry shortly. See Typed judgments.
  • Every request body is capped at 2 MiB, except the inference routes in the table above. Images sent inline count toward an inference request’s limit. A request that declares a body larger than its cap is refused before it reaches the requested action, with a 413, or with a 400 on an inference route (invalid_request, or the error type invalid_request_error on POST /v1/messages), and nothing is charged. An inference request under its cap but larger than the model provider accepts returns a 413 request_too_large (the error type on POST /v1/messages), and nothing is charged unless the response names a transaction. Anchorage retries a failed delivery to the provider for an inference request up to 10 MiB that doesn’t stream; a streamed request, or a larger one, is sent at most once. If it fails after it was sent, resending it with the same Idempotency-Key returns payment_in_progress or already_paid and doesn’t send it again; check the transaction the error names, then send the request with a new Idempotency-Key for another completion. If the error instead tells you to resend the identical request, nothing was sent yet, so do that. Another protection, such as cross-origin request blocking, can refuse a request first. A request sent without a declared size — for example, chunked transfer encoding — that turns out to exceed the cap is refused once the cap is hit while reading it.