x402 is an open HTTP-level payment protocol — built on the 28-year-dormant HTTP 402 “Payment Required” status code — that became the de facto agentic-payment standard during late 2025 and early 2026. By ETHPrague (May 2026), x402 has burst out of the crypto bubble: AWS, Cloudflare, Google Cloud, Vercel, Netlify have native x402 support; Cloudflare’s “isitagentready.com” checklist treats x402 compatibility as a baseline criterion. Coupled with Google’s AP2 (Agent Payments Protocol) intent-cart-purchase mandate framework, x402 forms the dominant agent-native commerce layer.

Key Ideas

Why HTTP 402 finally matters

The HTTP 402 status code has existed since 1997 and went unused for nearly 30 years. The reason: until late 2025, there was no settlement layer fast and cheap enough to handle micropayments at HTTP-request granularity. Stablecoin rails on L2s — USDC on Base / Arbitrum / Polygon — finally crossed the throughput-cost-finality threshold.

x402’s design is a classical request/response cycle:

  1. Client sends request to gated endpoint.
  2. Server responds with HTTP 402 + JSON: accepted currency (usually USDC), settlement network (Base/Arbitrum/Solana), required amount.
  3. Client makes the payment, includes proof.
  4. Facilitator verifies the payment.
  5. Server grants access (sets cookie, returns gated content).

Total round-trip can be sub-millisecond on warm-cache facilitators. Settlement-layer-agnostic by design — one config line switches networks.

Adoption velocity (per Ben Greenberg, Arbitrum DevRel)

Cited examples at ETHPrague:

  • Cloudflare — Officially adopted; checks x402 as part of “isitagentready.com” agentic-readiness audit.
  • AWS — Native x402 service launched the day before Greenberg’s ETHPrague talk; uses CDP wallet on the back end.
  • Google Cloud, Vercel, Netlify — All shipped x402 native support.
  • Google’s AP2 (Agent Payments Protocol v2) — Complementary higher-level standard; lists Adyen and Mastercard as adopters.

Greenberg’s framing: he has never seen this velocity of adoption for a crypto-native protocol. The reason: x402 solves a problem the broader market explicitly has (agents that need to pay), not just a problem crypto-natives notice.

AP2 — Google’s Agent Payments Protocol

x402 is the settlement layer. AP2 is the authorization layer that sits above it. AP2 introduces three mandate types issued by the user to the agent:

  1. Intent mandate — “I want to buy something matching this description” (cryptographically signed).
  2. Cart mandate — “I approve this specific cart of items at this specific cost.”
  3. Purchase mandate — “I authorize this specific payment now.”

The user can be in the loop at every step or fully out of it (“danger-skip-permissions” mode for agents). Critically, AP2 lets the user define bounded authorization — spending caps, per-merchant limits, time-windows — so that a psychophant agent (the canonical failure mode: agent buys unlimited LinkedIn ads because user said “look like ads”) cannot drain the user.

The combination of AP2 + x402 = full lifecycle: user intent → cart matching → AP2 verifies authorization → x402 settles payment.

What x402 enables

The classes of application now production-feasible:

  • Pay-per-use APIs at sub-cent granularity — Greenberg’s side-project example: $0.001 per API call, viable because x402 round-trip is sub-millisecond and Arbitrum gas is sub-cent.
  • Agent-to-agent service marketplaces — The x402 Bazaar (cf. Istanbul reference) — agents discover services across the web, pay them autonomously.
  • Autonomous commerce — Recurring payments with EIP-3009 gasless transactions, one-time AP2 mandate approval for spending caps.
  • Machine-to-machine payments — IoT sensors paying for compute, satellites paying for ground-station time, agents paying for inference.

How to Apify + x402 (Jakub Kopecky)

A concrete production reference. Kopecky’s ETHPrague talk demonstrated an x402 integration into Apify’s scraper marketplace — every scrape call gates behind x402 micropayment; data quality and price compete in a real market. The takeaway: x402 is already the production-grade settlement for AI agent data markets, complementing the MCPay pattern from Devconnect Argentina’s zkTLS day.

Build micropayment x402 solutions for communities (Julio M Cruz, PerkOS)

PerkOS extends x402 into community-loyalty contexts — every micro-interaction in a community (post, reply, helpful comment) can be x402-priced. The community-native variant of pay-per-API: pay-per-attention, where attention is monetizable at the micropayment scale.

Speed and fee-predictability matter for agents

