Skip to content
All systems operational0 AI providers monitored, polled every 2 minutes
Live status

x402

the open HTTP standard for agent payments

x402 revives the long-dormant HTTP 402 "Payment Required" status code as a machine-payable handshake. Servers gate APIs on USDC payment; agents pay on-chain in seconds. As of September 2026, the protocol is live infrastructure governed by the x402 Foundation: Amazon Bedrock AgentCore Payments, the Coinbase CDP Facilitator, AWS WAF, Pay.sh, TensorFeed, and TerminalFeed all speak it, with Stripe machine payments in preview. This page is the canonical hub. What x402 is, who uses it today, how to integrate, and the latest news, all in one place.

TensorFeed is x402-native

109 paid premium endpoints. End-to-end USDC loop verified on Base mainnet on April 27, 2026. AFTA-certified: code-enforced no-charge guarantees plus Ed25519-signed receipts on every paid call. Free tier remains free; pay only when you hit a premium endpoint.

Live: x402 settlement index

TensorFeed indexes every x402 USDC settlement on Base mainnet, auto-discovered via /.well-known/x402.json publisher manifests. Forward-only from 2026-05-28; cron refresh every 5 minutes. Pulled live from /api/x402-index/summary + /leaderboard.

Live: who speaks x402

The set is intentionally small. Live production publishers, canonical SDKs, deployable gateway templates, and the reference spec itself. Pulled live from /api/x402-adopters.

How it works in one round trip

