When machines start transferring x402, can they truly revolutionize traditional payments?

Author: Paul Timofeev Source: Shoal Research Translation: Shan Ou Ba, Golden Finance

In 1849, thousands of people rushed to California to seek gold. A few became overnight millionaires, while most returned empty-handed. But the biggest winners were the merchants who made pickaxes and shovels—so long as there was gold underground, these tools would always be in demand.

Today’s “Gold Rush” is artificial intelligence. Payments are becoming a fundamental part of AI workflows, and the infrastructure supporting these payments is undoubtedly the new era’s pickaxes and shovels. This article will deeply analyze the x402 protocol, an emerging open-source native AI agent payment infrastructure, including what it is, how it works, current adoption status, and the unresolved issues when machines start autonomously circulating funds.

A Structural Transformation Is Unfolding

History is defined by structural upheavals: sudden, profound changes that reshape the very foundations of life. The current geopolitical landscape was formed around 175 million years ago during the drift and split of Earth’s tectonic plates. Today, plates still move slowly, but the most significant modern upheavals come from human innovation.

From Sumerian wheels and Gutenberg’s printing press to the steam engine, foundational inventions follow a similar positive feedback loop: humans create machines, machines generate economic surpluses, surpluses fund the creation of better machines, further amplifying output. As technology advances, the costs of trial and error decrease, and iteration speeds up. Over the past decades, driven by computers and their derivative applications and services, this trend has accelerated dramatically.

Today, this transformative power is being fully realized through software, especially artificial intelligence.

AI has existed for decades. The first neural network paper was published in 1943. Expert systems in the 1980s and statistical machine learning in the 1990s quietly embedded AI into various production processes—from credit scoring to ad targeting.

Since the early 21st century, spam filtering, recommendation engines, and fraud detection have been based on machine learning models. The real change lies in interaction: generative AI allows humans to interact with systems in natural language, and this leap in usability has propelled AI into mainstream consumer markets.

OpenAI’s ChatGPT, which interacts with underlying GPT models in a simple, intuitive way, reached one million users in five days and a hundred million in two months, setting the fastest growth record for consumer internet products. Subsequently, competitors like Gemini, Claude, Grok, and others emerged, driving rapid iteration of models and features through fierce competition.

On the other hand, as corporate executives continue layoffs and increase AI investments, concerns about job displacement grow (notably, over half of US jobs today did not exist in 1940).

No one can precisely predict how AI will reshape society. But by the end of 2025, about one in six people worldwide will have used generative AI—a technology that barely existed three years ago. Despite still being in early stages, a structural upheaval is already underway.

However, merely conversing with AI has limited capabilities. Read-only permissions—such as enabling large models to access information, summarize texts, write code, or analyze data—are useful but have clear boundaries. Adding write permissions—allowing AI to perform real-world actions—unlocks a completely different dimension of capability.

In 2025, OpenAI launched Operator and Codex; Anthropic released Claude Code; Perplexity introduced Comet; Google embedded Gemini AI deeply into Workspace; Microsoft integrated Copilot into Office and Windows. Companies like Perplexity, Cursor, Sierra, and Cognition raised hundreds of millions of dollars, hitting record revenues. It’s clear that intelligent agents will define the next chapter of human-AI interaction.

But an overlooked fact is: autonomous intelligent agents have been driving online economic activity for years. The digital advertising market is a vast agent economy lurking behind nearly all ad-supported web pages (most large consumer websites and platforms fall into this category).

Every time a user loads a webpage, a micro-auction for ad space occurs; an AI agent representing an advertiser (any online merchant) evaluates the value of the ad slot and bids. The highest bidder wins, and the ad appears within milliseconds. By the time the page loads, the ad is in place. Programmatic digital advertising alone spends hundreds of billions of dollars annually, accounting for over 90% of current display ad budgets.

Web crawlers are another example. Autonomous AI agents roam the internet, follow links, and scrape web pages, inputting content into large-scale indexes and training pipelines. Similarly, data extraction tools pull raw information from web pages, widely used across many fields. More concerning is that by 2025, “malicious bots”—programs exploiting online business logic—account for 37% of internet traffic. Overall, over half of web traffic is generated by autonomous software agents.

