Part of a series on building cz-agents → under the hood.
Where we left off
In June, I compared the three camps of agentic payments here—x402, card tokens, and banks—and argued that x402 will take machine-to-machine micropayments, while cards and banks split the rest. I won't repeat the basics of the protocol, how the 402 status code works, or why cards don't add up economically on tiny amounts; anyone who needs a refresher will find it in that article.
This piece is about something else. A few weeks have passed; the numbers and the big-player backing have both jumped by an order of magnitude, and for the first time, I can compare those figures against what I actually see in my own logs. The gap between the two is the entire point of what follows.
The numbers are hard to miss
I'll start with what speaks for x402, because that's the more honest approach. According to aggregate Chainalysis data, the protocol has processed over 169 million payments so far, between roughly 590,000 buyers and 100,000 sellers. That's no longer a conference demo.
More interesting than the volume is the structural shift. The share of transactions above one dollar rose from 49% in early 2025 to roughly 95% in early 2026. In other words: x402 is ceasing to be a toy for micro-cents and is starting to handle amounts that actually show up on the books. Anyone who wrote the protocol off as a curiosity for paying fractions of a cent per API query is looking at an old snapshot.
Above all, a lineup has assembled that is hard to dismiss as crypto-bubble enthusiasts:
- Stripe launched x402 support on February 10, 2026, in the preview of its Machine Payments product (USDC on the Base network).
- Ripple added native x402 to the XRP Ledger on June 21, 2026.
- AWS built x402 into Bedrock AgentCore Payments—together with Coinbase and Stripe—and also lets you monetize agent traffic on CloudFront and WAF. Sites behind Amazon's edge can charge agents right at the edge, without touching their core application.
- Google is a founding participant in the x402 Foundation and built the protocol into its Agent Payments Protocol (AP2).
- The x402 Foundation itself, founded in September 2025 by Coinbase and Cloudflare, moved to formal governance under the Linux Foundation on April 2, 2026. With this move, the protocol stopped being the property of a single exchange.
When Stripe, Amazon, Google, and Ripple all adopt the same standard in a single year, and the foundation hands it over to neutral governance, that's usually a signal that infrastructure is being built—not that theater is being staged. At least, that's how it looks from the outside.
What I see on my own servers: nothing
I run eight public MCP servers—the Czech business register, due diligence, sanctions lists, insolvency, central-bank FX rates, VAT, European company registers, and real-estate data—plus one paid server. They're exactly the kind of services discussed in the context of the agentic economy: machine-readable data, a small query, a clearly bounded answer, and no reason a human should have to fill out a form to pay for it.
Total agentic payments processed across all of them: zero.
Before anyone turns that into a headline, I should state the uncomfortable truth upfront—otherwise, you'd figure it out yourself and be right: my servers don't accept x402. They have no wallets, they don't return a 402 status with payment terms, and they can't verify signed stablecoin payments. Money reaches me via Stripe subscriptions and API keys with tier limits. An agent wanting to pay me for a single query has no way to do so.
So zero payments isn't evidence against x402. It's evidence about me. Concluding "see, nobody uses this protocol" would be a cheap trick: building a straw man out of my own inaction just to knock it down. The absence of payments on a server that can't accept them says nothing about demand.
The interesting part is something else—something that is in the logs.
The only things arriving from the x402 economy are the scouts
My access logs regularly show a probe identifying itself as 402.ad-mcp-probe. It belongs to the 402.ad catalog, which describes itself as a search engine for the agentic economy. It didn't just hit one server; it systematically went through all nine. And it's not alone—my logs show a whole fleet of similar indexing services mapping out who can do what.
The logic behind that catalog is the substantive part. It indexes two categories: "MCP server" and "x402 API." When its probe hits an endpoint that returns a free response, it files it under the first bucket. If it hits an endpoint returning a 402 or 401, it marks it as paid, and potentially x402-compatible. Its own programmatic interface for registering a new service costs 0.10 USDC, payable via x402. The catalog of the agentic economy charges for a listing using the protocol of the agentic economy. It's a service that doesn't just index the protocol; it uses it.
Boiled down to the single sentence this piece exists for: the only things that have actually reached me from the entire x402 economy are probes checking whether I can accept a payment. Not agents with wallets. Not demand. Just mappers.
Infrastructure gets built first. Catalogs take inventory of who can accept payments before there is any paying traffic. That's an observation, not a complaint—but it can be read two ways, and honesty demands looking at both.
Two readings of the same thing
First reading: rails before the train. That's how every payment network comes to be. Before anyone can pay by card, a terminal has to exist; before a terminal exists, someone has to walk from shop to shop to find out who wants one. The mapping phase always precedes demand, and the numbers above suggest the train is already running somewhere—just not on my rails. If this were purely hype, Stripe wouldn't have shipped a product, AWS wouldn't have put it in the CloudFront billing layer, and the Linux Foundation wouldn't have taken it under its wing.
Second reading: rails for a train that will never arrive. That's also how every tech bubble starts. Enthusiasts build infrastructure, catalogs index it, the ecosystem congratulates itself on its growth—and the end customer never arrives, because their problem was solvable in another, cheaper way. Probes from a catalog aren't demand. They are someone else's sunk cost on a bet that demand will materialize.
I don't know which of these two readings is correct, and I won't pretend to. But I do know what signals to look for, which is more useful:
- Will a probe arrive asking about price, rather than just existence? The difference between "I have you in the catalog" and "how much does this query cost?" is the difference between a map and a market.
- Will an agent show up in the logs that receives a 401 and actually tries to pay? Today, agents just leave upon refusal. When one of them finally tries to resolve a refusal with a payment, the nature of the traffic will have changed.
- Will a human customer ask? The strongest signal isn't machine-made. When someone building an agent writes to me wanting to pay per unit—because a subscription doesn't fit their needs—the debate is over.
I haven't seen a single one of those three signals yet. That's a fact, not an opinion—and it's the only thing I can honestly claim about x402 demand based on my own data.
So should I turn x402 on?
This is the question every API operator asks themselves after reading the numbers above. I'll work through it using my own case, because there is no universal answer.
For. The barrier for an agent is zero: no registration, no key, no waiting for a human to approve access. My data is exactly the kind of small query worth paying for per unit—one company check, one FX rate, one sanctions scan. With the ecosystem now being pushed by Stripe, AWS, and Google, the integration path will keep getting shorter. What takes a week of work today could be a library and three lines of config a year from now.
Against. My paying customers are people with subscriptions, not agents with wallets. Billing in USDC means, in the Czech context, an entirely new chapter of tax and accounting work—overhead I'd be taking on for demand that no one has actually expressed yet. Furthermore, every additional payment path is one more thing that can break: more code, a larger attack surface, and more things to monitor in a system where I'm already tracking tiers, quotas, and per-query limits.
Decision: I'm not turning it on—but I'll set up a gauge. This isn't because I don't believe in x402. I believe in it just as much as I did in June: it will eventually take over machine-to-machine micropayments. I'm not turning it on because between "the protocol is growing" and "someone will buy my specific data per unit" lies a massive assumption I have no data to back up. Turning x402 on today would mean building a terminal based on someone else's numbers, hoping the mappers who visit me will one day bring a buyer with them.
What I'll do instead is cheaper and more informative: I'll measure the three signals from the previous section. I already have traffic classification on my servers. I can tell a catalog probe from a real tool call—which, incidentally, is the distinction where a lot of confident adoption numbers in this field fall apart. When the first agent wanting to pay lands in my logs, or the first human asks to pay per unit, it'll be a bet backed by evidence, not just a trend. Until then, waiting is my cheapest option. It's also reversible, which is more than you can say for a half-built payment layer.
What I take from this
The answer to "is x402 exploding?" is, by every available metric, yes. My logs don't contradict that, because my logs know nothing about it. That's the honest version. Zero payments on a server with no payment gateway is not a data point about the protocol; it's a data point about my prioritization.
What is a data point about the protocol is the probe. Someone is spending money to map out who can accept machine payments—and doing so before they have anyone to sell the map to. That's either the harbinger of something massive, or an expensive inventory of a market that will never form. Anyone who tells you today, with absolute certainty, which of the two it is, is selling you something.
Oddly, that uncertainty doesn't make me nervous. It means I don't have to decide right now—I just need to know what to watch. When demand appears, it will show up in my logs before I read about it in a press release. That's the only edge I have over the big players: I don't have to place my bets in advance.
Source for x402 adoption figures: Chainalysis — x402 agentic payments adoption. Traffic data on my own servers comes from access log classification across my portfolio of MCP servers.
Top comments (0)