Make agent payments invisible to applications.
The payment infrastructure layer for AI agents: one API for authorization, routing, settlement, compliance, and receipts across every protocol and rail.
For teams building agent-native products. No spam.
const paymentIntent = await tokenpay.create({
actor: "user_9K2",
agent: "travel_agent",
counterparty: "merchant_or_agent_id",
purpose: "Book refundable hotel under $300/night",
constraints: {
maxAmount: 90000,
currency: "USD",
merchantCategory: "travel",
requiresRefundable: true
},
approvalMode: "delegated",
settlementPreference: ["card", "usdc", "bank"],
});
// TokenPay returns a signed, auditable route.
await tokenpay.execute(paymentIntent.id);Every product team needs payment capability. Most don't want to build it.
TokenPay sits between your agents and the complexity, so you ship a financially capable agent in a sprint instead of a quarter.
Ship in a sprint, not a quarter
One SDK call replaces months of protocol integration work across AP2, ACP, x402, and card rails. TokenPay maintains the integrations; you maintain the product.
Users define what agents can spend
Every payment is constrained by a user-defined mandate: scoped budgets, time windows, counterparty rules, and approval modes. Agents spend exactly what users authorized, nothing more.
Compliance is a by-product, not a task
Every transaction produces a signed receipt with a full audit trail: who authorized it, what policy passed, why the route was selected. Finance gets what it needs without any extra work from your team.
Designed for trust before autonomy.
TokenPay turns vague agent actions into constrained, verifiable financial events.
Capture intent
Turn natural-language goals into structured payment constraints, budgets, counterparties, and approval rules.
Verify mandate
Confirm the agent is authorized to act for the user, organization, policy, and transaction context.
Route intelligently
Select AP2, ACP, x402, PSP, card, wallet, bank, or stablecoin rails based on acceptance and risk.
Settle and prove
Execute payment, generate signed receipts, reconcile ledgers, and preserve dispute-ready evidence.
From intent to settlement in milliseconds.
A programmable control plane for agentic payments, designed for human-approved, semi-autonomous, and fully delegated workflows.
What teams build with TokenPay.
Any agent that spends money needs a payment layer. Here is what that looks like across categories.
Travel and booking agents
purpose: "Book refundable hotel under $300/night"
AI travel assistants book hotels, flights, and car rentals within user-defined budget and refundability constraints. Mandate scoping enforces limits without human approval for every in-scope transaction.
MCP server and API monetization
purpose: "Call weather-data API, $0.002/request"
Developer tools and MCP servers charge per call using x402 HTTP micropayments. No billing infrastructure required. TokenPay handles metering, settlement, and signed receipts for every request.
Enterprise procurement agents
purpose: "Reorder office supplies under $500/month"
AI procurement agents place orders under company spending policy. Finance teams get line-item audit trails, category controls, and dispute-ready documentation without touching the agent code.
Agent-to-agent pipelines
purpose: "Pay research subagent for market analysis"
Agents in a pipeline pay each other for sub-tasks using AP2 mandates. Each hop is authorized, settled, and auditable. Complex multi-agent workflows become commercially viable without custom payment logic.
Infrastructure, not a product feature.
Agent payments are not a billing problem. They are an authorization, routing, and trust problem that sits below your product. We built the layer that should have existed already.
The challenge
- Payment protocols are fragmenting: AP2, ACP, x402, wallets, cards, and bank rails each require separate integrations.
- Autonomous spend creates a new authorization problem: how do you prove user intent for an action taken without a human in the loop?
- Enterprise teams need audit trails, category controls, and procurement rules that no existing API exposes natively.
- Agent-to-agent pipelines need a settlement layer that works without a shared PSP or billing relationship.
What makes us different
- Protocol-neutral: one integration routes across every current and future payment rail automatically.
- Mandate-first: authorization is a first-class primitive, not an afterthought bolted on top of a payment API.
- Auditable by default: every transaction produces a signed, human-readable receipt at no extra integration cost.
- Designed to stay out of your way: no new UI, no user onboarding flow, no dashboard your users need to learn.
Secure by design
Every payment is cryptographically authorized. No credential storage, no open-ended agent authority.
Protocol agnostic
Works across AP2, ACP, x402, card rails, and stablecoins. One integration, every standard.
Intelligent routing
Rail selection is deterministic and explainable. The fastest, lowest-cost path chosen automatically.
Built for institutions
Compliance-ready audit trails, category controls, and signed receipts finance teams can act on.
Ready to ship agent payments without building a payments team?
TokenPay handles the protocol complexity, mandate verification, routing, and compliance so your team can focus on the product. Join the early access list and we will reach out when the beta opens.
Joining teams building agent-native products. No spam, first access when the beta opens.