Canonical Coinbase x402 V2 handshake on the exact scheme over an EVM network like Base. This is the wire format AgentCore Payments and the @x402/* SDKs speak.

  1. 1.Client requests a paid resource: GET /something
  2. 2.Server responds 402 Payment Required with body { x402Version, resource, accepts: [...] }. Each accepts entry lists scheme, network (e.g. eip155:8453), amount, asset, payTo, maxTimeoutSeconds.
  3. 3.Client signs an EIP-3009 transferWithAuthorization for the requested amount of USDC. Gasless on the agent side: the agent only signs; the server broadcasts.
  4. 4.Client retries with header X-PAYMENT set to base64 of { signature, authorization: { from, to, value, validAfter, validBefore, nonce } }.
  5. 5.Server's facilitator broadcasts the authorization to the network, verifies settlement, returns 200 with the data plus a PAYMENT-RESPONSE header containing the settlement receipt.

Why x402 wins: the four-property test

When TensorFeed picked an agent payment rail, we ran every credible option against four properties. x402 over USDC on Base is the only stack that hits all four. The full bake-off is in the AFTA companion piece on rail selection.

Open

Public spec, public reference implementations, no vendor approval gate. Anyone can read, fork, ship.

Transparent

Every payment is visible on a public block explorer. Server and client agree on the same on-chain truth.

Instantly final

On-chain confirm in ~2 seconds on Base. No reversals, no chargebacks, no 30-day settlement window.

Sub-cent

L2 gas plus stablecoin transfer is fractions of a cent. Microtransactions are economically viable.

Read the full bake-off

The x402 handshake on the wire

Conceptual example of the Coinbase x402 V2 exact scheme on Base. Field names match the spec at github.com/x402-foundation/x402.

1. Server responds 402 with the price
HTTP/1.1 402 Payment Required
content-type: application/json

{
  "x402Version": 2,
  "resource":    { "url": "https://example.com/article/42" },
  "accepts": [{
    "scheme":            "exact",
    "network":           "eip155:8453",
    "amount":            "20000",
    "asset":             "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
    "payTo":             "0x...",
    "maxTimeoutSeconds": 60
  }]
}
2. Client signs EIP-3009 and retries with X-PAYMENT
X-PAYMENT: <base64 of>
{
  "signature": "0x...",
  "authorization": {
    "from":        "0x<agent wallet>",
    "to":          "0x<payTo>",
    "value":       "20000",
    "validAfter":  "1714780000",
    "validBefore": "1714780600",
    "nonce":       "0x<32 bytes>"
  }
}
3. Facilitator settles, server returns 200
HTTP/1.1 200 OK
content-type:     application/json
PAYMENT-RESPONSE: <base64 settlement receipt>

{ ...the resource the agent paid for... }
To pay TensorFeed specifically, see /developers/agent-payments for the credits flow (recommended for repeat use) and SDK snippets for Python and JavaScript.

Recent x402 coverage on TensorFeed

V1 and V2: the format split

x402 has two coexisting formats in the wild as the protocol matures. V1 was the original Coinbase reference (network and asset declared as separate fields). V2 added the discovery manifest at /.well-known/x402 and the eip155-style network identifier (e.g. eip155:8453 for Base mainnet). x402scan currently lists V2 publishers; x402.org documents both. The cleanest path for new publishers is V2 with the well-known manifest, plus an x-payment-info extension on each paid OpenAPI operation. The afta-gateway template ships with both formats wired correctly out of the box.

FAQ

What is x402?

x402 is an open HTTP-native payment protocol that revives the long-dormant HTTP 402 Payment Required status code as a machine-payable handshake. Servers gate API responses on payment; clients retry with proof of payment. Designed for AI agents, machine-to-machine commerce, and any caller without a human in the loop. Reference spec at x402.org. Created at Coinbase, the protocol is now governed by the x402 Foundation under the Linux Foundation, and the canonical repo lives at github.com/x402-foundation/x402.

How does x402 work in one round trip?

Client requests a paid endpoint. Server responds 402 Payment Required with a JSON body containing x402Version, resource, and an accepts array (scheme, network, amount, asset, payTo, maxTimeoutSeconds). For the Coinbase reference exact scheme on EVM networks like Base, the client signs an EIP-3009 transferWithAuthorization (gasless from the agent’s side), wraps it as a PaymentPayload (signature plus authorization fields from, to, value, validAfter, validBefore, nonce), and base64-encodes the result. The client retries with header X-PAYMENT set to that base64 string. The server’s facilitator broadcasts the authorization, verifies on-chain settlement, and returns 200 with the data plus a PAYMENT-RESPONSE header containing the settlement receipt. No accounts, no API keys for billing, no signup form, no invoice cycle.

How does Coinbase Base MCP fit into x402?

Base MCP (mcp.base.org, launched May 2026) is Coinbase's official transact-side MCP server. It connects an agent to a Base Account and lets the agent propose swaps, transfers, and x402 payments that the user approves in-wallet. From an x402 perspective, Base MCP is the canonical agent-side wallet client: it handles the EIP-3009 signature, the X-PAYMENT header, and the per-payment maxPayment approval modal without the agent ever holding private keys. Discovery still happens upstream of Base MCP: the user or upstream agent supplies the endpoint URL, and Base MCP detects the x402 payment requirement by reading the 402 response. It does not crawl Bazaar or x402scan. On the publisher side, the merchant API still needs an x402-compliant /.well-known/x402 manifest and a canonical 402 Payment Required response. TensorFeed pairs with Base MCP cleanly: TF's premium endpoints publish a canonical V2 manifest, Base MCP signs the payment, and the @tensorfeed/x402-base-mcp verify MCP independently confirms settlement on-chain.

Who actually uses x402 today?

As of September 2026, the spec is governed by the x402 Foundation under the Linux Foundation, which launched operationally on July 14, 2026 with 40 members (premier members include AWS, Cloudflare, Coinbase, Google, Mastercard, Stripe, and Visa). Live adopters include the Coinbase CDP Facilitator (Base, Polygon, Arbitrum, World, and Solana; its x402 Bazaar discovery API listed 15,406 resources on September 14, 2026), the PayAI Facilitator, Pay.sh (Solana Foundation and Google Cloud), AWS WAF AI traffic monetization (launched June 15, 2026), Amazon Bedrock AgentCore Payments (generally available August 18, 2026), TensorFeed (AFTA-certified, payable on Base or Solana), and TerminalFeed (federated with TensorFeed via the AFTA cross-Worker rail). Stripe machine payments (x402) is in preview: a PaymentIntent issues a standard x402 exact challenge and Stripe captures once USDC settles on Base. Cloudflare has announced a Monetization Gateway with a waitlist open. SDKs include the foundation's @x402/* packages (successors to @coinbase/x402), the Cloudflare Agents SDK, and the tensorfeed Python and JavaScript SDKs; the afta-gateway Cloudflare Worker template and the tensorfeed-mcp server round out the list. Live adopter directory at tensorfeed.ai/x402-adopters.

Why x402 instead of Stripe or a traditional payment API?

Traditional payment APIs assume a human at a keyboard filling out a signup form, attaching a credit card, and copying an API key. AI agents have none of those primitives. x402 lets agents act on their own spending decisions in a single round trip, settling on-chain in seconds with no chargebacks, no merchant-account termination risk, and microtransactions that are economically viable (sub-cent gas on L2s like Base). Stripe itself now issues standard x402 exact challenges in its machine payments preview, settling USDC on Base, so the protocol is cooperative not adversarial.

What is the .well-known/x402 manifest?

In x402 V2, services that support the protocol publish a discovery manifest at /.well-known/x402 listing every paid endpoint with its accepts block (asset, network, amount, payTo), input/output schemas, and metadata. Facilitators like CDP Bazaar and x402scan crawl this manifest to auto-index services so x402-compatible agents can discover them without manual directory submission. TensorFeed publishes its manifest at /.well-known/x402.json.

What about V1 vs V2?

Two coexisting formats are in the wild as the protocol matures. V1 is the original Coinbase reference (network and asset declared as separate fields). V2 added the discovery manifest and the eip155-style network identifier (e.g. eip155:8453 for Base mainnet). x402scan currently lists V2 publishers; x402.org documents both. The cleanest path for new publishers is V2 with the well-known manifest plus an x-payment-info extension on each paid OpenAPI operation.

How do I add x402 to my own API?

Three options ranked by effort. Drop-in: fork github.com/RipperMercs/afta-gateway, set 3 secrets (Worker secret, USDC payTo wallet, Ed25519 receipt signing key), deploy. Library: install the x402 Foundation packages (@x402/core plus the Express, Hono, Fastify, or Next.js adapter) and add the middleware to your app. Hand-rolled: implement the 402 handshake yourself in ~50 lines, verify the X-Payment-Tx receipt against an RPC node. The afta-gateway template is the recommended path for any publisher who also wants AFTA primitives (signed receipts, code-enforced no-charge ledger).

For agents: machine-readable directory at /api/x402-adopters. Filter with ?category=publisher|sdk|gateway|reference|spec or ?status=live|announced. Free, no auth, cached 10 min. TensorFeed's own x402 manifest lives at /.well-known/x402.json.

Further reading