Yet few are aware of these agents’ existence, and even fewer actively use them. While these agents are highly efficient for specific functions (like bidding for ad slots), their utility is limited by their specialized nature: crawlers only crawl, scrapers only extract, bid engines only bid. When these capabilities are integrated into a single program and controlled via a unified interface, the fundamental application paradigm shifts. This is what we now recognize as general AI agents. Their most fundamental transformation is the ability to perform multiple tasks within a single interface and operate across various applications and environments. These agents aim to enhance human productivity and efficiency: completing more tasks faster, and as they become more widespread, capturing an increasing share of web traffic.

So, what exactly is an agent? Simply put, it’s goal-oriented software: receives a goal, identifies the steps needed to achieve it, takes actions in a specific environment using available tools, until the goal is accomplished.

The user inputs prompts, which are sent to the agent’s runtime environment; the agent feeds prompts into a model acting as its “brain,” making decisions; it calls available tools (browser, APIs, databases, calendars, etc.) to execute tasks, absorbing action feedback, reasoning, and planning subsequent steps until reaching a preset termination condition (such as the user’s specified goal).

Gartner predicts that by the end of 2026, about 40% of enterprise applications will have embedded dedicated AI agents. McKinsey estimates that by 2030, AI agents will unlock a global consumer market of 3–5 trillion USD. Goldman Sachs forecasts that by 2030, agents will become the primary interface for knowledge work, eroding large parts of the SaaS market while expanding the entire software market.

Of course, these are forecasts, not facts, and some short-term predictions about AI agents have proven overly optimistic. But ignoring the scale of this “big gamble” is both difficult and naive: even if AI agents only realize a fraction of predicted growth, they will become consumers. And consumers need a way to pay for goods and services they want to buy.

Machines Need to Circulate Funds

Thus, the role of money emerges. Currency is a collaboration tool: a universal medium of exchange and accounting unit that enables humans to cooperate with strangers and settle transactions efficiently. It supports large-scale social cooperation, aggregating individual efforts into larger productive entities.

As AI agents take on more economic functions, they also need to connect to this universal layer of cooperation. But agents are structurally different “consumers,” with behavior patterns and optimization goals that diverge sharply from humans. They are not limited by human cognition or computation; their core mission is to massively amplify human output: completing more work in less time, often at higher resource consumption and finer granularity. They are also unaffected by advertising’s emotional influence on humans. By design, they are rational economic agents.

In this context, the role of money is both familiar and functionally extended:

• As a medium of exchange, minimizing transaction friction and enabling seamless value transfer between agents;

• As a unit of account, providing standardized measurement for precise cost-benefit analysis—assessing whether task compute costs match expected returns;

• As a store of value, allowing agents to retain purchasing power and efficiently allocate capital across time and tasks.

To realize these functions, it’s essential to distinguish between assets themselves and the infrastructure for their circulation. Money is a collaboration tool; payments are its execution mechanism. Essentially, payment is a way to settle debts: updating ledgers to prove value has actually transferred. For AI agents, this is the functional execution of contracts—transforming decisions into results and unlocking resources. Without settlement capability, agents are essentially stuck in a “read-only” state. They need a dedicated mechanism to pay for online goods and services.

But isn’t the machine already transferring funds?

Clearly, this is already feasible. AI agents can interface with the hundreds of billions of dollars circulating annually in online financial infrastructure. These systems revolve around specific checkout flows: humans confirm purchase intent, generate transaction tokens, and merchants process payments via their PSPs.

Take OpenAI and Stripe’s agent commerce protocol (ACP) as an example. ACP is an open-source API standard that, through standardized merchant catalog display, agent quoting, shopping cart logic, and user confirmation, delegates the purchase process to the merchant’s PSP. This allows AI agents to complete purchases on behalf of users. The most typical implementation of ACP today is the instant checkout feature in ChatGPT, supported by Stripe’s shared payment infrastructure. Users can shop (buy sneakers, order food, book restaurants) via natural language prompts within ChatGPT. Behind the scenes, ChatGPT sends limited-scope payment tokens to the merchant’s PSP, which completes the deduction.

Beyond ACP, as the agent commerce ecosystem matures, agent payments are growing. Claude Code and Codex can execute workflows using pre-funded user accounts; OpenClaw supports issuing virtual cards with spending limits for agents; Google’s UCP and AP2 use payment tokens linked to user credit cards and email addresses.

This system can operate without immediate overhaul. In human-AI collaborative checkout scenarios, this mode functions as designed.

Machines Are Indeed Transferring Funds—But Not Autonomously

