Network Asset (USDC) PayTo address
eip155:1329 - SEI 0xe15fC38F6D8c56aF07bbCBe3BAf5708A2Bf42392 0x3803A19280DeeFe533D177C4A169412BD341101b
eip155:8453 - Base 0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913 0x3803A19280DeeFe533D177C4A169412BD341101b
eip155:42161 - Arbitrum 0xaf88d065e77c8cC2239327C5EDb3A432268e5831 0x3803A19280DeeFe533D177C4A169412BD341101b
eip155:56 - Binance Smart Chain 0x8AC76a51cc950d9822D68b83fE1Ad97B32Cd580d 0x3803A19280DeeFe533D177C4A169412BD341101b
solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp - Solana EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v sLJ4uneGcD1mg6hKtkLYsY5HCw1nJ8GpNAmbzBWPBgk
x402 facilitators: x402.dexter.cash Coinbase x402 PayAI
Contacts: info@allai.pw
Domains: x402helper.xyz nginx402.com
What is x402 and how it works

x402 is an open payment standard that lets you sell access to content or the output of a website or server right inside a regular HTTP request. You can sell anything your server can return on request: API responses, computation results, text or image generation, database access, reports, analytics, files, streams - anything worth monetizing per call.

The standard is built around the old 402 Payment Required response code, which has existed in the HTTP specification for decades but was rarely used. x402 brings it back to life: a server can now tell a client "pay, and you'll get the response" - with no accounts, API keys, or sessions.

If you're a seller, x402 lets you charge micropayments for every request to your API. If you're a buyer - a human or an AI agent - you can automatically pay for access to paid resources without signing up or entering card details.

How it works: the flow, seller & buyer guide, MCP, links

How It Works: The Flow

On the client side, everything happens in a stream of two HTTP requests to the server - the first specifies the desired item and receives an invoice with payment details, the second sends the signature to pay:

Step 0. How the client knows what's for sale. Loosely speaking, x402's "documentation" is the server's own response. In the basic scenario, the client doesn't know the price or the endpoint schema in advance: it makes a request and receives a 402 with machine-readable terms. That's enough for an agent to decide. Optionally, a server can publish a discovery manifest - for example, a listing in Bazaar or at /.well-known/x402 - so agents and aggregators can find paid resources and learn the price before the first request. But this is an option, not a protocol requirement: even without a manifest, any client can start with a regular request.

Step 1. Request without payment. The client (an AI agent or your application, for example) sends a regular HTTP request to a payment-protected endpoint. The request contains no payment data.

Step 2. The server responds with 402 Payment Required. The server checks that the request hasn't been paid and returns a 402 response. That response contains machine-readable payment terms: the price of the request, the token and network you can pay in, the wallet address that should receive the funds, and how long the offer is valid.

Step 3. The client signs the payment. The client creates a payment authorization and signs it with its wallet. On EVM networks, a mechanism like EIP-3009 is typically used, which lets you authorize a token transfer with a signature - without sending a separate transaction or paying gas.

Step 4. The client repeats the request with the signature. The signed authorization is attached to the original request in the PAYMENT-SIGNATURE header, and the request is sent again.

Step 5. The server verifies and settles the payment. The server can verify the signature and complete settlement itself, or use a facilitator - a service that handles verification and on-chain settlement. The facilitator doesn't hold the buyer's funds and can't change the amount or the recipient: it only relays a transfer the buyer has already signed.

Step 6. The client receives the response. If the payment goes through, the server returns the requested resource. If the upstream request fails (4xx/5xx), settlement is skipped and the buyer doesn't pay.

What the Seller Gets

If you run a server that sells responses via x402, you can:

  • Charge for every request to your resources - no subscriptions, no minimum thresholds.
  • Accept micropayments - down to fractions of a cent per call, which makes selling individual responses or small data fragments economically viable.
  • Skip managing buyer accounts and API keys: payment is built into the HTTP request itself.
  • Accept payment in stablecoins (most often USDC) on networks like Base, Solana, Polygon, and others; the standard isn't tied to a single network.

What you need to start selling:

  1. An HTTP server with your API or the logic that returns responses.
  2. A wallet (an EVM address or an address on a supported network) to receive payments.
  3. An x402 middleware or SDK for your stack (implementations exist for Express, Fastify, Go, and others).
  4. Optionally, a facilitator for payment verification and settlement. The official docs call it optional but recommended: it saves you from running your own crypto infrastructure.

