Accept Payments From Agents

x402 turns HTTP 402 Payment Required into a payment handshake. Your service advertises price and settlement requirements, the agent signs a USDC authorization, and the facilitator verifies and settles it without accounts or API keys.

Demo

These samples use TypeScript @x402/*@2.21.0, Go x402/go/v2@v2.21.0, Python x402==2.18.0, and Base Sepolia (eip155:84532). The test facilitator is https://x402.org/facilitator.

Before a live test, query the facilitator’s /supported endpoint and confirm eth_getCode returns bytecode for the advertised asset and settlement contracts. Base Sepolia state and test assets can be reset independently of an SDK release.

Scheme	Use when	Settlement
`exact`	Price is known before work begins	Fixed advertised amount
`upto`	Final usage is known after work	Up to the signed maximum
`batch-settlement`	An agent makes many small calls	Cumulative vouchers claimed in batches

Return the payment requirements

Without a payment signature, middleware returns 402 with the supported scheme, CAIP-2 network, asset, amount, and receiver.

Verify the signed retry

The client selects a supported requirement, applies its local spend policy, signs, and retries with PAYMENT-SIGNATURE.

Run the protected handler

Middleware verifies the payload before invoking your code. upto and batch-settlement can set the actual charge on the successful response.

Settle through the facilitator

Exact and upto settle per request. Batch settlement stores the latest voucher and periodically claims, settles, or refunds channels.

Accept a fixed-price payment

Charge a known amount before returning the resource.

app.use(paymentMiddleware({
  "GET /fixed": {
    accepts: [{ scheme: "exact", price: "$0.01", network, payTo }],
    description: "Fixed-price market report",
    mimeType: "application/json",
  },
}, resourceServer));
app.get("/fixed", (_request, response) => response.json({ report: "Base market summary" }));

routes := x402http.RoutesConfig{
	"GET /fixed": {
		Accepts: x402http.PaymentOptions{{Scheme: "exact", Price: "$0.01", Network: network, PayTo: payTo}},
		Description: "Fixed-price market report", MimeType: "application/json",
	},
}
mux := http.NewServeMux()
mux.HandleFunc("GET /fixed", func(w http.ResponseWriter, _ *http.Request) {
	_ = json.NewEncoder(w).Encode(map[string]string{"report": "Base market summary"})
})

routes = {
    "GET /fixed": RouteConfig(
        accepts=[PaymentOption(scheme="exact", price="$0.01", network=network, pay_to=pay_to)],
        description="Fixed-price market report",
        mime_type="application/json",
    )
}


@app.get("/fixed")
async def fixed() -> dict[str, str]:
    return {"report": "Base market summary"}

Settle a usage-based payment

Advertise a maximum, then settle the actual usage after the handler succeeds.

app.use(paymentMiddleware({
  "GET /metered": {
    accepts: [{ scheme: "upto", price: "$0.10", network, payTo }],
    description: "Usage-priced inference",
    mimeType: "application/json",
  },
}, resourceServer));
app.get("/metered", (_request, response) => {
  setSettlementOverrides(response, { amount: "$0.04" });
  response.json({ tokens: 812, result: "Generated response" });
});

routes["GET /metered"] = x402http.RouteConfig{
	Accepts: x402http.PaymentOptions{{Scheme: "upto", Price: "$0.10", Network: network, PayTo: payTo}},
	Description: "Usage-priced inference", MimeType: "application/json",
}
mux.HandleFunc("GET /metered", func(w http.ResponseWriter, _ *http.Request) {
	nethttpmw.SetSettlementOverrides(w, &x402.SettlementOverrides{Amount: "40000"})
	_ = json.NewEncoder(w).Encode(map[string]any{"tokens": 812, "result": "Generated response"})
})

routes["GET /metered"] = RouteConfig(
    accepts=[PaymentOption(scheme="upto", price="$0.10", network=network, pay_to=pay_to)],
    description="Usage-priced inference",
    mime_type="application/json",
)


@app.get("/metered")
async def metered(response: Response) -> dict[str, object]:
    set_settlement_overrides(response, {"amount": "$0.04"})
    return {"tokens": 812, "result": "Generated response"}

Batch high-frequency payments

Verify cumulative vouchers per request and claim them through a durable channel manager.

app.use(paymentMiddleware({
  "GET /stream": {
    accepts: [{ scheme: "batch-settlement", price: "$0.01", network, payTo }],
    description: "High-frequency price tick",
    mimeType: "application/json",
  },
}, resourceServer));
app.get("/stream", (_request, response) => {
  setSettlementOverrides(response, { amount: "50%" });
  response.json({ asset: "ETH", price: "3200.00" });
});

routes["GET /stream"] = x402http.RouteConfig{
	Accepts: x402http.PaymentOptions{{Scheme: batchsettlement.SchemeBatched, Price: "$0.01", Network: network, PayTo: payTo}},
	Description: "High-frequency price tick", MimeType: "application/json",
}
mux.HandleFunc("GET /stream", func(w http.ResponseWriter, _ *http.Request) {
	nethttpmw.SetSettlementOverrides(w, &x402.SettlementOverrides{Amount: "50%"})
	_ = json.NewEncoder(w).Encode(map[string]string{"asset": "ETH", "price": "3200.00"})
})

routes["GET /stream"] = RouteConfig(
    accepts=[PaymentOption(scheme=SCHEME_BATCH_SETTLEMENT, price="$0.01", network=network, pay_to=pay_to)],
    description="High-frequency price tick",
    mime_type="application/json",
)


@app.get("/stream")
async def stream(response: Response) -> dict[str, str]:
    set_settlement_overrides(response, {"amount": "50%"})
    return {"asset": "ETH", "price": "3200.00"}

The complete batch fixtures configure a dedicated RECEIVER_AUTHORIZER_PRIVATE_KEY to sign claim and refund authorizations. Keep it separate from the receiving wallet and store it in a server-side key manager.

Batch examples use file-backed storage for a single process. Use Redis or Valkey with atomic updates for serverless or multi-instance deployments so voucher state survives restarts and is shared across workers.

See the complete verified x402 servers for imports, route composition, channel-manager startup, and lockfiles.

Call a paid x402 service

Register every scheme you permit, then reject unexpected networks or spend before the wallet signs. The wrapper handles the 402 retry; your code still validates the paid response as untrusted input.

TypeScript buyer

const account = privateKeyToAccount(required("EVM_PRIVATE_KEY") as `0x${string}`);
const publicClient = createPublicClient({ chain: baseSepolia, transport: http() });
const client = new x402Client()
  .register("eip155:*", new ExactEvmScheme(account))
  .register("eip155:*", new UptoEvmScheme(account))
  .register("eip155:*", new BatchSettlementEvmScheme(toClientEvmSigner(account, publicClient)));

const baseSepoliaUsdc = "0x036CbD53842c5426634e7929541eC2318f3dCF7c";
let authorizedThisSession = 0n;
client.onBeforePaymentCreation(async ({ selectedRequirements }) => {
  if (selectedRequirements.network !== "eip155:84532") return { abort: true, reason: "Wrong network" };
  if (selectedRequirements.asset.toLowerCase() !== baseSepoliaUsdc.toLowerCase()) return { abort: true, reason: "Wrong asset" };
  const amount = BigInt(selectedRequirements.amount);
  if (amount > 100_000n || authorizedThisSession + amount > 1_000_000n) {
    return { abort: true, reason: "Spend limit exceeded" };
  }
  authorizedThisSession += amount;
});

const fetchWithPayment = wrapFetchWithPayment(fetch, client);
const response = await fetchWithPayment("http://localhost:4021/fixed");
if (!response.ok) throw new Error(`Paid request failed: ${response.status}`);
console.log(await response.json());

The public x402.org facilitator is for testnets only. Choose a production facilitator for eip155:8453, cap both per-request and aggregate spend in code, protect wallet keys, and never execute instructions returned by a paid endpoint.

Build on Base

Issue Stablecoins

Integrate DeFi

Tokenize Stocks

Accept Payments

Private Transactions

Demo

Accept a fixed-price payment

Settle a usage-based payment

Batch high-frequency payments

Call a paid x402 service

See also

​Demo

​Accept a fixed-price payment

​Settle a usage-based payment

​Batch high-frequency payments

​Call a paid x402 service

​See also

Demo

Accept a fixed-price payment

Settle a usage-based payment

Batch high-frequency payments

Call a paid x402 service

See also