However, the key point is: this is not the final form of AI agent payments. When applied to large-scale, continuous agent workflows, this model will become overwhelmed.

This emerging ecosystem is called the “virtual agent economy”: a network of interconnected digital markets where AI agents trade among themselves, generating economic value independent of human labor. Crucially, in this economy, the scale and speed of agent transactions and collaborations far exceed human oversight. This is where current commercial systems begin to reveal core economic and technical constraints.

Protocols like ACP rely on traditional payment mechanisms: credit cards, digital wallets, buy-now-pay-later services. Consumers and merchants using these still bear their costs: 2.9% + $0.30 per transaction, multi-day settlement, 120-day chargeback periods. For humans, this is manageable but inconvenient.

But agent transaction volumes are much larger. Systems often break down complex problems into tiny, sub-cent-dollar distributed tasks. Thousands of steps add up, and existing cost structures become unsustainable: imagine a micro-task worth $0.02 with a fixed fee of $0.30—an effective premium of 1500%.

This stems from deeper architectural issues. As Felipe Montealegre notes in “Internet Finance,” the modern financial system is just a collection of private servers. Value transfer requires authorized reconciliation between servers, resulting in settlement delays and layered fees. When AI agents initiate purchases via protocols like ACP, they trigger synchronous links: requests forwarded to Stripe, then to card issuers. Stripe charges fees, Visa and Mastercard charge fees, banks charge fees—all operating independently.

This reconciliation mechanism sets a speed limit on the entire economy. The 2024 BIS report states that a 1% increase in digital payment adoption boosts per capita GDP growth by 0.10 percentage points over two years. If eliminating human payment friction can produce such effects, the impact on speedier AI agents—whose transaction volumes are orders of magnitude higher—would be even greater.

Another hidden cost is permissions themselves. Traditional payment infrastructure is designed around discrete, high-value human transactions (at least a few dollars). Compliance systems like KYC, AML checks, chargeback systems, and partner banks are rational responses to legal liabilities at this scale. An API call costing $0.004—risk and complexity akin to a $50,000 wire transfer—receives similar overheads.

Nick Szabo posed a related question in 1999: the “psychological transaction cost”—the cognitive burden of small payments. Early micro-payment ventures failed not because of technical impossibility but because humans had to actively authorize each small payment. On a large scale, attention is more expensive than money.

AI systems seem to solve this: Claude Code deducts from pre-funded accounts without user interruption. But this is just a budgeted proxy—an agent operating within fixed limits, not an autonomous economic entity. Its scope is set at setup; it cannot negotiate for new resources or capabilities beyond preconfigured parameters, nor does it have an independent economic identity outside conversations. Szabo’s concern about upper limits reappears here.

Another key constraint is identity. In current human-AI checkout flows, AI agents essentially borrow user identities for transactions. The entire system assumes the payer is a natural person with legal identity, banking relationships, and personal responsibility. But AI agents (at least now) lack these attributes. Claude Code payments rely on user Stripe credentials, merchant fraud models, card issuer dispute rules, and bank settlement frameworks. An economy where each transaction is anchored to human legal identity is not truly an agent economy.

This raises unresolved legal issues: How do AI agents perform AML checks? Submit suspicious activity reports? Screen for sanctions violations? These questions are gaining federal attention, and answers may soon emerge. The US National Institute of Standards and Technology (NIST) recently published a concept paper on AI agent identity and authorization, listing it as an unresolved infrastructure challenge requiring new open standards.

Human-AI checkout processes are useful, but in the next stage—the AI agent economy—cost, autonomy, and identity are fundamental systemic constraints. Multi-day settlement and the lack of a 24/7 global payment rail further increase friction, though these are secondary to the structural issues above. To address these constraints, understanding how AI agents actually operate is crucial. Since agents are software running on the network, the most natural payment layer might be embedded within the network itself.

This is exemplified by a payment API call that initiates a transaction via an HTTP 402 POST request.

HTTP 402 has been reserved for decades but has never been truly implemented. It envisions a world where payments can be handled at the protocol layer—much like today’s identity verification. It only lacks two things: clear standards and a form of currency that can flow at network speed.

We already have a native network payment layer

Just as HTTP enables free, permissionless information flow on the internet, a global value transfer system based on public blockchains has formed at scale. Stablecoins circulate in hundreds of billions of dollars, with a current market cap exceeding $308 billion.