Greenberg’s point: agents are more impatient than humans. Humans abandon a webpage after 3–4 seconds; agents abandon a tool after one failed attempt unless prompted to retry with different approach. Settlement layer requirements:

  • Sub-second confirmation.
  • Predictable fees — agents budgeting thousands of micropayments need to be able to plan, not gamble on gas spikes.
  • Arbitrum’s relative-fee-predictability is the working example (Greenberg’s shameless plug, with the data on Dune dashboards).

Details / Subtopics

The CDP wallet pattern

AWS’s x402 native service uses Coinbase Developer Platform (CDP) wallets. The architecture: agent gets a wallet under user control with AP2 spending caps; AWS service receives x402 payment via CDP-facilitated settlement; user retains full sovereignty over funds. The CDP wallet abstraction lets agents pay without holding meaningful balance.

Builder hubs and merchant onboarding

x402 V2 added several features critical for production:

  • Multi-payment recipients — Split payments across multiple parties in one request.
  • Recurring payments — Implicit subscriptions with revocation.
  • Multimarket opportunities — A single x402 endpoint can advertise multiple acceptable currencies/networks.
  • Reusable sessions — Skip full payment round-trip for repeated calls within a session window.

Quote and structured-data signing

A robust x402 flow uses EIP-712 structured data for the quote object. Only authorized “quote services” can sign valid quotes; the user approves the token once with an AP2 mandate; multiple swaps can execute in sequence; the user retains single-signature UX.

x402 vs. credit cards / Stripe

The natural comparison. Stripe-style payment processing has 2.9% + $0.30 transaction fees and ~2 day settlement. x402 on Arbitrum: sub-cent total cost, sub-second settlement, programmable mandates. For per-API-call payments, the credit-card stack is structurally infeasible.

What x402 doesn’t solve: chargebacks. The cypherpunk answer (smart-contract escrow with on-chain dispute resolution) exists but is not yet integrated into the dominant x402 implementations. For high-trust merchants this is fine; for low-trust merchants it’s a gap.

Connection to Stripe + Bridge agentic payments

Colin Banville’s EthCC[9] talk (“How Payments Change When Agents Pay”) is the institutional-side complement. Stripe’s Bridge acquisition and integration positions them to be the AP2/x402-compatible bridge for institutional commerce. The retail and institutional payment stacks are converging on the same agent-native architecture.

The “isitagentready.com” checklist

Cloudflare’s checklist (cited by Greenberg) treats x402 support as one of the criteria for whether a site is ready for agentic users. Other criteria: AP2-compatible authorization flows, machine-readable content (not anti-bot rate limiting that breaks legitimate agents), reasonable response time (<3s for agent timeouts).

x402 on chains other than Ethereum L2s

The protocol is settlement-layer-agnostic; Solana has working x402 integrations. The dominant deployment is on EVM L2s (Base most-deployed because of CDP wallet integration; Arbitrum favored by Greenberg for fee predictability) but no architectural lock-in.

Connections

  • On-Chain Agents — x402 is the dominant agentic-payment standard; AP2 is the authorization layer above it; Hardware Wallets in the Age of AI is the user-end safety layer.
  • Stablecoins & RWA Convergence — USDC on L2 is the most-used settlement asset for x402.
  • Account Abstraction — AP2 mandates map naturally onto EIP-8141 frame transactions; recurring payments with AA + x402 is a key emerging pattern.
  • Ethereum Developer Tooling — x402 SDK and protocol spec are open; CDP, Coinbase OnchainKit, and similar tools form the developer stack.
  • ETHPrague 2026 — Overview — Greenberg’s session is the ETHPrague headline for the agentic-payment cluster.

Open Questions

  • Will AWS’s native x402 service result in a fork toward AWS-specific extensions, or do they hold to the open standard? Greenberg expressed cautious optimism; the open-protocol vs. embraced-and-extended risk is real.
  • What’s the equilibrium between x402’s “no fees” framing and the reality that L2 gas, facilitator services, and bridge costs add up? For pure micropayments under $0.01, the overhead is sometimes >50% of the transaction.
  • AP2 + x402 ship without on-chain dispute resolution. Does the equilibrium settle into “trust the merchant” for the unsophisticated tail, with cypherpunk-native escrow only for crypto-native users? Or does Stripe-style chargeback functionality eventually layer on?
  • What’s the security threat model for agents holding x402-payable balances? AP2 mandates bound the damage, but prompt injection against an agent with a $1,000 AP2 cap is still a $1,000 attack. Hardware-wallet co-signing for agent payments is the open implementation work.