Micropayments have been the web's "someday" idea since at least the 1990s: pay a fraction of a cent per article, per API call, per song, instead of bundling everything into a subscription or giving it away and selling ads against it. It never happened at scale for human commerce. It's happening now for machines, and the reason isn't that the idea got better - it's that the caller changed.
A human checking out pays a fixed cost on every transaction regardless of the amount: a card network fee, a moment of attention to confirm "yes, charge me," sometimes a password or a biometric prompt. None of that scales down to a two-cent charge. A $0.02 microtransaction processed through typical card rails can cost more in fixed fees than the transaction itself is worth, and no human wants to approve a checkout flow a hundred times in a browsing session anyway. The market's answer was subscriptions and ad-supported free tiers - bundle the cost so nobody has to make a purchasing decision every few seconds.
That bundling solved the human-attention problem. It didn't solve the pricing problem - it just hid it, cross-subsidizing light users with heavy users' subscription fees, or replacing payment with a slower, noisier currency (attention, data) instead.
An agent doesn't experience checkout friction. Signing a payment and attaching it to a request is the same amount of "work" for code whether the amount is $0.02 or $20 - there's no popup, no hesitation, no decision fatigue from doing it a thousand times a day. The two things that made micropayments impractical for humans - fixed transaction cost and the cost of a human's attention - both disappear when the caller is a program.
What's left is a settlement problem: you still need a payment rail where clearing a few-cent transaction doesn't itself cost more than a few cents. Stablecoin settlement on a low-fee chain answers that directly. DimeBox settles over USDC on Base specifically because the transaction cost of moving a few cents of value there doesn't erase the value being moved - see why USDC on Base for the reasoning. And the signing step itself is gasless from the caller's side: an agent signs an authorization rather than broadcasting and paying for its own transaction, which is what makes EIP-3009 the mechanism underneath, not an incidental detail.
The prices involved are genuinely small: $0.02 to draft an email, $0.01 to send one, $0.03 for a priority-delivered receive, $1.00 one-time to claim a custom inbox name. None of those are prices a card network would clear efficiently one at a time. They're exactly the range x402 over USDC is built for - see how the 402 to sign to retry flow works for the mechanics of a single call, and what x402 is if you haven't seen the protocol before.
The wallet alternative sidesteps the card-rail problem a different way, rather than avoiding it: fund a wallet once through a card-based checkout (one transaction, one fixed fee, amortized over however much balance you load), then authorize individual $0.01-$0.03 calls against that balance with a bearer secret instead of a new signature each time. The fixed cost of touching a card network happens once, at top-up; every call after that is pure ledger arithmetic. See how the wallet works.
A human website visitor who won't pay still gets monetized somehow - through ads, through data collection, through a free tier subsidized by someone else's subscription. An agent calling an API has none of those options available to the API provider: there's no ad to show a script, no attention to sell, no profile to build on a caller that discards its state after one task. If the API isn't willing to work for free, the only lever left is a price the caller can actually pay inline, which is exactly what pay-per-call pricing provides and ad-supported or freemium models don't. It's also why outbound email specifically can't be free here - a free send endpoint with no other monetization to fall back on is just a free spam cannon.
Because each call carries its own payment, there's nothing to reconcile after the fact. No invoice, no "usage this month," no separate billing system to keep in sync with what was actually consumed. The cost of every action is legible at the moment it happens - which matters more as the caller making these decisions stops being one person and starts being a fleet of agents running unattended. That's the broader shift machine-to-machine payments are part of: not "humans buying things cheaper," but software transacting with other software at a granularity no human-facing payment system was ever built to handle.