The Payment Stack for theMachine Economy
Agents are becoming the internet's most active buyers, sellers and contractors. xpay✦ gives them the financial primitives to act on it — autonomously, verifiably, at machine speed. Non-custodial. Multi-rail. Developer-first.
500+
Developers building
23,000
Settlements on Base
$0.043
Median transaction
Three primitives. Complete financial autonomy.
Every existing payment rail was designed for humans. xpay✦ gives agents what humans take for granted — an identity, a wallet, and the ability to transact — built for machine speed and machine frequency.
Programmatic Spend Authority
Identity + wallet
An agent gets scoped, revocable spending authority — what it can pay, to whom, for how long, up to what ceiling. The authority is in the code, not a policy document. It narrows at every level of delegation: sub-agents inherit less, never more.
Machine-Native Revenue
Monetize per call
Any API becomes billable per call. An agent pays another agent. An MCP server charges per query. Settlement is instant and on-chain — no invoice, no net-30, no human in the loop. Revenue starts the moment you flip the switch.
Verifiable Audit Trail
Trust the ledger
Every transaction is on-chain and independently verifiable at basescan.org. Your compliance team can verify without trusting xpay. Every amount, agent address and timestamp is a permanent public record — not a report we generate for you.
Why existing rails structurally fail agents
Each alternative fails the agent use case for an architectural reason — not a missing feature. No amount of product iteration fixes a structural mismatch. x402 on Base is a different primitive entirely.
Legacy rails
- Cards: $0.018+ interchange on a $0.043 agent tx
- ACH: settles next business day, not finality
- Wire / SWIFT: human identity + banking hours only
- Virtual cards: still interchange, still T+2, still human
- Every rail needs a human account holder at origin
x402 on Base
- Settlement: 192ms with cryptographic finality
- Cost: $0.000008 per transaction on Base
- No minimum transaction value — sub-cent native
- Open protocol — nobody can de-platform you
- Agent-to-agent: software pays software directly
One Line to Production
Start building in seconds, not weeks. Zero config setup with auto-instrumentation.
terminal
// Instant x402 integration
import { XPay } from '@xpay/core';
const xpay = new XPay('YOUR_API_KEY');
// Enable firewall protection
xpay.enableFirewall({
limit: 500,
period: 'daily'
});
// Track all transactions
xpay.trackTransactions();
// You're live! Your agents are now protected.✓ Zero config setup
✓ Auto-instrumentation
✓ Built for scale
Agents transact autonomously. Your team stays in control.
The enterprise objection to autonomous agent payments is governance, not capability. xpay✦ answers every line of it — programmatically, not with a policy document.
Spend ceilings — in the code
Set a ceiling per agent, per task type, per vendor, per time window. Enforced at the protocol level — not a policy document the agent might not read.
Delegation that narrows
A parent agent delegates only a subset of its own authority — never more. The chain narrows at every hop. Cryptographically enforced, no privilege escalation by construction.
Instant revocation at any depth
Kill any agent’s spending authority at any depth in the delegation chain, instantly. One call, takes effect in under 100ms. No waiting for a session to expire.
Verify without trusting us
Every payment is on Base — independently verifiable at basescan.org. Your compliance team audits without asking xpay for a report. Exportable as CSV or queryable via API.
Time-bounded authority
Wallets expire automatically — 8h for a day’s work, task-complete for single-objective agents. Unused authority returns to the pool at expiry. No orphaned credentials.
Fleet dashboard
Real-time spend across every agent in your fleet — who spent what, on which vendor, when. Anomaly alerts. Drill from fleet level to a single transaction in two clicks.
Built for the Entire Agentic Ecosystem
x402 is an open protocol — it settles on Base and plugs into every major AI model, agent framework, and cloud you already run on.
OpenAI
AI ModelsGPT-4, o1, and custom model integrations with cost tracking
Anthropic
AI ModelsClaude integration with usage monitoring and budget controls
LangChain
FrameworksAgent framework integration with transaction visibility
CrewAI
FrameworksMulti-agent orchestration with financial governance
Vercel
InfrastructureServerless deployment with usage-based billing
AWS
InfrastructureCloud infrastructure with cost attribution and monitoring
Settles on Base. Works with your stack.
192ms
Settlement finality on Base
$0.000008
Fee per transaction
USDC
Stablecoin-settled, non-custodial
From zero to autonomous payment in four steps
Delegation, not just control. An agent gets spending authority, acts on it, and can pass a narrower version to a sub-agent — all without a human approving each step.
01
STEPDelegate spending authority
An agent receives a funded wallet with a ceiling, an allowed-vendor list, and an expiry. Authority is in the code — not a policy document. Two lines. Thirty seconds.
02
STEPAgent pays autonomously
Payment settles inside the HTTP header via x402 — 192ms, USDC on Base, $0.000008 fee. No redirect, no card call, no human in the loop. The response arrives already paid.
03
STEPSub-agent delegation narrows
The agent passes a subset of its authority to a sub-agent — but never more than it holds. The chain narrows at every hop. Cryptographically enforced. No privilege escalation.
04
STEPVerify without trusting us
Every transaction is on Base — independently verifiable at basescan.org. Revoke any wallet at any depth instantly. Your compliance team audits without asking xpay for a report.
Your agents can think. Now let them pay.
Start building freeTwo lines of code • A funded wallet • Sub-cent settlement
Real transactions. Right now.
Not a testnet. Not a demo environment. Autonomous agent-to-agent payments settling on Base with real USDC — early, growing, and the volume tells its own story.
Below every card minimum
The median transaction is $0.043 — beneath the minimum charge of every card network on earth. This is not a volume story yet. It is a behaviour story: developers needed a primitive the card economy cannot serve, and found one.
Built by developers, not pitched to them
500+ developers wired x402 into production workflows because they hit a wall the card rails could not clear — sub-cent, no human in the loop, agent-to-agent. Adoption came from need, not marketing.
Verifiable, not reported
Every one of the 23,000 settlements is on Base — public, permanent, and independently checkable at basescan.org. Not a dashboard number we ask you to trust. The ledger is the proof.
Honest numbers, live on Base
500+
Developers building
23,000
Settlements on Base
$1K / mo
Settled volume, recurring
$0.043
Median transaction
Build on x402
Everything you need to give your agents a wallet and let them pay — an open protocol, drop-in framework support, and two lines of code.
Your agents can think. Now let them pay.
Two lines of code. A funded wallet. Autonomous settlement at sub-cent economics. 500+ developers are already building on it.
✓ Two lines of code
✓ Non-custodial
✓ Live on Base
✓ Open protocol