McKinsey and Artemis Analytics data show that by 2025, stablecoin payments will reach $390 billion, doubling from the previous year, mainly in B2B, P2P, card-linked consumer, and B2C remittances. While historically on-chain stablecoin activity was primarily transactional, specific blockchain data indicates that payments are becoming an independent and steadily growing segment.

In simple terms, stablecoins are software programmed to maintain a stable exchange value, usually pegged to the US dollar. They can be minted or redeemed via smart contracts. These software assets have key features making them especially suitable for network-native payments, particularly in AI agent commerce.

The most obvious advantage is economic: stablecoin transactions are orders of magnitude cheaper than traditional payment rails, as they eliminate intermediaries. Transactions are just redistribution of balances on shared digital ledgers, with resource consumption mainly for updating balances—paid as Gas fees. Current mainnet Gas fees are often below one cent. Compared to credit card fees, the cost difference is enormous.

A more unique advantage is programmability. As Hadfield and Koh pointed out, “programmable money” is needed for agents to autonomously coordinate large-scale complex economic activities. Stablecoins issued and redeemed via smart contracts can encode payment conditions directly: conditional releases, spending limits, periodic transfers, etc. Agents can control wallets with cryptographic keys, signing transactions directly without human credentials at the payment layer.

Haseeb Qureshi sharply notes: cryptocurrencies are better suited for agents than humans. Agents can verify transaction details, audit smart contract code, confirm settlement within seconds—without trusting counterparties or legal entities. Since code is deterministic: same input always yields same output. A smart contract stating “release payment if condition X is met” executes automatically each time the condition is fulfilled.

Before signing an economic agreement via smart contracts, agents can know the outcome in all scenarios. They can read code, verify logic, confirm results in milliseconds. Stablecoins are just code; wallets are just code. Agents holding funds, executing transactions, signing agreements—like sending HTTP requests—are natural.

The Missing Link

HTTP 402 defines how servers indicate that resources require payment. Stablecoins provide a form of currency that can flow at network speed. Combining the two is no longer a traditional checkout but more like an HTTP handshake.

Take a vending machine: it offers specific products (soda, chocolate), and only dispenses after receiving full payment. The operator doesn’t produce the goods but provides neutral infrastructure for willing buyers to access resources.

This is the pattern of network-native AI agent payments: agent initiates request → server returns payment demand → agent completes payment → resource is unlocked. HTTP 402 provides the status code; stablecoins provide the settlement layer. The missing piece is a network-native vending machine binding the two.

x402: The Network-Native Payment Layer

In May 2025, Coinbase’s engineering lead Erik Reppel, along with colleagues Kevin Leffew, Dan Kim, and Nemil Dalal, published a white paper that for the first time in 29 years truly realized HTTP 402: the x402 protocol.

The core premise is simple: the internet has always needed a native way to send and receive payments, and stablecoins make this possible. Coinbase began exploring internet payment standards as early as 2015, but the idea was too ahead of its time. By May 2025, conditions had matured: on-chain fees on networks like Solana and Base are as low as a few cents; stablecoin supply is rapidly growing, approaching $300 billion; and agent commerce has formed sufficiently concrete use cases.

What is x402?

x402 is an open-source payment protocol that standardizes value exchange between network clients and servers via HTTP 402 and stablecoins. It’s the missing network-native vending machine: buyer initiates request, seller quotes, payment is settled directly via HTTP, with no pre-established relationship needed.

Its core is to separate three components:

• Transport layer: how data flows between parties;

• Payment logic: how value transfer is structured;

• Settlement network: where value is ultimately recorded on-chain.

This separation makes x402 scalable. HTTP is the primary transport, 402 status code is the native signal, but the same payment logic can run over MCP or A2A without changing standards. In practice, x402 acts as a lightweight middleware integrated into existing network infrastructure, with servers requiring only a single function call. Clients can pay any endpoint supporting it, without pre-establishing relationships.

How does x402 work?

In brief, the x402 payment process is:

1. Client requests paid resources from server;
2. Server responds with HTTP 402, including machine-readable payment instructions;
3. Client constructs a signed payment payload and resubmits the request;
4. Payload verification passes, server fulfills original request. Note: payment is submitted and settled on-chain first; proof of settlement is transmitted via Facilitator to confirm payment;
5. After confirmation, server returns 200 OK with resource and transaction proof to client.