Bonus: selling MCP tools. If your server exposes not only HTTP endpoints but also MCP tools, x402 works there too. The cycle is the same - the client calls a tool without payment, the server returns a payment requirement, the client signs and repeats the call, and the tool executes. The only difference is the "packaging": MCP message fields are used instead of HTTP headers. For a seller, this means the same wallet and the same pricing logic can serve both REST clients and AI agents connected over MCP.

What the Buyer Gets

If you want to automate your processes or delegate tasks to an agent - teach it to handle 402, and you'll be able to:

  • Call paid APIs without signing up, without a card, and without issuing API keys.
  • Pay only for what you requested - one call, one response, one micropayment.
  • Delegate payment to an AI agent: the agent handles the 402, signs the payment, and repeats the request, provided it has access to a wallet and a budget.

If your agent works over MCP. Agents connected to tools via the Model Context Protocol (Claude Desktop, Cursor, and others) can buy tool calls using the same logic. The MCP client calls a tool, the server returns an error with a payment requirement, the client signs the payment and repeats the call. From the buyer's perspective, the only difference is the "packaging": MCP message fields are used instead of the PAYMENT-REQUIRED / PAYMENT-SIGNATURE HTTP headers. If you've already given your agent a wallet and wired up an x402 client for HTTP, MCP tools need an x402-compatible MCP server - such as payclaw or an equivalent - that handles the payment requirement and signing.

What you need to start buying:

  1. A wallet that supports the right network and token (for example, an EVM wallet with USDC on Base, or a Solana wallet with USDC). A private key or signing access.
  2. An x402 client library or wrapper for your language (TypeScript, Python, Go, etc.) that can intercept a 402, sign the payment, and retry the request.
  3. Budget awareness: you (or your agent) set limits on how much you're willing to pay per request or per period.

To teach your agent to buy:

  1. Give the agent a wallet with a small USDC balance on a supported network.
  2. Wire the x402 client into the HTTP client your agent uses: the library will automatically handle the 402, sign the payment, and retry the request.
  3. Set budget limits on the wallet or client side so the agent can't spend more than allowed.

Key Things to Remember

  • x402 is not a blockchain or a token. It's a set of rules and message formats on top of HTTP. Payments are made in stablecoins over existing networks.
  • The standard is open and governed by the Linux Foundation. It's backed by Coinbase, Cloudflare, AWS, Google, Visa, Mastercard, and others.
  • Retries are safe: payment authorizations are single-use, and the payment-identifier extension lets a client retry a request without double-paying for a limited time (typically up to 15 minutes).

Useful Links

MCP server · Model Context Protocol tools
endpoint: /mcp X402 Helper MCP – Glama score

This server also exposes an MCP endpoint - AI agents (Claude, Cursor, etc.) can discover and call endpoints as native tools.

Add to Claude Desktop / Cursor:
{
  "mcpServers": {
    "x402helper": {
      "url": "https://x402helper.xyz/mcp"
    }
  }
}

universal x402 endpoint

Ask anything - get structured data.
One API, any request, paid by microtransactions.

describe what you need → pay with USDC → get structured data

Register your API endpoints

Add your paid endpoints to x402 bazaar so AI agents can discover them via x402 / A2A.

Live Tests · X402 flow networks: eip155:1329 eip155:8453 eip155:42161 eip155:56 solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp
Click a button to send request...
All available routes · payments & free endpoints based on /.well-known/x402.json
Endpoint & methodDescriptionPrice / assetNetwork details
Loading configuration from x402.json...
Network Asset (USDC) PayTo address
eip155:1329 - SEI 0xe15fC38F6D8c56aF07bbCBe3BAf5708A2Bf42392 0x3803A19280DeeFe533D177C4A169412BD341101b
eip155:8453 - Base 0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913 0x3803A19280DeeFe533D177C4A169412BD341101b
eip155:42161 - Arbitrum 0xaf88d065e77c8cC2239327C5EDb3A432268e5831 0x3803A19280DeeFe533D177C4A169412BD341101b
eip155:56 - Binance Smart Chain 0x8AC76a51cc950d9822D68b83fE1Ad97B32Cd580d 0x3803A19280DeeFe533D177C4A169412BD341101b
solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp - Solana EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v sLJ4uneGcD1mg6hKtkLYsY5HCw1nJ8GpNAmbzBWPBgk
x402 facilitators: x402.dexter.cash Coinbase x402 PayAI
contacts: info@allai.pw