USDC ON BASE · LIVE ON MAINNET

The payment layer
for AI agents

Managed wallets, spending policies, and real USDC settlement on Base. P2P transfers, micropayments, and x402 paywalls, one API.

Get StartedView API
<0ms
Settlement
$0.001
Gas per tx
99.9%
Uptime SLA
0+
Active protocols
Developer Experience

Ship in minutes, not months

Four lines to create a wallet. Four more to send a payment. Full type safety.

 1
▊
Capabilities

Everything agents need to transact

Agent Wallets

CDP-backed USDC wallets created in one API call. Funded from treasury, non-custodial key management via Coinbase.

Spending Policies

Per-tx limits, daily caps, merchant blocklists, category allowlists, and multi-sig approval gates — enforced before every settlement.

P2P Transfers

Agent-to-agent instant payments. Zero gas, atomic balance swaps, full audit trail. Agents pay each other for tool access and services.

x402 Protocol

HTTP 402 pay-per-request. Register endpoints with USDC prices — agents auto-pay on 402. Sub-cent micropayments on Base.

DID Credentials

Issue verifiable credentials with JWT-signed DIDs. Merchants authenticate agents cryptographically before accepting payment.

MCP Monetization

Gate MCP tool calls behind NexusPay. Providers earn per-invocation; agents pay from managed wallets with policy enforcement.

Workflow

From zero to settled in four steps

STEP 01

Register Agent

Single API call creates a CDP-backed wallet funded with USDC on Base.

STEP 02

Set Policies

Define spending limits, allowlists, blocklists, and approval workflows.

STEP 03

Issue Identity

Generate DID credentials for cryptographic merchant authentication.

STEP 04

Transact

Send USDC, transfer P2P, or pay-per-request via x402 — all policy-enforced.

Use Cases

Three ways agents transact

Every payment is policy-checked, balance-verified, and settled with full audit trail.

🤖
AI Agent
Initiates payment
NexusPay
NexusPay
Policy Check
Balance Verify
Settlement
💰
Recipient
Receives USDC
USDC on Base

On-Chain Settlement

Agent pays an external address. USDC settles on Base via Coinbase CDP — real blockchain, sub-second finality, under $0.001 gas.

1Agent calls /api/transactions
2Policies enforced (6 checks)
3Balance decremented atomically
4CDP settles USDC on-chain
5Tx hash returned to agent
Instant, Zero Gas

P2P Agent Transfer

Agent pays another agent. Balances swap atomically in NexusPay — no on-chain settlement needed, no gas, instant confirmation.

1Agent calls /api/p2p
2Policies enforced on sender
3Both balances updated atomically
4Transaction logged with audit trail
5Both agents notified
Micropayments

x402 Pay-Per-Request

Agent hits a monetized API endpoint. Gets 402, auto-pays the sub-cent USDC fee, receives access. Enables true pay-per-call AI tool economics.

1Agent hits protected endpoint
2Receives HTTP 402 + price
3Calls /api/x402 with payment
4Balance debited, access granted
5Endpoint revenue tracked
TypeScript SDK

Install and start in 30 seconds

Full TypeScript types, CJS + ESM, works in Node, Bun, and edge runtimes.

TERMINALnpm
$ npm install nexuspay-sdk
import NexusPay from "nexuspay-sdk";

const nexus = new NexusPay({
  baseUrl: "https://your-nexuspay.vercel.app",
  apiKey: process.env.NEXUSPAY_API_KEY,
});
Full TypeScript types
CJS + ESM
Node / Bun / Edge
Zero dependencies
Works with fetch API
Auto-typed responses
Coinbase AgentKit

Native AgentKit integration

One import gives your AgentKit agent 9 payment actions — wallets, policies, P2P transfers, and x402 micropayments.

TERMINALnpm
$ npm install nexuspay-agentkit @coinbase/agentkit
TypeScript
import { AgentKit } from "@coinbase/agentkit";
import { nexusPayActionProvider } from "nexuspay-agentkit";