Details vary depending on blockchain architecture, explained below. The key is each step involves two layers:

• Off-chain communication: information exchange;

• On-chain settlement: value transfer.

Communication Layer

x402 natively adapts to transport protocols. Although primarily implemented over HTTP, the protocol is compatible with existing data transfer methods, requiring no extra requests outside typical client-server flows. Any request-response system can implement x402 payment flows, meaning it can run on: HTTP APIs and REST services; AI agent tools and resources via MCP; direct agent-to-agent (A2A) payments.

Main off-chain components are client and server, applicable to all supported transport layers.

Client, as the buyer: the entity requesting access to paid network resources, can be a developer using an HTTP client or an AI agent running as a network client. It sends initial requests, constructs valid payment payloads, and retries with a Payment-Signature header containing the signed payload.

Server, as the seller/resource provider: typically an API or content endpoint, ultimately any digital resource accessible via the network. It responds with payment demands, verifies incoming payment payloads, and upon confirmation, returns resources.

For AI agents, no separate integration of transport layers is needed; payments are handled automatically across HTTP APIs, MCP tools, and A2A interactions.

On-Chain Layer

The on-chain layer of the x402 protocol is where payments occur. It includes a wallet for storing funds and authorizing payments, a Facilitator service for verifying payloads and submitting payments on-chain, and the actual stablecoin or token contracts for transferring value.

To pay with x402, the client needs a pre-funded crypto wallet, consisting of a public and private key pair. The public key acts as an anonymous identifier—similar to a network address or routing number. The private key authorizes the client to sign and execute transactions, like a password. When an agent needs to access paid resources, it signs a transaction authorization with this private key, creating a payment payload. The signed payload includes the public key, allowing the server to independently verify the sender and confirm the on-chain transaction.

For on-chain settlement, the server uses a Facilitator—a transaction relay and gas abstraction service. It receives the signed payment payload, verifies it against token authorization parameters, and broadcasts the transfer on behalf of the server, paying gas fees. When the server receives the signed payload, it can process on-chain settlement directly or POST it to the Facilitator’s /settle endpoint. The Facilitator verifies the signature, calls the token’s transferWithAuthorization function, pays gas from its own balance, and broadcasts the transaction.

Crucially, the Facilitator is not a custodian. It executes only the transfer authorized by the client’s signature. It cannot redirect funds or modify payment terms; it only executes or rejects signed transactions. Coinbase runs a Facilitator on Base and Solana for USDC payments, but the role is open. Any server that prefers not to outsource can run its own verification logic locally.

x402: EVM-compatible chains vs. Solana

The HTTP handshake in the x402 payment flow is the same across chains. Differences lie in the on-chain settlement mechanisms, reflecting the architectural divergence between EVM-compatible chains and Solana.

EVM-compatible chains: x402 uses EIP-3009 as its core token transfer primitive. EIP-3009, authored by Coinbase engineers Peter Jihoon Kim, Kevin Britz, and David Knott in 2020, facilitates hundreds of billions of USDC transfers monthly.

Its key mechanism is the separation of authorization and execution. EIP-3009 provides a one-time off-chain cryptographic signature that authorizes a transfer of a specified amount to a specific address within a validity window. This signature becomes the payment payload in x402.

Two main functions are involved: transferWithAuthorization and receiveWithAuthorization. The client signs an EIP-712 structured message containing payment details and a random 32-byte nonce. The nonce allows multiple parallel authorizations without ordering constraints.

When the server receives the Payment-Signature header, it performs deterministic validation: matching recipient address, correct amount, acceptable token contract, valid timestamp, and cryptographic validity of the signature. Because authorization and execution are separated, the server verifies the signed payload before submitting anything on-chain. Invalid signatures, mismatched amounts, or expired timestamps are rejected, with no loss to either party.

If all checks pass, the server or its proxy calls the token’s transferWithAuthorization function. The proxy pays gas from its own balance, so the client only needs to hold the payment assets, not native gas tokens. After confirmation, the server returns the resource and a transaction hash and block number for independent verification.

Solana: On Solana, x402 employs a different settlement mechanism reflecting the chain’s transaction structure. Instead of off-chain signatures authorizing future transfers, the client constructs and partially signs a complete SPL token transfer transaction, encoding it as a base64 payload in the Payment-Signature header. It’s “partial” because the client signs the transfer instruction while designating the Facilitator as the fee payer, and the Facilitator must sign to broadcast.

