The Status Code That Waited Thirty Years
HTTP 402 — Payment Required — has been in the spec since 1997. For almost thirty years, every HTTP reference has included the same note: "reserved for future use." Browsers never implemented it. Web frameworks ignored it. It became a piece of internet trivia, the status code that was always meant for something but never quite found its moment.
That moment appears to be now. In the space of six months, three separate organisations have independently built payment protocols for AI agents around HTTP 402: Stripe and Tempo launched the Machine Payments Protocol (MPP) this week, Coinbase shipped x402 earlier this month, and Google released its own agent payments scheme back in September 2025. All three use HTTP 402 as the signalling mechanism — the server tells the client "you need to pay for this," the client figures out how to pay, and the transaction happens without a human navigating a checkout page.
The convergence is worth paying attention to, because it suggests something real is happening at the infrastructure layer. When Stripe, Coinbase, and Google independently arrive at the same protocol primitive, that's not a coincidence. It's a signal that the internet is growing a payment layer it probably should have had all along — and AI agents are the forcing function.
How MPP Actually Works
The technical architecture of MPP is clean. An agent sends an HTTP request to a service endpoint. If the resource costs money, the server responds with a 402 status code and a structured payment request: how much, in what currency, where to send it. The agent authorises the payment, retries the request with proof of payment attached, and gets the resource plus a receipt.
For Stripe businesses, these transactions flow through the existing PaymentIntents API. Funds settle into the business's normal Stripe balance, on their standard payout schedule. Tax calculation, fraud protection, reporting, refunds — all the infrastructure that already exists for human payments works for machine payments too.
MPP supports two payment methods. Crypto payments settle on-chain using deposit addresses on Tempo, a new blockchain co-developed by Stripe and Paradigm that went live this week. Fiat payments work through Shared Payment Tokens (SPTs), which let agents pay with cards and wallets without exposing full card numbers. Visa contributed the specifications for card-based agent payments — not a small detail, given that Visa processes most of the world's card transactions means this isn't purely a crypto play.
The code to accept MPP payments is genuinely minimal. A few lines with Stripe's mppx server library: define your payment method, set a price, and wrap your endpoint. The library handles the 402 challenge-response flow.
What Agents Are Actually Buying
The interesting part isn't the protocol mechanics — it's what's being built on top of it. Stripe lists three early adopters, and each represents a different model for machine commerce:
Browserbase lets agents spin up headless browser sessions and pay per use. An agent that needs to scrape a page, fill out a form, or take a screenshot pays for exactly the compute it consumes. No subscription tiers, no account creation, no pricing page to navigate.
PostalForm lets agents pay to print and send physical mail. An AI agent that needs to send a legal notice or a physical letter can do it programmatically, paying per envelope.
Prospect Butcher Co. — and this one is slightly surreal — lets agents order sandwiches for human pickup or delivery in New York City. An agent that's scheduling your lunch while managing your calendar can now also pay for it.
These aren't hypothetical use cases. They're live on Stripe's infrastructure right now. The pattern they share is pay-per-action: no accounts, no subscriptions, no human in the loop. The agent needs something, pays for it, gets it.
The Standards Race
MPP isn't operating in a vacuum. Coinbase launched x402 earlier this month — a similar protocol that also uses HTTP 402 as its signalling mechanism but routes payments through Coinbase's own infrastructure and the Base blockchain. Google shipped an agent payments scheme in September 2025 that supports both credit cards and stablecoins.
Three competing standards for the same primitive in under six months. That's either a sign of genuine demand or a sign that everyone is building for a market that doesn't exist yet. Probably both.
The meaningful difference between them is less about the protocol and more about the payment rails. MPP supports both fiat (via Stripe) and crypto (via Tempo). Coinbase's x402 is crypto-native. Google's approach is agnostic but leans on existing card networks. Each reflects its creator's strategic position, which is unsurprising — payments protocols are as much about capturing commerce flows as they are about technical elegance.
Matt Huang, cofounder of Tempo and managing partner at Paradigm, described MPP to Fortune as "the most elegant, minimal, efficient protocol that anyone can extend without our permission." The "without our permission" part matters. An open protocol that anyone can implement stands a better chance of becoming infrastructure than a proprietary one, regardless of who built it.
The Harder Questions
The technical plumbing is the easy part. The harder questions are about trust, authorisation, and control.
When a human makes a purchase, they see a price, decide it's worth it, and click "buy." When an agent makes a purchase, who decided the price was reasonable? The agent? Its prompt? A spending policy set by the user? MPP's "sessions" primitive — where an agent authorises a spending limit upfront and streams micropayments within that budget — is one answer, but it pushes the trust question up a level rather than solving it.
There's also the question of what happens when agents start paying other agents. If your scheduling agent pays Browserbase to scrape a restaurant's menu, and Browserbase's infrastructure pays for compute from a cloud provider, you've got a chain of automated transactions that no human approved individually. The total spend is the sum of many small decisions, none of which looked expensive in isolation.
This connects to something we've written about before — the gap between what agents can do and what we can meaningfully oversee. Adding financial transactions to that gap doesn't make it smaller.
What This Means for Building Services
For anyone building services that agents might consume, the signal is clear: machine-readable pricing and programmatic payment are becoming table stakes. The era of "visit our pricing page and pick a tier" doesn't work when your customers don't have eyeballs.
The practical implications are straightforward:
- Price per action, not per seat. Agents don't have seats. They have tasks. Usage-based pricing is the natural model.
- Expose machine-readable payment endpoints. If your API returns a 402 with structured payment details, any agent with a wallet can pay you. If it returns a redirect to a checkout page, no agent can.
- Think about authorisation boundaries. Your customers' agents will want to buy things from you. Their customers' agents will want to buy things from their customers. The spending authorisation chain gets long fast.
The businesses that figure this out early — services designed from the ground up for machine consumption, with pricing and payment that don't require human intervention — are likely building the infrastructure layer of the agent economy. The ones that retrofit existing human-oriented flows will work, but they'll be working against the grain.
The Bet
Stripe is making a bet that the agent economy will be large enough to justify dedicated financial infrastructure. Given that Tempo raised $500 million at a $5 billion valuation from Paradigm and Thrive Capital, and that Visa is contributing protocol specifications, this isn't a side project. It's a serious wager on a specific vision of how the internet evolves.
Whether that vision materialises depends on whether agents become genuine economic actors — not just tools that fetch information, but participants that autonomously transact. The early examples are modest (headless browsers, physical mail, sandwiches), but the protocol is designed for arbitrary commerce at internet scale.
HTTP 402 waited thirty years. The question now is whether it was worth the wait, or whether we're watching infrastructure being built for a future that's still further away than it looks. Given what's shipping this week, the evidence points toward the former.