Loomal Index vs Stripe ACP tool-level micropayments vs agentic checkout.
Stripe's Agentic Commerce Protocol, developed with OpenAI, lets agents complete checkout using a merchant's existing Stripe integration. x402 — the protocol behind every Loomal listing — skips checkout entirely: the API call itself is the purchase.
Stripe's Agentic Commerce Protocol (ACP) is probably the most consequential signal yet that agent payments are real: Stripe and OpenAI building a protocol so agents can buy things from merchants. So how does it relate to Loomal, which also exists so agents can buy things?
The split is granularity. ACP is built around checkout — an agent completing a purchase with saved payment methods through a merchant's existing Stripe integration. x402, which powers Loomal, is built for transactions too small and too frequent to justify a checkout at all: individual API and tool calls, paid in stablecoins on-chain rather than over card rails.
What Stripe ACP does well
ACP meets commerce where it already lives. Merchants have Stripe integrations, customers have saved payment methods, and ACP lets an agent drive that existing machinery to completion — developed with OpenAI, which means distribution into the agent surfaces consumers actually use. For buying products — physical goods, subscriptions, anything with a cart — extending proven card-rail checkout to agents is the pragmatic design.
If you're a merchant selling things people would otherwise buy on your website, ACP is aimed squarely at you.
Why checkout doesn't fit tool calls
Now shrink the transaction to a $0.02 web-scrape or a $0.05 OCR call, repeated hundreds of times an hour by a machine. A checkout flow — even an agent-driven one — is the wrong shape: card rails carry per-transaction economics that make two-cent charges impractical, and 'saved payment method within a merchant relationship' assumes an ongoing buyer-seller relationship that one-shot tool calls don't have.
This isn't a flaw in ACP; it's scope. ACP is described as agentic checkout on Stripe's network. Pricing individual API requests was never the problem it set out to solve.
What x402 and Loomal do instead
x402 removes checkout from the loop. The agent calls an endpoint, gets HTTP 402 Payment Required with a price, pays in USDC, and retries — the payment is a header, not a flow. Settlement lands on Base in about two seconds, the seller's handler only runs after payment clears, and every call produces an Ed25519-signed receipt. No chargebacks, no card network, no minimum-viable-transaction problem: Loomal listings price from $0.01 per call.
Loomal adds the market layer: a machine-queryable index of MCP servers and APIs with prices attached, so the agent that needs a tool can discover it and pay it in the same pass. Sellers claim a listing, set the price in one field, and pay a 5% fee on settled transactions — currently waived.
Two protocols, two transaction shapes
The clean way to hold both in your head: ACP is for when an agent buys what a human would have bought — a product, at checkout, on card rails. x402 is for what only machines buy — metered access to software, per call, on-chain. A sophisticated agent will end up speaking both, the way today's web speaks both 'add to cart' and 'API request.'
If what you sell is tool calls, the x402 side is your market, and Loomal is where agents go to find it priced and payable.
FAQ
Is Loomal competing with Stripe's Agentic Commerce Protocol?
Mostly not — they target different transaction shapes. ACP brings agents into checkout flows on a merchant's existing Stripe integration, suited to product purchases. Loomal uses x402 for per-call API and tool micropayments in USDC, where no checkout exists. An agent ecosystem likely uses both.
Why not just use card rails for API micropayments?
Economics and shape. Card transactions carry per-payment costs that make a $0.01–$0.05 charge impractical, and checkout assumes a buyer-merchant relationship. x402 settles in USDC on Base in about two seconds with no chargebacks, which is what makes one-cent-per-call pricing viable at all.
Does Stripe ACP support x402 or on-chain settlement?
ACP is described as an agentic checkout protocol using merchants' existing Stripe integrations and saved payment methods. For anything beyond that description — including any stablecoin or x402 plans — Stripe's own documentation is the source to check; this space is evolving quickly.
I sell API access today. Which protocol applies to me?
x402, almost certainly. Your transaction is a metered call, not a checkout. List the API or MCP server on Loomal, set a per-call price from $0.01, and x402-capable agents can pay and call it autonomously — payment clears before your handler runs, with a signed receipt per transaction.
Price the call, skip the checkout.
List on Loomal and let agents pay per call via x402.