Before constructing the transaction, the client queries the /supported endpoint to get the facilitator’s fee address and confirm network support. The facilitator then verifies the partially signed transaction, adds its own signature as fee payer, and broadcasts it. The client pays fees with USDC, not SOL.

Both EVM and Solana flows achieve atomic settlement via their native mechanisms: EVM uses off-chain signatures for future transfers; Solana completes and broadcasts partially constructed transactions. Each chain’s architecture offers advantages: EIP-3009 shifts gas costs to the server, suitable for high-value, infrequent payments; Solana’s design favors high-throughput, low-latency payments.

In essence, x402 is chain-agnostic. It uses CAIP-2 network identifiers, enabling routing across blockchains like Base, Solana, Polygon, Scroll, Avalanche, etc., in a single handshake. The server specifies supported networks and assets in the 402 response; the client chooses from supported options. As the facilitator ecosystem matures and new chains meet x402 standards, the protocol can scale without changing its core.

What Is the Unique Value of x402?

It’s worth viewing x402’s value from a broader perspective.

Online transaction capability is increasingly a fundamental requirement for AI agents. As software communicating via HTTP and continuously consuming network resources, payments are central to their operation. But the underlying infrastructure supporting such basic functions was not designed for AI agents. Traditional human proxy checkout flows involve manual infrastructure, credentials, and intermediaries designed for human consumers. x402 runs directly on the native web frameworks used by agents.

The key difference is structural. Costs are the most obvious: on supported chains like Base and Solana, stablecoin transactions cost only a few cents, representing the only on-chain transaction cost in the current x402 payment flow. This aligns with the fine-grained economic model of AI agents (e.g., per call, per task). Charging 2.9% + $0.30 per transaction would quickly make the model unviable.

Settlement mechanisms go deeper. Because payment conditions are enforced at execution, only transactions meeting predefined criteria are finalized. The system enforces this via code, removing the need for trust or counterparty knowledge. This is the difference between post-verification and pre-execution, and it’s key to securely delegating high-risk workflows. Operators only need to define limits: daily caps, per-transaction limits, whitelisted addresses. Agents operate within these bounds without requiring approval each time.

Beyond costs and settlement, identity verification is another challenge. Each transaction signed by an agent uses the same cryptographic wallet address—a consistent, verifiable identifier owned and controlled by the agent. No need to borrow human credentials for each service; the wallet moves with the agent, ensuring consistent presentation.

But what does this really mean?

Fine-grained pricing—pay-per-article, pay-per-video, pay-per-stream—has long been the most straightforward digital content business model. Early internet relied on this idea, but micro-payments failed due to high transaction costs and cognitive burdens of approval. x402 solves these issues: pricing can truly reflect consumption, rather than bundling partial content in subscriptions.

For AI agents, fine-grained pricing is essential: resources are consumed in discrete, measurable units (e.g., reasoning per prompt, market data per query, compute per job, API calls per task). Mapping this naturally to subscription models is difficult; subscription pricing exists largely because micro-payments are infeasible. But if each transaction costs only fractions of a cent, micro-payments become practical.

x402 also reshapes the software market for agents. Previously, acquiring features meant paying for subscriptions or building in-house. As inference costs fall, self-building becomes more feasible. x402 introduces a third option: agents can access features on-demand during workflows, paying only for actual usage, without replicating features via inference. This enables real-time cost-based decision-making, shifting the software market toward access rather than ownership.

The most profound impact is a shift in product architecture. Bundling goods and services is driven by transaction costs making fine pricing impractical. For example, a news article bundles interviews, photos, background info because selling each separately is costly. Meanwhile, AI agents can track what users read, coordinate with content providers, and push only the latest or relevant content, paying per actual content consumed. This logic applies to any digital product with separable components. As micro-payments make individual content economically viable, a retrieval ecosystem may emerge where content creators are paid per use, and users receive more personalized, less standardized products.

This also applies to how AI agents operate in workflows. When encountering paywalls, agents receive a 402 response with machine-readable instructions, construct a signed payment payload, settle on-chain, and continue execution. The workflow remains uninterrupted because of the seamless integration. The only requirement is that the user has a pre-funded wallet, configured once by the operator.