const agentKit = await AgentKit.from({
  cdpApiKeyName: process.env.CDP_API_KEY_NAME!,
  cdpApiKeyPrivateKey: process.env.CDP_API_KEY_PRIVATE_KEY!,
  actionProviders: [
    nexusPayActionProvider({
      baseUrl: process.env.NEXUSPAY_URL!,
      apiKey: process.env.NEXUSPAY_API_KEY!,
    }),
  ],
});

// Your agent now understands natural language payments:
// "Transfer $5 to agent-writer for the article it generated"
// "Check agent-alpha's balance before approving the request"
// "Pay the inference API at /api/premium/gpt4"
// "Set a $10 daily spending limit on agent-beta"
nexuspay_get_balance
Check wallet balance
nexuspay_create_wallet
Provision agent wallet
nexuspay_send_payment
On-chain USDC payment
nexuspay_p2p_transfer
Instant agent transfer
nexuspay_pay_x402
Auto-pay HTTP 402
nexuspay_create_policy
Set spending limits
nexuspay_check_policies
Audit spending rules
nexuspay_list_transactions
Transaction history
nexuspay_list_wallets
List all wallets
View AgentKit docs →
Model Context Protocol

NexusPay inside Claude & Cursor

MCP lets AI assistants use external tools natively. Add NexusPay once and Claude, Cursor, or Windsurf can manage wallets, send payments, and check balances — just by asking.

⬡
What is MCP?
Model Context Protocol is an open standard that lets AI assistants connect to external services as native tools — no custom code, no API wrappers. Your AI just gains new abilities.
◈
Why payments?
Agents that can reason but not pay hit a wall the moment they need to buy compute, access an API, or compensate another agent. MCP + NexusPay closes that gap in minutes.
⚡
30-second setup
Add one JSON block to your MCP config file. No SDK, no code, no build step. Restart your client and your AI assistant is ready to transact.
Claude Desktop · Cursor · Windsurfnpm
{
  "mcpServers": {
    "nexuspay": {
      "command": "npx",
      "args": ["-y", "nexuspay-mcp"],
      "env": {
        "NEXUSPAY_URL": "https://your-nexuspay.vercel.app",
        "NEXUSPAY_API_KEY": "nxp_your_key_here"
      }
    }
  }
}
What you can say after connecting
›“Check the balance of agent-researcher before running the job”
›“Transfer $5 to agent-writer for the article it just completed”
›“Send $2.50 USDC to 0x742d... for the compute invoice”
›“Set a $10 daily spending limit on agent-beta”
›“Show me the last 10 transactions from agent-alpha”
›“Pay the inference API at /api/premium/gpt4 using agent-alpha”
Works with any MCP-compatible client
Claude Desktop
Cursor
Windsurf
Zed
Continue.dev
FAQ

Common questions

NexusPay settles on Base (Coinbase L2) using USDC. Base offers sub-second finality and gas costs under $0.001 per transaction, making it ideal for agent micropayments.

Each agent wallet can have multiple policies defining per-transaction limits, daily caps, allowed recipient lists, blocked merchant categories, and approval gates. Every transaction is validated against active policies before settlement.

x402 implements HTTP 402 Payment Required for machine-to-machine payments. Register an API endpoint with a USDC price — when agents hit it without payment, they receive a 402 response, pay via NexusPay, and gain access. Sub-cent micropayments make this viable for every API call.

Agent wallets are created via the Coinbase CDP SDK, which provides institutional-grade key management. The CDP handles signing and key storage — your agents never touch private keys directly.

Agent-to-agent transfers are instant balance swaps within NexusPay — no gas, no on-chain settlement needed. Both balances update atomically in a single database transaction, with full audit trail.

Ready to build the agent economy?

Start building agent payment infrastructure today.

Open DashboardView Docs