Stablecoins moved a record $33 trillion in 2025, so the rails for instant, low-cost, programmable settlement already exist at scale. Autonomous AI agents account for very little of that volume. On-chain data for Coinbase's x402 protocol shows it settling around $28,000 a day at an average of about $0.20 per transaction, a tiny share of overall stablecoin activity.
The AI agent market is projected to grow from $7.63 billion in 2025 to $182.97 billion by 2033. Agents can already research, decide, and act on their own, but most still stop when they need to pay. The constraint is the payment layer itself. Systems built for human checkout struggle to price, authorize, and settle the many fractional-cent transactions a single agent task produces. A few platforms now build specifically for this, including FluxA, whose agent wallet settles payments in stablecoins under spending rules the user sets once.
This guide compares the main platforms, what each is suited to, how they price, and where they fit alongside the broader shift toward agentic commerce.
Key Takeaways
- Card fees make sub-dollar payments unprofitable. A fixed processing fee, commonly around 2.9% + $0.30, can be many times the value of a $0.002 API call. Sub-cent agent payments need rails priced for high volume rather than for human-sized purchases.
- Stablecoins are the default micropayment rail. USDC and similar assets settle in seconds for a fraction of a cent, which is why most agent-native platforms settle in stablecoins rather than on cards.
- x402 has become an industry standard. Governance moved to the x402 Foundation under the Linux Foundation in April 2026, with launch members including Circle, Google, Mastercard, Microsoft, Shopify, Stripe, and Visa, alongside roughly 165 million cumulative transactions reported at launch.
- Protocols are converging. Google's Agent Payments Protocol (AP2) shipped with backing from a broad group of payments and technology organizations and includes an x402 extension for crypto settlement. Supporting more than one protocol reduces the risk of rebuilding as standards settle.
- Traditional fintech is entering the space. Stripe's $1.1 billion acquisition of Bridge and its Machine Payments launch show that incumbents now treat agent micropayments as a real rail.
- A workable stack has to do three jobs. It needs to price per request, authorize without a person approving each charge, and settle small amounts cheaply. FluxA approaches this with intent-based authorization and zero-knowledge batch settlement, both covered later in this guide.
Why AI Agent Micropayments Need Purpose-Built Infrastructure
Traditional payment systems assume a person starts every transaction. Card networks, bank transfers, and digital wallets expect a manual checkout, an authentication step, and settlement that can take days. Agent workloads look nothing like that. A single task such as researching a topic or booking a service can trigger dozens of paid calls to LLM APIs, data providers, MCP tools, and other agents, each one small and needed immediately.
How agent spending differs
Agent payments tend to be frequent, small, and started by software rather than a person. That creates several requirements older systems handle poorly:
- Transaction minimums. Fixed per-charge fees make sub-dollar payments uneconomic on card rails.
- Manual approval. Most checkout flows need a human confirmation that breaks agent autonomy on every purchase.
- Settlement latency. Multi-day bank settlement conflicts with workflows that expect near-instant finality.
- Limited programmability. Spending rules cannot be expressed and enforced at the protocol level.
- Cross-border friction. Currency conversion and compliance steps add cost and delay to international flows.
An infrastructure gap
The low x402 volume reflects missing infrastructure more than missing demand. Stablecoin liquidity is abundant and agents can already spend, but the layer in between, covering discovery, pricing, authorization, and settlement at machine speed, is still maturing. The platforms below are the ones building that layer rather than adapting human checkout to fit.
The Economics of AI Agent Micropayments
Micropayments are mostly a unit-economics question. If the cost to collect a payment is higher than the payment itself, more volume only deepens the loss. The platforms that work are the ones where a service can charge a fraction of a cent per call and still keep a margin.
Why card rails don't fit micropayments
A card transaction usually carries a percentage fee plus a fixed component, often around 2.9% + $0.30. On a $50 purchase that is negligible. On a $0.002 API call, the fixed fee alone is around 150 times the payment. Every sale loses money, and more volume only increases the loss. This is why most agent micropayments run on stablecoin rails, where settlement costs a fraction of a cent and there is no fixed minimum working against small amounts.
How batching makes sub-cent pricing work
Even on cheap rails, settling every fractional payment on-chain one at a time adds up, since each settlement carries gas and coordination cost. One approach is to authorize each payment instantly but settle them in batches, verifying many small payments together and posting a single on-chain settlement. FluxA's AEP2 protocol uses this model. Its zero-knowledge batch settlement (Groth16/BN254 on EVM) lets a service take a stream of sub-cent payments and settle them in one proof, instead of paying overhead on each. Combining stablecoin rails with batch settlement is what makes sub-cent pricing practical at scale.
Protocols Matter Before Platforms
Before comparing products, it helps to know the standards they build on, because the choice of protocol shapes what a platform can do. Four are worth knowing.
- x402 is the HTTP-native payment standard. It uses the long-dormant HTTP 402 "Payment Required" response so a server can quote a price and a client can pay in USDC, usually on Base or Solana, then retry the request with proof of payment. There are no accounts or API keys, and the receipt is the credential.
- AP2 (Agent Payments Protocol), from Google, handles authorization and payment mandates. It is rail-agnostic and works with cards, and it includes an x402 extension for crypto settlement.
- MCP (Model Context Protocol) lets assistants and agents call external tools and services, and it is increasingly where per-call payments get attached.
- A2A (Agent-to-Agent) covers how agents discover and talk to each other.
Identity sits underneath all of this. An agent has to prove who it is before a service will quote a price or take its payment, which is why agent authentication across platforms is becoming its own layer of the stack.
Supporting more than one protocol matters while the landscape is still settling, since a platform tied to a single API risks rework later. FluxA's AEP2, for example, embeds one-time payment mandates inside x402, A2A, or MCP calls rather than replacing them. This guide to how agents make autonomous payments with x402 and AEP2 covers the approach in detail.
The Platforms, Compared
Seven platforms span the range from open protocol to full-stack service. Each entry notes what it is best for, how it prices, and where it fits.
1. Stripe: Agent Payments on Familiar Rails
Best for: Teams already on Stripe that want incremental agent-payment support.
Pricing: Standard Stripe fees, plus blockchain gas on crypto rails.
Stripe has shipped a sequence of agent products over the past year, including the Machine Payments Protocol (MPP), launched March 18, 2026, x402 support with USDC on Base, the Agentic Commerce Protocol with OpenAI, and a Link Agent Wallet. The appeal is that agent payments land in the same dashboard, reporting, and compliance stack businesses already use.
Key features:
- MPP for session-based streaming payments.
- x402 payments with USDC on Base.
- Agent payments unified with existing Stripe reporting and compliance.
- CLI tooling and Python and Node examples for testing.
Stripe's reach and compliance are hard to match. Several of its agent-native pieces are still in preview, and parts of the stack assume a human is still approving or specifying purchases, which fits some agent workflows better than fully autonomous ones.
2. Coinbase x402: The Open Standard
Best for: Developers who want to build on open, permissionless infrastructure.
Pricing: No protocol fee. Costs are the underlying chain's gas, typically fractions of a cent on Layer 2s.
x402 is less a product than the standard much of the category now runs on, embedding stablecoin payments directly into HTTP requests. Governance has moved to the x402 Foundation under the Linux Foundation, and it is now co-stewarded by a wide group including Circle, Google, Mastercard, Stripe, and Visa. Coinbase reported roughly 69,000 active agents and about 165 million cumulative transactions around the Foundation launch.
Key features:
- HTTP 402 request-level payments with no accounts or API keys.
- USDC settlement on Base, Solana, and other supported chains.
- Permissionless operation across any compatible implementation.
- Native fit with AP2 for authorization mandates.
Because x402 is a protocol rather than a managed service, teams get flexibility but also have to assemble wallets, identity, metering, and settlement themselves or through a platform built on top of it. On-chain analysis also suggests a meaningful share of current volume is testing rather than commercial use.
3. Circle: The USDC Settlement Layer
Best for: Teams that want to build directly on the dominant stablecoin.
Pricing: CCTP and the Gateway API are free and permissionless. Circle Mint carries issuance and redemption terms for institutions.
Circle issues USDC, the stablecoin most agent payment platforms ultimately settle in. That puts it at the foundation of the stack rather than in competition for the application layer. Its Cross-Chain Transfer Protocol (CCTP) moves USDC across chains natively without bridges, and the Gateway API gives a unified balance across chains with sub-second transfers.
Key features:
- Native cross-chain USDC movement via CCTP, with no API key required.
- Gateway API for a unified balance across EVM chains and Solana.
- Circle Payments Network for routing with real-time FX quoting.
- Permissionless, widely integrated infrastructure.
Circle gives you the rail, not the surrounding workflow. Compliance, fiat on and off ramps, agent identity, and spend controls are not included, so most teams pair Circle with an orchestration or agent-payment layer on top.
4. FluxA: Intent-Based Wallet and Batch Settlement for Micropayments
Best for: Proactive agents that need to spend within set limits and services charging sub-cent prices.
Pricing: USDC stablecoin settlement aimed at sub-cent payments. See the docs for current fees.
FluxA is a payment layer built around agent autonomy rather than human checkout. Its agent wallet works on a sign-once model. A user approves a single intent that sets a budget and what it covers, and the agent then transacts within those bounds without seeking approval on each charge. A risk engine checks every payment against the signed intent and blocks anything outside it. The company reports more than 80,000 agent wallets created and over 200,000 agent payment requests a month.
Key features:
- Intent-based authorization with on-wallet enforcement of spend limits, approved services, and time windows.
- AEP2 protocol with zero-knowledge batch settlement (Groth16/BN254 on EVM) for high-frequency micropayments.
- AgentCard single-use virtual cards for services that still need a card number.
- AgentCharge and FluxA Monetize for charging agents to use an API, MCP server, CLI, or skill.
The combination of intent-based control and batch settlement targets the two hard parts of agent micropayments at once: keeping autonomous spend governed, and keeping sub-cent transactions profitable. As a newer entrant, its ecosystem of integrations is smaller than that of incumbents like Stripe or Circle.
5. Nevermined: Metering-First Monetization
Best for: AI service providers that need detailed metering and audit trails.
Pricing: A 1% fee on stablecoin payment flows, plus any processor fees on other rails.
Nevermined is built for monetizing agent services, with metering as the core. Every usage record is cryptographically signed and written to an append-only log, which supports per-line-item reconciliation and audit-ready billing. It supports x402, AP2, MCP, and A2A, and offers usage-based, outcome-based, and value-based pricing. Nevermined reports that Valory cut its billing integration from six weeks to six hours.
Key features:
- Tamper-evident metering with signed, append-only usage logs.
- Usage, outcome, and value-based pricing models.
- Native support for x402, AP2, MCP, and A2A.
- SDKs for TypeScript and Python.
Nevermined is strongest on the get-paid and audit side. Teams whose main need is agent spending controls or single-use cards will use less of what it offers.
6. Crossmint: Full-Stack Stablecoin Infrastructure
Best for: Enterprises that want wallets, compliance, and fiat ramps from one vendor.
Pricing: Usage-based, with enterprise terms on request.
Crossmint bundles the parts most teams would otherwise assemble separately: wallets, compliance, on and off ramps, and orchestration across 40-plus chains including EVM networks, Solana, and Stellar. Agent wallets, virtual cards, and x402 support are live, and the platform is SOC 2 Type II certified and MiCA authorized, with customers including MoneyGram and Western Union.
Key features:
- Wallets, onramp, offramp, and compliance in one API.
- Coverage across 40-plus chains.
- Agent wallets and virtual cards with x402 support.
- Enterprise certifications for regulated use.
Crossmint suits teams that value breadth and compliance coverage. The trade-off is that an all-in-one platform offers less low-level control than building directly on a protocol or settlement layer.
7. Skyfire: Agent Identity and the KYA Framework
Best for: Agents paying for APIs and services where verified identity matters.
Pricing: Transaction-based, with spending funded through prefunded PAY tokens. Contact Skyfire for terms.
Skyfire is a payment network built specifically for AI agents, with verified agent identity at its center. Its KYAPay product and Know Your Agent (KYA) framework give agents a credential that services can check before transacting, and it settles in USDC. The company is backed by Coinbase Ventures and a16z CSX, and integrations such as Apify let agents pay for tools through Skyfire tokens.
Key features:
- Verified agent identity tied to the KYA framework and ERC-8004.
- USDC settlement with developer-defined spend controls.
- PAY tokens that prefund agent spending against a set budget.
- A growing set of API and tool integrations.
Skyfire's strength is identity and access for paying for services. Teams that mainly need to monetize their own services, or that want batch settlement for very high-frequency micropayments, may need additional tooling.
Intent-Based Authorization: Autonomy Without Handing Over the Wallet
Two failure modes show up when agents handle money. Approving every charge keeps a person in control but stops the agent on each purchase, which defeats the purpose of an autonomous workflow. Giving the agent open access to a card or wallet removes that friction but also removes the guardrails, and an agent that misreads a task can spend in ways no one intended.
Intent-based authorization sits between the two. The user signs one intent that sets a budget, the services or hosts it covers, and how long it lasts. After that, payments inside the intent clear automatically, and the wallet rejects anything outside it. Approval happens once, at the level of a task rather than a transaction.
This is the model behind FluxA's wallet, and it lines up with the broader set of intent-based spending controls that teams running agents in production now treat as a baseline: spend limits, approved-service lists, time windows, single-use credentials, and audit logs. Enforcing those rules at the infrastructure layer, before funds move, is what makes autonomous spending auditable and recoverable rather than a standing liability.
Making a Service Payable by Agents
Most of this guide is about agents that spend. The other side is being a service that agents can find and pay. Many sites today are effectively invisible to agents, with no machine-readable description of what they offer and a checkout that assumes a logged-in human.
A human-only setup answers an agent with a 404 for any capabilities file and a 401 on checkout, because it expects a human session. An agent-ready setup answers differently. A request for a capabilities file returns a description and price, a query returns a 402 with a quote, and the same query carrying a payment mandate returns the result, already settled.
FluxA packages this as a few primitives a service publishes once. FluxA Monetize lets a provider charge agents for an API, MCP server, CLI, or skill, and AgentCharge handles getting paid in USDC. The sequence is discovery, then onboarding without a human step, then per-request pricing over MCP and x402, then settlement on stablecoin rails where sub-cent amounts are not eroded by fees.
Choosing the Right Platform
The rails for agent micropayments already exist. The open question is the layer that prices, authorizes, and settles fast enough for software to use without a person involved. Open standards like x402 and settlement infrastructure like Circle form the base. Full-stack platforms such as Crossmint and metering-first ones such as Nevermined serve specific needs.
For micropayments in particular, the two recurring problems are keeping autonomous spend governed and keeping sub-cent transactions profitable, which is where intent-based authorization and batch settlement matter most.
If you are building an agent that needs to spend, or a service that wants to charge agents, you can open a FluxA wallet or request a demo.
Frequently Asked Questions
Why can't credit cards handle AI agent micropayments?
Card transactions carry a fixed fee on top of a percentage, often around 2.9% + $0.30. On a sub-cent or few-cent payment, the fixed fee alone can be many times the transaction value, so each sale loses money and higher volume only makes it worse. Cards also assume a human checkout and settle over a window of days, neither of which fits an agent making thousands of small, instant payments.
How do AI agents pay for API or MCP calls?
Usually through a protocol such as x402 or AEP2 layered over an agent wallet. The agent requests a resource, receives a price quote in response, pays in a stablecoin like USDC, and retries with proof of payment. The service verifies the payment and returns the result. No account signup or manual approval is needed for each call.
What is the difference between x402 and AEP2?
x402 is an open standard for request-level payments over HTTP that settles each payment as it happens. AEP2 embeds a one-time payment mandate inside an x402, A2A, or MCP call, so the payee is verified instantly while settlement is deferred and batched. They are complementary rather than competing: AEP2 adds an authorization and batch-settlement layer on top of calls that protocols like x402 already carry.
What is the cheapest way to settle sub-cent agent payments?
Stablecoin rails such as USDC on a low-fee Layer 2 are the common answer, because settlement costs a fraction of a cent and there is no fixed minimum working against small amounts. For very high frequency, batching many payments into a single on-chain settlement lowers the per-payment overhead further.
How do I make my API or MCP server chargeable to AI agents?
Publish a machine-readable description of what you offer and its price, respond to unpaid requests with a payment quote, and accept a stablecoin payment or mandate in return for the result. Platforms that monetize APIs, MCP servers, and skills automate this so it can be added without rebuilding the service.