This is especially important in multi-agent or cluster systems. Modern workflows decompose into specialized agents that coordinate via handoffs: one agent calls another, which calls a service, which may call yet another agent. When payments are involved, a centralized billing relationship can become a bottleneck. The stateless design of x402 means each handoff is independently settled, allowing the payment layer to scale with the workflow rather than dominate it.

All of this is straightforward to integrate. x402 comes with complete reference implementations: core protocol libraries, server middleware for Express.js and Next.js, and client libraries for browsers and Node.js. Server integration requires only a single function call. Agents can access paid endpoints, receive 402 errors, construct signed payloads, and settle on-chain—all without custom payment logic.

Given this, let’s look at the current adoption status of x402.

Current Status of x402

Launched on May 6, 2025, x402 initially supported USDC on Base. Over nine months, it processed 164 million transactions totaling $46.4 million, involving 447,000 unique buyers and 89,000 sellers.

Growth was not linear; at peak on November 17, x402 accounted for 19% of Base’s daily 17 million transactions—an astonishing rate of saturation for a single chain. Afterwards, as overall activity declined, transaction volume dropped sharply, though it rebounded significantly in March.

Data reveals what it tells us—and what it doesn’t. Both are worth careful analysis.

x402 is a chain-agnostic framework, currently operating on a few but growing number of chains. So far, Base dominates with 125 million transactions and $3.9 billion in volume, thanks to its early mover advantage and Coinbase’s native infrastructure, supporting a vibrant ecosystem of 27 active platforms. Solana launched in July 2025, with 38 million transactions and nearly $7 million in volume so far. By early February 2026, Solana’s share surged to 97% of daily transaction volume, yet Coinbase still leads in active buyers (423,000 vs. 23,000) and sellers (68,000 vs. 20,000), indicating demand remains concentrated on Base despite Solana’s growing share.

Beyond Base and Solana, x402 is actively expanding support to chains like Polygon, Avalanche, Sei, Optimism, and Arbitrum. These are less active but growing. It’s too early to tell which chains will dominate, but likely depends on specific applications rather than architecture alone.

Meanwhile, the ecosystem of payment providers is also expanding. Coinbase remains dominant in volume (78 million transactions, $27.3 million volume), benefiting from zero-fee models and early deployment. But the ecosystem is diversifying: third-party providers like PayAI, Dexter, Daydreams, and Virtuals Protocol have gained traction, handling most recent transaction volume and value.

Not all agent activity is genuine, though. For example, Moltbook, a viral social network for AI agents, attracted media attention claiming millions of agents posting and coordinating. Later, it was found that much of this activity was pattern-matching social media behavior, often with human involvement.

The same scrutiny applies to x402. Artemis Analytics’ dashboard distinguishes real from fake transactions, with fake ones often indicating money laundering. Some use x402 to launch “meme coins,” boosting rankings on x402scan and converting exposure into token sales.

Although x402 officially launched in May 2025, the first large-scale active period only emerged in late Q4 2025. Most activity then was meme coin-related; during much of November and early December, gaming transactions even exceeded real transactions.

As total x402 volume declined over recent months, the proportion of genuine transactions increased. In February, five consecutive days saw 100% real transaction volume.

Simulated transactions help stress-test infrastructure, verify settlement, and demonstrate throughput. But economic incentives and subsequent activity can distort assessments of adoption quality. Whether these transactions involve meme coins, airdrops, or other tokens, they are ultimately behaviors optimized for profit, not genuine utility.

While data is useful, it only tells part of the story. To better understand x402’s adoption, it’s worth examining the ecosystem.

x402 Ecosystem

The x402 ecosystem comprises various participants in the payment flow: client representatives (buyers requesting network resources for AI agents), servers (service and resource endpoints—APIs, data providers, content platforms, or any digital resource accessible via x402), service providers (third parties handling payment verification and on-chain settlement), and supporting infrastructure/tools (SDKs, analytics, wallets, developer tools) enabling development on x402.

Most of the ecosystem remains early-stage, but integrations and experiments by various service partners reveal industry enthusiasm and interest.

x402 in the Broader Agent Commerce Stack

It’s crucial to step back and recognize that agent commerce is a complex, multi-layered system spanning many industries. From discovery, authorization, checkout, to agent coordination, each step involves different protocols and major tech and finance players.

