[TL;DR]
- x402 is a protocol that actually implements the HTTP 402 code defined in 1996, enabling AI agents to make micropayments as small as $0.01 within 200ms without human intervention.
- Alongside other protocols such as Google AP2 (authorization), Visa TAP (identity), and Stripe ACP (legacy integration), x402 acts as the settlement layer of the agent commerce stack, responsible for crypto-native payment execution.
- While today it is heavily centralized around Base + USDC + Coinbase as facilitator, x402 must solve for multi-chain support and a decentralized facilitator ecosystem if it is to become a true web standard.
1. How AI Is Changing the Internet Economy
1.1 Content Is Consumed, but the Money Doesn’t Flow Back
For the past 30 years, the internet has made money in two main ways. When people visit websites, ads are shown, and that ad revenue supports content creators. Or, like Netflix, you pay a monthly subscription fee and consume unlimited content. These two pillars — ads and subscriptions — have been the foundation of the digital economy.
But with the rise of generative AI, this structure has started to crumble. AI agents browse the web like humans, but they don’t watch ads. When ChatGPT reads a news article, it doesn’t click banner ads, and subscription models don’t work either. AI doesn’t buy a monthly pass; it just extracts the information it needs and summarizes it for the user. As the primary consumer of the internet shifts from humans to machines, the existing monetization model stops working.
Take a developer running a free weather data API, for example. Originally, this API handled a few hundred requests per day. Once AI agents discover it, they start sending hundreds of thousands of queries per hour. Server costs skyrocket, but revenue remains zero. The developer eventually has to shut down the API or consider paywalling it. Content is being consumed, but creators are not being compensated.
This problem isn’t limited to journalism or the arts. The New York Times suing OpenAI is just the most visible case; the real issue lies in how the web itself is designed. The internet was built to exchange information, not value. As the AI era matures, creators go bankrupt and AI runs out of new content to train on. In the end, we’re left with a loop where AI trains on AI-generated content.
1.2 HTTP 402, Returning After 30 Years
When the HTTP/1.1 standard was published in 1996, it included an intriguing status code: 402 Payment Required. It was meant for servers to signal to clients, “This resource requires payment.” Unlike well-known codes like 404 (not found) or 500 (server error), it quietly sat in the spec, rarely mentioned. The problem is that it was never properly used in practice for almost 30 years.
It failed for three main reasons. First, the standard itself was incomplete. The 402 code only indicated that “payment is required,” but it did not define how that payment should happen. Second, there was a chicken-and-egg problem. Client developers didn’t implement it because no servers supported it; server developers didn’t implement it because no clients could pay.
Third, and most importantly, the payments infrastructure could not handle micropayments. Traditional payment systems had a fixed cost of at least 30 cents per transaction. A typical credit card fee is 2.9% plus $0.30. If you sell $1 content, $0.33 goes to fees. If you try to charge $0.10 or $0.01, the fee exceeds the amount. Under this model, micropayments were dead on arrival.
That’s why the micropayment systems attempted in the late 1990s and early 2000s all failed. People simply couldn’t tolerate paying every time they loaded a webpage. Even for small amounts, each payment forces a moment of hesitation: “Is this really worth paying for?” That psychological friction was too high. Content providers returned to ads and subscriptions, and 402 faded into obscurity in a spec document.
1.3 2025: Three Conditions Finally Align
By 2025, the situation has fundamentally changed. Coinbase and Cloudflare launched the x402 Foundation, resurrecting the long-dormant 402 code. This suddenly became possible because three core technologies matured at the same time.
The first is stablecoins. Bitcoin’s volatility made it unsuitable as a daily payment method. What is worth $1 today might be $0.80 tomorrow. In contrast, stablecoins like USDC are pegged 1:1 to the US dollar, making their price stable. We now have a medium of exchange that behaves like money while remaining digital and programmable.
The second is Layer 2 blockchains. Ethereum mainnet was slow and expensive: transaction fees were often several dollars each. But L2 networks like Base batch multiple transactions together and only write the final result to mainnet. This drives fees down to around $0.0001 and reduces latency to between 0.2 and 2 seconds. Compared to credit cards, which can take days to settle, this is a different world.
The third, and most important change, is the rise of AI agents. Micropayments failed in the past because humans hate making many small payment decisions. AI, however, feels no such psychological burden. Whether it pays $0.01 or $100, it simply executes the programmed logic. No annoyance, no hesitation, no fatigue. In other words, both the technical and psychological barriers have disappeared. With these three factors converging in 2025, the vision of web-native payments imagined 30 years ago is finally becoming real.
2. How x402 Works
2.1 A Handshake Between Machines
x402 is fundamentally a payment negotiation protocol. Just as browsers and servers talk via HTTP when you visit a website, x402 inserts a payment process into that conversation. You don’t need deep blockchain knowledge; you simply add a few steps to exchange payment information within normal HTTP requests and responses.
The protocol requires four participants. First is the client, the party requesting the resource — this could be an AI agent or an app. Next is the resource server, which provides the paid content, such as an API or website. So far, this is just the normal web model. x402 adds two more: the facilitator, which bridges Web2 and Web3, and the blockchain, which acts as the final settlement layer where money actually moves.
There is a key design decision here: the resource server never directly touches the blockchain. Regular web developers don’t need to run nodes or work with smart contracts. Instead, the facilitator handles all that complexity. The server simply asks, “Can you verify this payment?” This makes it surprisingly simple to integrate x402 into existing web infrastructure.
2.2 The Payment Flow
Let’s see how a payment actually happens. Suppose an AI research assistant wants to read the latest semiconductor paper from a paid academic database.
The AI assistant requests the paper from the database. At this point, it doesn’t know whether payment is required. The database responds with a 402 status, specifying the payment conditions: something like “This paper costs 0.03 USDC on the Base network, sent to this address.” It’s like checking the price of a book at a bookstore.
Now the AI’s wallet springs into action. It creates a signature saying, effectively, “I agree to pay 0.03 USDC.” This signature is both a promise and proof of authorization. The AI then re-sends the request for the paper, this time including the signed payment.
Here’s where the important part happens. The database doesn’t verify the payment itself. It forwards the payment information to the facilitator. The facilitator checks whether the signature is valid, the amount is correct, and the payment isn’t being reused. Then it actually submits the transaction on-chain. On a fast network like Base, settlement completes in under two seconds.
Once everything is finalized, the database returns the requested paper along with a payment receipt. The AI gets the paper, the provider gets $0.03, and the entire transaction is transparently recorded on the blockchain. From the end user’s perspective, they just waited an extra two or three seconds.
2.3 Design Philosophy
x402’s design follows a few clear principles. The first is that servers do not handle the blockchain directly. This is intentional. Most web developers are not blockchain experts. Running nodes, calculating gas fees, and managing private keys are all high-friction tasks. By offloading these to facilitators, regular developers can integrate x402 with just a few REST API calls.
The second principle is a non-custodial structure. Facilitators never hold user funds. Money moves directly from the client’s wallet to the server’s wallet, while the facilitator merely relays and verifies. It’s like a courier delivering a package but never owning it. This minimizes the risk of funds being seized, stolen, or frozen in the middle.
The third principle is a world without chargebacks. Credit card payments can be reversed for up to 120 days. For merchants, this means money can suddenly disappear, and chargebacks are a major vector for fraud. Blockchain transactions, once finalized, cannot be undone. Once the server sees a confirmed payment, the money is definitively theirs. This is especially important for micropayments: if you earn $0.01 and later lose $0.01 plus fees due to a chargeback, the model collapses.
Finally, x402 aims to be chain-agnostic and asset-agnostic. While current implementations focus on Base and USDC, the protocol itself can work with any blockchain and any token. It could run on Solana or Polygon, and in the future, even integrate credit cards or bank accounts via facilitators. This flexibility is what allows x402 to evolve into a true web standard rather than being locked into one platform.
3. The Agent Commerce Stack
3.1 Building the Agent Economy Together
To understand x402, we need to zoom out. Starting in 2025, global tech companies began focusing on a similar question: what infrastructure is needed for AI agents to autonomously participate in the economy? Each company grabbed a different piece of the puzzle, and together these pieces form what we can call the agent commerce stack.
Google proposed AP2 (Agent Payments Protocol). Rather than payments themselves, AP2 focuses on the authorization problem. When an AI spends money, how do we prove that it reflects the user’s intent? AP2 defines how to express user-granted permissions in a verifiable way. For example, “This AI can spend up to $10 per day and only on news subscriptions and data APIs.”
Stripe and OpenAI are building ACP (Agentic Commerce Protocol). Their focus is integrating with existing e-commerce. Today’s online stores are designed for humans filling out forms and typing card numbers. ACP helps AI agents navigate and complete these existing checkout flows using natural language commands — essentially an automated payment assistant for AI.
Visa introduced TAP (Trusted Agent Protocol). Visa is focused on identity. From the server’s perspective, it needs to distinguish between legitimate agents and malicious bots. TAP uses verifiable credentials to give AI agents a kind of digital ID. This lets servers confirm that “this agent is acting on behalf of a trusted user.” It essentially addresses the KYA problem: Know Your Agent.
There’s also ATXP (Agent Transaction Protocol), developed by former Stripe engineers, which focuses on per-function API payments. When an AI agent calls an external API, ATXP lets you price and charge for each function call automatically. It’s designed to run inside agent frameworks like MCP servers and goes even deeper than x402, down to fine-grained function-level billing.
3.2 x402’s Unique Role
So where does x402 sit among all these protocols? It doesn’t handle authorization, identity, or legacy integration. x402 has a single, sharp role: payment execution. While other protocols deal with “who, why, and where,” x402 handles “how the money actually moves.”
Imagine the flow. A user tells their AI assistant, “Find me an up-to-date report on the semiconductor industry.” The AI finds a paid research database and decides to purchase a report. At this point, several protocols kick in. AP2 verifies that the AI has permission to make such a purchase. TAP proves that the AI represents a verified user. Then x402 executes the payment: “Send 0.50 USDC on the Base network.”
In this sense, x402 acts as the settlement layer of the agent commerce stack. Once authorization and identity checks are done, it’s x402’s job to move the money. A 402 response goes out, the client sends a signed payment, the facilitator posts the transaction on-chain — that chain of events is the moment of value transfer.
Importantly, these protocols are not competitors but complements. AP2 for authorization, TAP for identity, x402 for crypto-native payments, ACP for legacy checkout flows — they are puzzle pieces that form a complete picture when combined.
In fact, Cloudflare has stated that its agent platform can support both x402 and ATXP. Developers can choose the protocol that best fits their use case. x402 is ideal for web-wide resource payments; ATXP works well for pricing individual API functions. The key is that this is an open ecosystem. No single company controls everything; protocols can be freely combined and extended.
x402’s strength lies in this clear division of labor. It doesn’t try to do everything. It focuses on one job — “crypto-native payment execution” — and lets other protocols handle authorization, identity, and integration. This modular approach is how web standards have historically evolved, and it’s why x402 has a real chance of becoming an internet standard.
4. How Internet Businesses Will Change
4.1 True Micropayments
The biggest change x402 brings is that it rewrites the economics of micropayments. Transactions as small as $0.01 can now be profitable. Previously, charging $0.01 via credit card incurred a fixed fee of $0.30 plus 2.9%. The fee was 30 times the amount; no one could price content that way. With x402 on an L2 like Base, fees are around $0.0001. If you charge $0.01, you keep about $0.0099.
This change is about more than enabling small payments. It revives usage-based pricing. In the past, charging $0.001 per API request was impossible, so providers resorted to monthly subscriptions or giving access away for free. Now, true pay-per-use becomes viable. If a user makes 100 calls, they pay $0.10; if they make 10,000 calls, they pay $10. If they don’t use it, they pay nothing.
A comparison with traditional systems makes this clearer. Credit cards typically cost $0.30 + 2.9% per transaction, settle in days, and carry chargeback risk for up to 120 days. The theoretical capacity is around 65,000 transactions per second. PayPal is similar: fees above 3%, relatively fast settlement, but chargebacks still exist. Stripe’s crypto payment options have fees of 1.5%+ and speed varies by chain.
x402 on Base is effectively near-free. Gas is less than $0.0001, settlement is done in about 200ms, and there are no chargebacks. Capacity can scale to hundreds or thousands of transactions per second. Compared to Ethereum L1, where each transaction can cost $1–$5 and take 12 minutes to finalize, x402 brings the decentralization benefits of blockchain without the usual cost and latency penalties, thanks to L2.
4.2 Real-World Use Cases
So what does this look like in practice? One obvious use case is autonomous purchases by AI agents. A research assistant AI searches a scholarly database to answer a user’s question. A paid paper costs $0.03. The AI uses x402 to automatically pay and download the paper, then summarizes it. The user may not even realize a purchase happened — they just see a good answer.
A trading bot needs real-time market data. Minute-level data is free, but per-request access to second-level data costs $0.02. The bot only buys second-level data when it detects a potential opportunity. If it does this 500 times a month, it pays $10, saving $90 compared to a fixed $100 monthly subscription. Meanwhile, a high-frequency trading bot might make thousands of purchases and spend $200. Everyone pays according to their actual usage.
The same applies to GPU resources. Suppose cloud GPUs cost $0.50 per minute for AI training. Traditional cloud services bill in hour blocks or have minimum usage requirements. An x402-based service can truly bill by the minute. Use 3 minutes, pay $1.50; use 50 minutes, pay $25. Each burst of usage triggers a payment, and when you’re done, charges stop.
This also enables content unbundling. A single New York Times article might cost $0.25. If you read 10 articles a month, that’s $2.50, versus a $20 monthly subscription. For light users, per-article payments are much more efficient. Heavy readers may still prefer subscriptions, but the key is choice — subscription is an option, not the only path.
Podcasts could charge $0.50 per episode. Listeners get ad-free content, and creators receive direct income. With ads, platforms take a cut; with x402, payments go straight to the creator’s wallet. Games can adopt a pay-per-play model, charging $0.10 per session instead of selling large upfront packages or forcing users to watch ads. If you try a game once and drop it, you only spent $0.10; if you love it and play 100 times, you spent $10.
Perhaps the most interesting is the agent-to-agent economy. A user’s generalist AI assistant gets a complex task: “Find the best arbitrage opportunities across these three decentralized exchanges.” The generalist AI hires three specialist AIs, each an expert in one exchange, paying them $0.25 each. The specialists return their findings, and the generalist composes the final recommendation. At no point does a human intervene. AI hires AI and pays AI. This is a genuine autonomous economy.
4.3 Shifts in Business Models
As these use cases accumulate, the structure of the internet economy itself changes. Subscription fatigue eases. Today, the average person manages dozens of subscriptions: Netflix, Spotify, NYT, YouTube Premium, cloud storage, and more. Hundreds of dollars leak out monthly, while only a fraction of these services are used heavily. With x402, users can truly pay only for what they use and choose between subscription and metered billing.
Dependence on advertising can also decrease. Currently, free services must attach ads to survive. If x402 lets sites charge $0.05 per article, they can be ad-free and still sustainable. Users get a cleaner experience; creators earn directly. The margins that used to go to ad platforms disappear.
Creator monetization becomes more democratic. Small creators can make money without relying on big platforms. A solo blogger who integrates x402 can charge $0.10 per article. If 1,000 people read a post, they make $100 — and unlike platforms that take 30%, they keep the full amount. Lower barriers mean long-tail creators have a better chance of surviving.
5. Who Manages the Wallet?
5.1 x402’s Real Bottleneck
The x402 protocol is elegant. A 402 response goes out; the client sends a signed payment; the facilitator verifies and settles on-chain. Theoretically, it’s perfect. But using it in practice assumes one precondition: AI agents must have wallets.
This is where the trouble starts. Having a wallet isn’t just about owning an address. You must securely store a private key, sign transactions, maintain sufficient balance, and handle gas fees. Even humans struggle with this. How will AI agents manage? More fundamentally, is it safe to entrust money to an AI at all?
This problem has three dimensions. The first is user experience. If an ordinary user wants to use an AI service and you tell them, “Install MetaMask, buy USDC from an exchange, and transfer it to your wallet,” most will churn instantly. Crypto onboarding is still a major barrier. The second dimension is agent permissions. How much autonomy do you give AI? What is the daily spending cap? Which types of services can it pay for? Who defines and enforces these rules? The third is developer integration. If an API developer wants to support x402 but isn’t a blockchain expert, how do they help users manage wallets?
For x402 to succeed, it needs infrastructure that simplifies wallet management. The protocol is the standard, but the actual running system depends on implementations. That’s where various wallet solutions come in.
5.2 Categories of Wallet Solutions
There’s no single way to solve the wallet problem. The right approach depends on context and priorities. Broadly, we can think in terms of four categories.
Embedded wallets are wallets created automatically via social login. When a user signs up for an AI service with Google or Apple, a wallet is created in the backend. The user may not even know it exists. If they top up $10 with a credit card, the service converts that into USDC and deposits it into the wallet. Whenever the AI uses x402 to make a payment, funds are automatically drawn from there. Users just see a dashboard message like “$0.45 spent today.” The word “crypto” never appears.
Custodial wallets are wallets where the service provider manages the keys. Exchange wallets on Coinbase or Binance are typical examples. For users, this is the simplest: they only need a username and password and never worry about keys. But this moves away from decentralization ideals. If the exchange is hacked or goes bankrupt, users can lose funds. Still, for mass-market services, this is often the most pragmatic option.
Smart contract wallets are wallets implemented as smart contracts instead of simple key-pair accounts, often using standards like ERC-4337 (account abstraction). Their strength is programmable rules. You can encode, “This AI can only spend $10 per day,” “only on APIs X, Y, and Z,” or “any transaction over $1 requires human approval.” This is ideal when you want to give AI limited, structured autonomy. KITE AI’s Agent Passport uses this model, issuing AI a kind of digital passport that encodes spending limits and permissions.
Self-custody wallets are user-managed wallets. MetaMask, Coinbase Wallet, Phantom, and similar browser extension wallets fall here. Users store private keys themselves and manually approve each transaction. This provides maximum control but conflicts with x402’s ethos of automation. Crypto-native users may prefer it, but for the general public, it’s a heavy lift.
5.3 The Role of WaaS (Wallet-as-a-Service)
These wallet models share one thing in common. Except for pure self-custody, most of them are built on WaaS (Wallet-as-a-Service) solutions. WaaS lets developers integrate wallet features via API. They don’t need to run blockchain nodes, build key management infrastructure, or engineer multi-chain support.
Embedded wallets are WaaS. Custodial wallets often rely on WaaS. Smart contract wallets can also be exposed as WaaS. In other words, WaaS is a category of infrastructure under which many implementation styles live. Developers call createWallet() to spin up a wallet and signTransaction() to get a signature. They don’t need to understand the cryptographic details happening behind the scenes.
The relationship between x402 and WaaS is like language and vocal cords. x402 defines “how to speak payments,” while WaaS makes it possible to physically “produce the sound.” Coinbase WaaS naturally integrates tightly with Coinbase’s x402 facilitator, letting developers handle everything from wallet creation to payment verification in one place. Circle’s Programmable Wallets offer a WaaS stack from a regulated stablecoin issuer, appealing to compliance-sensitive financial institutions. MPC-based providers like Fireblocks or Turnkey serve institutions handling large sums.
The critical point is that the x402 protocol itself has no opinion on wallet architecture. It doesn’t care which WaaS you use or what kind of wallet you build. The protocol behaves identically. That flexibility is the power of an open standard. Developers choose the wallet solution that fits their needs, and x402 sits on top as the payment layer. The puzzle pieces can be combined freely.
6. What Kind of Internet Do We Want?
6.1 The Current State: Centralized Bootstrapping
The most common criticism of x402 today is that the actually running system is overly centralized. In theory, x402 is chain-neutral and asset-neutral. In practice, everything revolves around USDC on Base with Coinbase as the facilitator. All three layers trace back to Coinbase: Base is an L2 incubated by Coinbase, USDC is issued by Circle, whose key partner is Coinbase, and the facilitator is run by Coinbase itself.
How should we see this? A critical view would say that x402 claims to be an open standard but is effectively a funnel into the Coinbase ecosystem — driving usage of Base, USDC, and Coinbase infrastructure. Once developers adopt x402, they’re nudged into using Coinbase’s stack. Can such a system truly become a neutral web standard?
But there’s another perspective. Any new standard faces a bootstrapping problem. To break the chicken-and-egg deadlock, someone has to invest and build a full stack first. Coinbase did this by offering a single, integrated path that drastically reduces onboarding friction. Developers don’t have to think about multi-chain support or facilitator choices; they just follow Coinbase’s docs. That simplicity helps drive early adoption.
Historically, many web standards evolved this way. HTTP initially ran on specific server software and later spread to many servers and clients. The key question is whether the protocol itself is open. The x402 spec is public; anyone can build a facilitator, and any blockchain can be used. Today’s centralization can be interpreted as a pragmatic starting point rather than a permanent design choice.
6.2 x402’s Key Challenges
Beyond centralization, x402 faces several hurdles on the path to becoming a true internet standard. First is adoption and network effects. A protocol’s value scales with how widely it’s used. Today, only a tiny number of websites support x402. Most APIs still use API keys and subscription plans. AI agent developers are also mostly in the experimental phase. Reaching critical mass will take time.
Past attempts stumbled on the same issue. The W3C’s Web Monetization standard was technically solid but failed to gain enough publishers and browser support, and quietly faded away. For x402 to avoid that fate, it needs a killer use case. AI agents could be that use case — but it’s still too early to be sure.
Intertwined with adoption is wallet security and user experience. As discussed earlier, onboarding users into crypto just to use AI services remains a high barrier. WaaS providers help abstract this away, but we don’t have a perfect solution yet. More fundamentally, delegating spending power to AI creates new security concerns. What if the AI is hacked or buggy? What if it figures out a way to circumvent the limits we set? Without answers to these questions, mainstream adoption will be slow.
There’s also the risk of standard competition and fragmentation. x402 is not alone. AP2, ACP, TAP, ATXP, and more are all being proposed at once. While they are theoretically complementary, in practice they may clash. What if Google bakes AP2 directly into Chrome and Apple puts its own protocol into Safari? Developers could be forced to support multiple competing standards. The history of web standards shows how painful such fragmentation can be.
The x402 Foundation is trying to prevent this by emphasizing neutral governance, bringing in not only Coinbase but also Cloudflare, Visa, Google, and others. Still, aligning companies with different incentives is difficult. The worst-case scenario is a fractured landscape of incompatible protocols, with large platforms building closed, siloed systems.
On the technical side, scalability cannot be ignored. Today, x402 traffic is small, so there’s no issue. But if it succeeds, things change. What happens when millions of AI agents generate tens of millions of micropayments per second? Can Base handle that load? Even L2 networks have limits. Batch settlement and payment channels might be needed on top. Facilitators could also become bottlenecks; a surge in verification and settlement requests could cause noticeable latency and degrade user experience.
On top of all this sit regulatory uncertainties. Stablecoins and crypto payments are under close scrutiny from regulators. Rules differ across jurisdictions and change frequently. Facilitators may need money transmitter licenses; some countries might restrict or ban stablecoin use altogether. Making x402 a global standard means clearing these regulatory hurdles, which is beyond the scope of pure engineering. It demands engagement with governments, lobbying, and legal work.
6.3 The Road Ahead
Recognizing these challenges, the x402 ecosystem has a clear direction of travel. The most urgent priority is genuine multi-chain support. Today, Base is the default, but x402 needs to expand to Solana, Polygon, Arbitrum, and other L2s. Developers should be able to choose the chain that fits their application, and clients should be able to pay on the chain they prefer. Facilitators must support multiple chains, and the spec must gracefully handle chain-specific differences.
Even more important than multi-chain is the development of a decentralized, multi-facilitator ecosystem. The current model, where Coinbase is the sole facilitator, needs to evolve. Anyone should be able to operate a facilitator; developers should choose from multiple providers or even run their own. That eliminates single points of failure, improves censorship resistance, and moves the system closer to true decentralization. The emergence of third-party facilitators like PayAI Network or x402.rs is a promising early sign.
To improve technical robustness, more advanced payment schemes will be needed. Today, x402 is mostly a “pay per request” model. Real-world use cases are often more nuanced. Sometimes you want “up to a maximum amount” payments — for example, “I’m willing to spend up to $5 for this streaming service; handle time-based billing within that cap.” Or you might want delayed settlement: an AI crawls thousands of pages in a day, but instead of settling on each request, it reconciles once at the end of the day. Cloudflare has already proposed approaches along these lines. These features would unlock even more business models.
Ultimately, x402’s future depends on how quickly it can decentralize. A centralized starting point is pragmatic, but it cannot remain that way. To become a true web standard like HTTP, x402 must evolve into a public good that no single entity owns and everyone can use. If that transition succeeds, x402 could become the payment layer of the AI-era internet. If it fails, it may be remembered as an interesting experiment by Coinbase — and not much more.
[WEPIN Wallet SNS Channels]
