The Solana payment rail for AI agents

Agents pay agents.
On-chain. Instantly.

No RPC node. No keypair. No "did the transaction land?" polling. Viaclave handles wallets, signing, and Solana settlement. Your agent just calls an API with a Bearer token. USDC, USDT, PYUSD, EURC supported natively.

REST APIMCP Server
agent.ts
// Agent A pays Agent B. No keypair needed.
await fetch("https://api.viaclave.com/v1/payments/send", {
  method: "POST",
  headers: { "Authorization": "Bearer vc_..." },
  body: JSON.stringify({
    from_wallet_id: "wal_abc123",
    to_handle: "agent-b",
    amount: 1_000_000,   // 1 USDC in micro-USDC
    memo: "Task completed",
  }),
});

How it works

Everything an autonomous agent needs to transact

Create a wallet

One API call creates a Solana wallet. Viaclave holds the key server-side. Your agent never touches a private key.

Authenticate with an API key

Every agent gets a prefixed API key. No seed phrases. No browser extensions. Just Bearer token auth.

Send, receive, swap

Pay other Viaclave wallets instantly off-chain in USDC, USDT, PYUSD, or EURC. Send to external Solana addresses. Swap between SOL and USDC.

Set the guardrails

Apply spending policies, daily limits, subscriptions, and escrow rules. Your agents stay autonomous while you stay in control.

What you don't have to build

Building a Solana payment stack from scratch is weeks of infrastructure. Viaclave ships it as one API.

Without Viaclave

  • Run a Solana RPC node (or pay Helius/QuickNode)
  • Generate, store, and rotate keypairs securely
  • Handle priority fees and retry on dropped tx
  • Reconcile incoming deposits across mints
  • Write idempotency, refund, and ledger logic
  • Build subscription billing and retry logic
  • Build escrow and conditional release flows
  • Enforce spending policies in your own app code
  • Integrate swap routing

With Viaclave

  • POST /v1/wallets — wallet created instantly
  • POST /v1/payments/send — payment moves
  • POST /v1/subscriptions — recurring billing handled
  • POST /v1/conditional-payments — escrow with conditions
  • POST /v1/policies — declarative spending rules
  • POST /v1/payments/simulate — dry-run before charging
  • GET /v1/lookup — find anything by id, handle, or address
  • Webhooks, idempotency, refunds built in
  • USDC, USDT, PYUSD, EURC out of the box

A complete platform, not a single endpoint

Every primitive your agents need to transact, control spend, and bill customers

Custodial wallets

Viaclave signs every transaction server-side. Agents are stateless. They issue commands, we handle keys.

Instant internal transfers

Internal transfers settle off-chain via atomic Durable Object balances. Zero gas, zero on-chain wait.

Multi-stablecoin

USDC, USDT, PYUSD, and EURC out of the box. Send, receive, and check balances across all four.

SOL ↔ USDC swaps

Best-route swaps with slippage control. All triggered from a single API call.

Spending policies

Per-transaction limits, daily caps, recipient allowlists, and custom rules enforced before anything hits the chain.

Subscriptions

Recurring agent-to-agent billing. Set an interval and amount, and Viaclave handles charges, retries, and cancellation.

Conditional Payments

Escrow funds until a condition is met. Release on webhook confirmation, signature verification, or timeout.

Reservations

Hold funds for future use without moving them. Reserve a budget, then confirm or release when the task completes.

Address book

Save and label trusted recipients. Simplify repeat payments and enforce allowlists with named contacts.

Rate cards

Publish per-call pricing for your agent's tools. Let other agents discover and pay at your published rates.

Universal lookup

Find any wallet, agent, or transaction by ID, handle, or Solana address with a single GET request.

MCP-native

Expose every capability as a Claude/GPT tool via the MCP server. AI agents discover and call without writing code.

How a payment moves

Four steps, one API call. Internal transfers settle off-chain in milliseconds.

1

Agent A calls the API

POST /v1/payments/send

Bearer token auth, no keypair

2

Viaclave validates

Policy check · Simulation · Limits

Blocked if over budget

3

Ledger settles atomically

Debit sender, credit receiver

Idempotent · Auditable

4

Agent B gets a webhook

payment.completed event

Real-time, no polling

< 50ms
Internal transfer
Off-chain, zero gas
~ 400ms
External send
On-chain with managed signing
Atomic
Settlement
Idempotent debit/credit pair

Cheap enough for agent-to-agent

Card networks were built for humans buying coffee. They can't price a single LLM inference call. Viaclave's architecture is what makes per-task agent payments economically viable.

Edge-deployed, not server-rented

Viaclave runs on Cloudflare Workers. No 24/7 RPC nodes burning cash, no Kubernetes cluster, no idle capacity to amortize. We pay only for the requests we actually serve, and so do you.

Off-chain ledger absorbs micro-tx

Internal Viaclave-to-Viaclave transfers never hit Solana. They settle atomically in a Durable Object. Zero gas, zero RPC cost. Perfect for agents paying agents per task.

Stablecoin-native, not card-based

We don't pay Visa, Mastercard, or correspondent banks. There's no chargeback machinery to fund. The only real cost is signing, monitoring, and webhook delivery.

Controls reduce blast radius

Policies, simulation, and reservations catch mistakes before they hit chain. Cheaper than refunds, cheaper than incidents. Built-in guardrails mean fewer support tickets.

For AI Agents

If you're an agent, start here.

Viaclave exposes its full API as an MCP skill. Drop it into your Claude, GPT, or custom agent and it gains wallets, payments, subscriptions, escrow, spending policies, and swaps. No integration code required.

MCP install docs
Available tools
create_walletCreate a custodial Solana wallet
send_paymentPay another agent in any stablecoin
send_to_addressSend tokens to any Solana address
simulate_paymentDry-run a payment before sending
swap_tokensSwap between SOL and USDC
verify_transactionConfirm any Solana tx by signature
request_paymentRequest payment from another agent
wait_for_paymentPoll until a payment completes
set_spending_limitsSet daily and per-tx caps
lookupFind agents, wallets, or txns by any identifier
get_balancesAll stablecoin balances at a glance
withdrawWithdraw tokens to an external address
+ 13 more tools

The full platform, in one API

Every primitive your agents need to transact, control spend, and bill customers

Payments

Internal transfers
Instant off-chain settlement between Viaclave wallets
External sends
On-chain to any Solana address with managed signing
Payment simulation
Dry-run any payment to check limits and balances
Payment retry
Retry failed transactions with a single API call

Automation

Subscriptions
Recurring agent-to-agent billing with auto-retry
Conditional Payments
Escrow with webhook or signature release conditions
Reservations
Hold funds for future use, confirm or release later
Webhooks
Real-time event notifications for every state change

Controls

Spending policies
Daily caps, per-tx limits, recipient allowlists
Rate cards
Publish per-call pricing for your agent's tools
Address book
Manage trusted recipients and named contacts
Billing tiers
Upgrade for higher throughput and priority settlement

Developer Tools

MCP server
Expose everything as Claude/GPT tools instantly
Universal lookup
Find anything by ID, handle, or Solana address
Transaction verification
Confirm any Solana transaction by signature
Multi-stablecoin
USDC, USDT, PYUSD, EURC in every endpoint

Ready to give your agent a wallet?

Free to start. No credit card. Start building in 60 seconds.