In business: as previously mentioned, ACP defines how AI agents handle the entire shopping process—from product discovery to checkout—independent of payment processors, allowing merchants to connect with existing payment providers. Google’s UCP (Universal Commerce Protocol) plays a similar role within Google’s ecosystem: it standardizes how agents on Google Search and Gemini discover products, negotiate prices, and complete purchases. ACP is optimized for conversational interfaces like ChatGPT, while UCP targets broader Google products. Google’s own agent payment protocol (AP2) sits below, handling authorization: before an agent can spend, AP2 issues an encrypted, signed authorization confirming the user’s permission up to a certain amount. Each transaction generates an auditable, tamper-proof record, enabling merchants and financial institutions to verify legitimacy. Google’s A2A (now maintained by Linux Foundation with over 100 supporting organizations) addresses a different problem: how different companies’ and platforms’ agents communicate when transferring tasks or data. It provides a common language for coordination.

x402 enhances this stack in multiple ways. Google and Coinbase have built an A2A x402 extension, as a production-ready module within AP2, dedicated to agent-based stablecoin payments. It clearly separates: AP2 issues authorization commands confirming agent spending rights; x402 executes actual per-call transfers after authorization, settling on-chain in USDC. Cloudflare integrated x402 into its Agents SDK and MCP server tools, so any MCP-available tool or API can require 402 payments before granting access. In practice, assistant driven by ACP can discover services via MCP, see 402 responses, get operator approval, and settle via x402 on each call, while ACP manages overall order and record-keeping.

Traditional payment networks are also entering agent payments. Visa’s Trusted Agent Protocol (TAP) helps merchants identify and verify AI agents during checkout, distinguishing legitimate shopping agents from malicious bots. TAP provides cryptographic signatures for verified agents, which can be shown during browsing and checkout. Built on Cloudflare’s Web Bot Auth infrastructure, it’s supported by Microsoft, Stripe, Shopify, and Worldpay. Visa collaborates with Coinbase to ensure TAP is compatible with x402. Similarly, Mastercard launched Agent Pay, with its own merchant verification framework: tokenized agent credentials that merchants can register and verify before settlement. While Mastercard has not announced direct x402 integration, it is an AP2 partner, and Cloudflare is working with Mastercard on the same Web Bot Auth infrastructure supporting x402 identity.

Stripe is another key player advancing agent payments. In February 2026, Stripe launched a “machine payments” preview supporting USDC on Base via x402. Developers can charge API calls, MCP requests, or HTTP endpoints using the standard PaymentIntents API (the same infrastructure used for credit card payments). They also introduced shared payment tokens: scope-limited, time-bound credentials that agents can use to initiate payments without exposing underlying accounts, which non-Stripe merchants can forward to their own processors.

On March 18, Tempo reintroduced the PaymentIntents API as the foundation of the Machine Payment Protocol (MPP). MPP is a new open standard for agent payments launched alongside Tempo’s mainnet. It adopts the same HTTP 402 signaling as x402, aiming to solve the same fundamental problem, but with two architectural differences: a “session” mechanism allowing clients to deposit funds into on-chain escrow accounts and sign off-chain vouchers; and support for multiple payment methods, including Tempo native stablecoins, Visa, Lightspark, and Stripe, as well as Bitcoin Lightning and fiat.

Unlike x402 and protocols like ACP/UCP/A2A, MPP and Tempo are more competitive than complementary. Tempo has raised $500 million from Stripe and Paradigm, and partners with Visa, Mastercard, Anthropic, OpenAI, and Shopify. Their competitive dynamics merit future analysis; but it’s worth noting that the two protocols are compatible. Cloudflare’s documentation confirms MPP is backward compatible with x402: existing x402 flows can be directly mapped to MPP “charge” intents, and Stripe supports both.

Understanding these diverse agent commerce protocols hinges on their roles. ACP and UCP enable AI agents to handle online shopping on behalf of users. AP2 manages authorization and audit. Visa and Mastercard provide trust and identity verification for merchants. Stripe aims to integrate developers into all these protocols. x402 sits at the execution layer: a neutral payment API that any agent, any service, any developer can implement with a few lines of code, without merchant accounts, merchant protocols, or card schemes. When an agent accesses a paid endpoint (API, MCP, or Stripe-controlled resource), the server responds with a payment request; the agent pays with stablecoins; the request completes. Funds flow, workflows proceed. On-chain infrastructure enables finer-grained, faster, and more programmable AI agent economies than traditional payment systems.

Coinbase

Coinbase is the principal