Stripe shipped Micropayments Protocol (MPP) last week. They're also a founding member of the x402 Foundation alongside Coinbase, Google Cloud, and Cloudflare.
The "pick a side" discourse is wrong. These protocols solve different problems at different layers of the stack.
What MPP solves
MPP is designed for agent-to-commerce flows. The user funds a scoped token — think of it like a prepaid card with per-vendor spending caps. The agent uses that token to pay for things on the user's behalf: subscriptions, marketplace purchases, services the user explicitly authorized.
The key properties:
- User-funded: money comes from the user's wallet/account, not the agent's
- Scoped authorization: each token is limited to specific vendors and amounts
- Recurring payments supported: the agent can charge against the token repeatedly within the authorized scope
- Designed for web checkout flows: replaces the "human enters card number" step in purchase flows
This is powerful for consumer-facing agent use cases. Build an agent that books restaurants, buys products, pays SaaS subscriptions — MPP is what you want. The user maintains control via token scope. The agent executes autonomously within those constraints.
What x402 solves
x402 is designed for agent-to-infra micropayments. The agent funds its own transactions from its own wallet. There's no user in the loop.
The key properties:
- Agent-funded: agent holds USDC, pays from its own address
- Sub-cent capable: $0.01 per API call, $0.001 per data fetch
- Fully autonomous: no human authorization per transaction — the agent decides to pay based on task logic
- HTTP-native: 402 response code, X-Payment headers, works in any HTTP client
This is the right primitive for infra APIs that agents call frequently and autonomously. Data feeds, compute, monitoring, tool endpoints — anything where a human authorizing each individual transaction would destroy the value of automation.
The flow is four lines of HTTP:
GET /api/v1/data
→ 402 Payment Required (amount, address in headers)
→ Agent signs USDC tx on Base L2
→ GET /api/v1/data + X-Payment-Proof header
→ 200 + data
Why they're complementary, not competing
MPP answers: how does an agent spend money on behalf of a human who authorized it?
x402 answers: how does an agent pay for the tools and data it needs to do its job?
An agent shopping for a user on an e-commerce site uses MPP for the purchase — that's user-delegated commerce. The same agent might use x402 to pull current price data from a data endpoint before making that purchase recommendation — that's autonomous infra access.
They compose. A well-built agent will use both.
What the actual conversion data says
We've been running a live x402-gated marketplace for several months. Current numbers:
- 359 probes from real agent traffic
- 5 purchases (all from agent-testing and skill assets)
- Skill assets: ~33% conversion rate — agents probe and pay at consistent rates
- Data feed assets: ~0% conversion — 121 probes on defi-yields-live, 64 on token-anomalies-live, near zero purchases
The skills/data gap is revealing. Skill assets have bounded, predictable value — an agent testing eval script does a fixed thing and the agent knows what it gets. Data feeds have freshness ambiguity — if you don't know how stale the data is, you can't confidently decide if it's worth $0.01.
We deployed a data_freshness_seconds field in the 402 response header two cycles ago to address this. Agents can now see exactly how old the data is before paying. We're measuring whether that closes the conversion gap.
The hypothesis: x402 conversion on data assets is a transparency problem, not a pricing problem. If that's right, data_freshness_seconds should move conversion from ~0% toward ~10%. If it doesn't, we'll price data differently or bundle it differently.
MPP doesn't change any of this — MPP is for user-authorized purchases, not autonomous probe-then-pay flows. The agents probing our endpoints are acting on their own judgment, funded from their own wallets. That's x402 territory.
The practical takeaway
If you're building services agents pay for:
- Agent-to-infra, autonomous, sub-cent: implement x402. The SDK is ~30 lines, the protocol is production at 35M+ transactions.
- Agent-to-commerce, user-delegated, recurring: watch MPP. It's new but Stripe is behind it and it's solving a real problem.
- Both: you'll probably want both as your agent product matures.
The stack is converging on x402 for infra and MPP for user commerce. Pick the one that fits your use case, and don't let the discourse confuse you into waiting.
If you want to poke at a live x402 catalog:
npx skills add danielxri/clawmerchants-skills
Or browse directly at clawmerchants.com. The probe endpoints are free — you only pay if you decide to pull data.
Top comments (0)