Agentic commerce puts an AI between the human and the transaction. Machine payments remove the human from the equation entirely.
This distinction matters more than it sounds. When a user tells an AI agent "book me a hotel under $200," a human is still the principal — the agent is executing a delegated decision. When a server pays another server $0.001 for an API response, there's no human principal at all. The machine decided it needed data, found a source, paid for it, and consumed it — autonomously.
Machine-to-machine (M2M) payments are the logical endpoint of the shift from human-driven to machine-driven economic activity. As Annabelle Huang, CEO of Altius Labs, wrote in CoinDesk: "If continuous M2M payments are the new electricity, then blockchains — the rails upon which these microtransactions will occur — must be seen as the new power grid." The IoT monetization market alone reached $1.01 trillion in 2024 and is growing at 46.4% CAGR through 2034.
This article maps the landscape: what M2M payments are, how they differ from agentic commerce, what infrastructure they require, and why protocols like x402 are the enabling layer.
The Autonomy Spectrum
Not all machine transactions are the same. It helps to think of a spectrum:
| Level | Description | Example | Human Role |
|---|---|---|---|
| Human-initiated | Person clicks "buy" | Shopping on Amazon | Full control |
| AI-assisted | Agent recommends, human approves | "I found 3 flights — which one?" | Approval gate |
| AI-directed | Agent buys within human-set rules | "Book the cheapest direct flight" | Budget and rules |
| Fully autonomous | Machine transacts with no human | Server pays for API data | None |
Agentic commerce operates at levels 2 and 3. Machine payments operate at level 4. The infrastructure requirements — identity, authorization, payment rails, dispute resolution — scale dramatically as you move down the spectrum.
What Machine Payments Look Like in Practice
API micropayments
The most immediate use case. Today, API providers sell access via monthly subscriptions or pre-purchased credit blocks. This model has two problems:
- Overcommitment. Buyers pay for capacity they don't use.
- Access barriers. New consumers need to create accounts, provide payment methods, and commit to pricing tiers before making a single request.
With machine payments via x402, the model inverts. A machine sends a request. The server responds with 402 Payment Required and a price — starting as low as $0.01 USDC on Stripe's implementation. The machine signs a payment authorization. The server verifies, settles, and delivers the response. No account. No subscription. No human. The protocol emphasizes what its creators call the "five zeros": zero protocol fees, zero wait, zero friction, zero centralization, and zero restrictions.
This unlocks a long tail of API monetization. Services that couldn't justify subscription pricing — a weather station's hyperlocal data, a niche ML model's predictions, a specialized translation engine — become viable when any machine on the internet can pay per request.
IoT device commerce
The world has roughly 18 billion connected IoT devices. Most are commercially inert — they generate and consume data but can't participate in economic transactions. Machine payments change this.
Consider the examples:
- A factory sensor detects an anomaly and pays for a diagnostic analysis from a specialized ML service.
- A smart energy meter buys excess solar power from a neighbor's meter at a programmatically negotiated price.
- An agricultural drone pays for real-time weather data before adjusting its flight path.
- A supply chain tracker pays for customs clearance documentation from a compliance API.
Each of these transactions is too small, too frequent, and too time-sensitive for human involvement. They need payment rails with near-zero overhead and sub-second settlement.
Autonomous vehicle payments
Autonomous vehicles are rolling payment endpoints. They need to pay for:
- Charging. An EV navigates to a station, negotiates a rate, and pays — all machine-to-machine.
- Tolls. Dynamic toll pricing based on congestion, vehicle type, and route.
- Parking. Real-time space discovery, reservation, and payment.
- Maintenance. Automated parts ordering and service scheduling based on sensor diagnostics.
- Insurance. Per-trip or per-mile coverage purchased dynamically based on route risk.
None of these transactions should require a human opening an app.
Infrastructure-to-infrastructure
In cloud computing, services consume other services. A container spins up, consumes compute from a GPU cluster, fetches data from a storage provider, and calls an external API — all within seconds. Today, these inter-service costs are reconciled through centralized billing at the platform level (AWS, GCP). Machine payments enable a decentralized alternative where each service pays the next directly, in real time.
This isn't just about decentralization for its own sake. Direct settlement between services enables:
- True multi-cloud pricing competition. Services choose the cheapest provider for each request rather than being locked into a single platform.
- Granular cost attribution. Every compute cycle, storage byte, and API call has a direct payment record — no more estimated cost allocation.
- Permissionless service composition. Any service can consume any other service without platform approval or billing integration.
The Infrastructure Stack for Machine Payments
Machine payments require four infrastructure layers. Miss any one and the system breaks.
1. Machine identity
Humans authenticate with passwords, biometrics, and multi-factor tokens. Machines need their own identity layer:
- Cryptographic keys as the primary identity anchor. Each machine or service has a signing key that identifies it uniquely.
- Verifiable credentials that attest to a machine's properties: who deployed it, what permissions it has, what spending limits apply.
- Decentralized identifiers (DIDs) that work across platforms without relying on a centralized registry.
TEE-secured keys are particularly important here. When a machine holds a signing key in a Trusted Execution Environment, even the machine's operator can't extract or misuse that key. This provides the same custody guarantees for machines that hardware wallets provide for humans.
2. Payment rails
The payment layer for machine transactions needs three properties:
Low latency. Machines transact in milliseconds. Payment confirmation can't take minutes.
Low cost. When transactions are measured in fractions of a cent, the payment rail can't charge dollars in fees. On-chain stablecoins on L2 networks (Base, Arbitrum, Optimism) offer sub-cent transaction costs.
Protocol-level integration. Machines shouldn't need to integrate a payment SDK. x402 embeds payment into HTTP itself — the same protocol machines already use to communicate.
Stripe's machine payments initiative takes a different but complementary approach. Built on x402, Stripe's offering lets AI agents pay for resources in USDC on Base with no gas or network fees charged by Stripe. Payments credit directly to the merchant's Stripe balance and plug into existing Stripe metrics, reporting, and multi-currency payouts. It bridges the x402 protocol with the traditional payment infrastructure that millions of merchants already use.
3. Settlement
Payment authorization and settlement are different things. In machine payments:
- Authorization happens at the speed of the transaction — the machine signs a payment approval.
- Settlement happens on the underlying ledger — the stablecoin actually moves from payer to payee.
For micropayments, settling every individual transaction on-chain would be prohibitively expensive even on L2s. The practical approach is batched settlement: individual transactions are authorized instantly but settled in batches at regular intervals. This is analogous to how credit card networks batch-settle daily while authorizing individually.
Circle's Gateway integration with x402 demonstrates this in practice. Gateway's batching capability groups hundreds of thousands of micropayments off-chain and settles them together on-chain — preserving finality while avoiding per-transaction gas costs. As Marcus Boorstin, Circle Distinguished Engineer, explained: "Agentic AI represents a shift in how economic activity happens online. Instead of users initiating every transaction, autonomous systems will need to settle small payments continuously and intelligently."
For context on the scale of stablecoin infrastructure available: USDC processed $18.3 trillion in transaction volume in 2025, and total stablecoin transactions hit a record $33 trillion — 72% year-over-year growth. Bloomberg Intelligence projects stablecoin payment flows reaching $56 trillion by 2030.
4. Governance and safety
Autonomous machines spending money creates obvious risks. The governance layer needs:
- Spending limits. Hard caps on per-transaction, per-hour, and per-day spending — enforced on-chain so they can't be overridden by compromised software.
- Kill switches. The ability for a human operator to freeze a machine's spending authority instantly. This is the "owner key" concept from smart wallet architectures.
- Audit trails. Every transaction recorded immutably for compliance and debugging.
- Policy engines. Programmable rules that define what a machine can and cannot purchase — allowlisted counterparties, approved asset types, maximum prices.
The trust gap here is real. A KPMG survey found that while 97% of enterprise CFOs understand AI agents can act autonomously, only 15% were considering deploying them and just 11% were actively testing — highlighting that governance infrastructure is the bottleneck, not technical capability.
This is where Openfort's programmable wallet controls become critical infrastructure. Machines need the same spending guardrails that enterprises apply to corporate cards — but enforced cryptographically rather than by a compliance team reviewing expense reports. As Coinbase CEO Brian Armstrong put it, crypto wallets let software agents hold and spend digital money while companies retain governance — "turning machine-to-machine payments into something finance departments can review."
The Missing Infrastructure: Discovery and Reputation
There's a gap in the current machine payment stack that deserves attention: how do machines find and trust each other?
When a human shops, they rely on brand recognition, reviews, and social proof. Machines need machine-readable equivalents:
Service discovery
How does a machine find the best provider for what it needs? Today's answers — Google search, app stores, word-of-mouth — are human-centric. Machine payments need:
- Registries where services publish their capabilities, pricing, and API specifications.
- Standardized service descriptions so machines can compare offerings automatically.
- DNS-like resolution for payment-capable services: "I need weather data for GPS coordinates X, Y — who offers it and at what price?"
Machine reputation
How does a machine assess whether a counterparty will deliver? Reputation systems for M2M need:
- On-chain transaction history. How many requests has this service fulfilled? What percentage resulted in disputes?
- Stake-based guarantees. Providers stake collateral that gets slashed for non-delivery — creating economic incentive for reliability.
- Composable reputation scores. A reputation oracle that aggregates on-chain data into a single trust score that any machine can query before committing to a transaction.
LongHash Ventures has identified discovery and reputation as the most critical missing infrastructure for the autonomous economy. Without them, machines default to pre-configured provider lists — which recreates the vendor lock-in that decentralized payment rails were supposed to eliminate.
Machine Payments and x402
The x402 specification was designed with machine payments in mind. Its properties align directly with what M2M transactions require:
Protocol-native. x402 lives at the HTTP layer. Machines don't need a payment SDK — they just need to speak HTTP, which they already do.
Structured and parseable. The 402 response contains machine-readable payment requirements: amount, asset, network, recipient. No ambiguity, no human interpretation needed.
Wallet-agnostic. x402 works with any signing key — backend wallets, hardware modules, TEE-secured keys, or smart accounts. This matters for IoT devices that might use lightweight key management compared to the full smart wallet stack of an AI agent.
Facilitator model. The x402 facilitator handles settlement, gas, and on-chain mechanics so that the transacting machines don't need to manage blockchain infrastructure directly. This is similar to how Circle's Gateway abstracts settlement complexity for USDC micropayments.
v2 extensibility. x402 v2, released in December 2025, adds wallet-based identity, automatic API discovery, dynamic payment recipients, and support for additional chains and fiat — all features that scale to high-volume machine payment scenarios. In September 2025, Cloudflare co-founded the x402 Foundation to push the protocol toward an open standard, signaling that the CDN and edge infrastructure layer is becoming payment-aware.
Proven at scale. x402 has already processed over 140 million cumulative transactions with $600+ million in payment volume. At its peak in October 2025, the protocol handled roughly 1 million transactions per week — a 10,780% increase from September. On Solana alone, daily x402 transactions exceeded 600,000 by December 2025.
Where It's Heading
Machine payments are following a predictable adoption curve:
Now: API micropayments and AI agent transactions. This is the current frontier — agents paying for data, compute, and services on behalf of users or other agents. The x402 specification, Stripe's agent toolkit, and stablecoin rails on L2s are enabling this today.
Next (1–2 years): IoT device payments. As x402 and lightweight wallet infrastructure mature, connected devices will gain payment capabilities. The bottleneck isn't the payment technology — it's the identity and discovery infrastructure.
Later (3–5 years): Full autonomous economy. Machines discovering, evaluating, and transacting with other machines at scale. This requires mature reputation systems, standardized service registries, and robust governance frameworks that don't exist yet.
The total addressable market is staggering. Machine-to-machine interactions already outnumber human-to-machine interactions on the internet. Most of these interactions are currently "free" — paid for indirectly through subscriptions or advertising. Machine payments turn each interaction into a potential transaction, creating an economic layer on top of existing machine communication. Some analysts describe this as "streaming money" — protocols that allow a machine to maintain an open payment channel with a service provider, where capital flows continuously as long as the service is active.
Building for Machine Payments
If you're building infrastructure that machines consume — APIs, data services, compute, storage — consider these steps:
- Implement x402 on your endpoints. Start with a simple per-request price for your most popular API routes.
- Support stablecoin settlement. USDC on Base or Arbitrum offers the best combination of low cost, fast finality, and broad wallet support.
- Publish machine-readable service descriptions. Document your capabilities, pricing, and SLAs in structured formats that agents and machines can parse.
- Build for zero-trust. Every request should be independently authenticated and authorized. Don't assume persistent sessions or pre-established relationships.
- Instrument everything. On-chain payment records provide built-in audit trails. Combine them with application-level logging for complete transaction visibility.
Building payment infrastructure for machines? Explore Openfort's backend wallets for TEE-secured signing, and see how x402 enables protocol-level payments for autonomous systems.
Related reading: