Do you ever hold my money?

No. Every payment moves directly between wallets. We build and verify the transaction and send you a receipt — we never custody, route or freeze funds. That's the whole point of the non-custodial design.

Which AI agents are supported?

Any agent that can call an API or run code can connect — via Model Context Protocol (MCP), function-calling tools, our open-source SDK (Python/TypeScript), or direct REST. The grid above lists the most popular ones with the recommended method for each.

How does my agent send or receive money?

To send, the agent asks us to build a payment, then signs and broadcasts it from its own wallet. To receive, you list products or share a hosted checkout link and buyers pay your wallet directly.

Can it do real Bitcoin or USDT, not just Base tokens?

Yes. Alongside instant micro-swaps on Base, there are real cross-chain swaps to native BTC, USDT (TRC20/ERC20) and Monero — the same engine the website uses for people.

Who sets the spending limits?

You do. Every key has a per-transaction cap, a per-minute rate limit and a daily USD cap — and the agent (or its human owner) sets them itself via POST /limits (MCP tool ace_set_limits). A cap of 0 means no limit for that field. A good pattern is for the bot to ask its owner for the numbers on first run, or start with a small safe default and raise it. Session keys add allow-lists and expiry, and there is an instant kill switch.

How can a human see what the bot is doing?

Each bot owner gets a read-only activity link — a live dashboard of swaps, payments, fees and timestamps. It can only view, never spend. Your backend can also subscribe to signed webhooks or pull the events feed for every action in real time.

Can an agent run a subscription or bill for usage?

Yes. Create a recurring plan or meter usage; each cycle we raise an invoice (a checkout to your wallet) and fire a subscription.due event. We invoice; the payer settles — we never auto-debit or hold funds.

Yes — a refund builds a reverse transfer the merchant signs to return the buyer's funds, and the order is marked refunded. For stuck cross-chain swaps there's an emergency EXCHANGE/REFUND option too.

Can the owner fund the bot's wallet?

Yes — two ways. (1) Send crypto directly to the agent's own wallet address — instant, nothing extra needed. (2) A funding link: a fiat→crypto on-ramp pre-filled to the agent wallet, where a human completes the card/bank payment. Either way the crypto goes straight to the agent (non-custodial); agents can't pay with a card themselves, so the fiat step needs a human.

Connecting is free. A small platform fee (about 0.5%) applies to value actions, taken on each rail's native fee mechanism — never by holding your funds.

Integration hub

Connect your AI agent — step by step

Three things, once: 1) get an agent key, 2) pick the method your agent supports, 3) drop in the snippet. Everything is non-custodial.

Verify we're live: /health · machine-readable capability card.

What you can — and can't — do

✅ Can

Swap on Base (gasless micro) and real cross-chain to native BTC, USDT (TRC20/ERC20), XMR.
Pay any Base address (USDC/ETH/…) — you sign & broadcast.
Accept payments (commerce): products, checkouts, hosted page + QR.
Run subscriptions, meter usage, raise invoices.
Charge/pay per call (x402 USDC, L402 Lightning).
Refund orders; emergency EXCHANGE/REFUND on stuck cross-chain swaps.
Get signed webhooks + an events feed; read caps + activity.
Be funded via a fiat on-ramp link (or a direct crypto transfer).

🚫 Can't (by design)

We never hold your funds — money moves wallet-to-wallet.
Nothing moves without your signature — we only build/verify.
Can't exceed the per-tx / daily / per-minute limits you set (a cap of 0 = no limit).
Can't pay with a card by itself — a human completes the fiat on-ramp payment.
No true hold-and-release escrow yet (needs an audited on-chain contract — deferred).
Closed consumer agents with no tool API can only receive (via a checkout link).

What you need before you start

An agent key (from the operator) — it carries your per-tx, daily and per-minute caps.
Your own wallet — register its public address (/wallet/register). Private keys stay in your SDK, never with us.
est_usd on value calls — pass the USD value on swap / pay / cross-chain so caps apply (required, > 0).
Funds in the wallet — send crypto to it, or use a funding link (step 4 below).
Optional: a webhook URL (public HTTPS) for push events; a merchant wallet if you'll receive payments.

1 · Find your agent

2 · What you can call

Once connected, your agent has the full surface — every part non-custodial:

🔄 Swap

Base micro-swaps (/swap/*) + real cross-chain BTC/USDT/XMR (/ff/*), incl. emergency/refund.

📤 Pay anyone

Build a payment to any Base address (/pay) — within your limits; you sign & broadcast.

🧾 Commerce

Merchants, products, checkouts, confirm, refund, deliver (/commerce/*).

🔁 Billing

Subscriptions + usage metering + invoices (/billing/*).

⚡ Pay-per-call

x402 (USDC) + L402 (Lightning) metered access.

🔔 Events

Signed webhooks + events feed (/events, /webhooks/*).

👛 Wallet

Session keys, caps, allow-lists, kill switch (/wallet/*).

🏦 Funding

Fiat→crypto on-ramp link to the agent wallet (/fund/link).

📊 Visibility

Caps (/limits), activity (/activity) + a read-only human dashboard.

3 · Connection methods

MCP

Model Context Protocol (MCP)

Agents/clients that speak MCP.

Get an agent key from the operator (admin → AI Agent API).
Add our MCP server to your client. Tool discovery (tools/list) is public; authenticated tool calls are signed with your key.
For clients that can't sign each call themselves, run the open-source SDK signer in front (it adds the HMAC).

{
  "mcpServers": {
    "acechange": {
      "url": "https://www.acechange.io/wp-json/acechange-agent/v1/mcp"
    }
  }
}

Functions

Function / tool calling

OpenAI-style tools (function calling).

Import our ready tool schemas: agent-wallet/examples/openai-functions.json.
Expose them as tools to your model.
Your backend signs each call (METHOD\nROUTE\nTS\nBODY, HMAC) — or use the SDK which signs for you.

// tools = JSON.parse(read('openai-functions.json'))
// on tool call → POST to the AceChange REST endpoint, signed with your key

SDK

Open-source SDK (Python / TypeScript)

Frameworks & custom agents (LangChain, CrewAI, AutoGPT, …).

Install the SDK and load your agent key (the SDK holds the wallet keys, never us).
Register the AceChange tools with your framework (a LangChain example ships in the repo).
Call swap / pay / cross-chain / commerce — the SDK signs every request.

pip install acechange-agent-wallet     # Python
npm i @acechange/agent-wallet          # TypeScript

REST

Direct REST API

Any backend / enterprise platform (OpenAPI actions).

Sign each request: HMAC-SHA256 of "METHOD\nROUTE\nTS\nBODY" keyed by hex(sha256(secret)).
Send X-Ace-Agent-Key / -Timestamp / -Sign headers.
Call the endpoint (e.g. POST /ff/create for a real BTC/USDT swap).

curl -X POST .../wp-json/acechange-agent/v1/ff/create \
  -H 'X-Ace-Agent-Key: ag_…' -H 'X-Ace-Agent-Timestamp: …' -H 'X-Ace-Agent-Sign: …' \
  -d '{"from":"USDC","to":"BTC","amount":100,"toAddress":"bc1q…","est_usd":100}'

No-code

No-code automation (Zapier / n8n / Lindy)

Automation platforms with an HTTP step.

Add an "HTTP Request" action pointing at the AceChange REST endpoint.
Put the signed auth headers in the request (compute the HMAC in a small code step).
To only RECEIVE money, skip the API entirely — just share your hosted checkout link.

HTTP Request → POST /wp-json/acechange-agent/v1/pay
Headers: X-Ace-Agent-Key, X-Ace-Agent-Timestamp, X-Ace-Agent-Sign

Receive-only

Receive-only (closed agents)

Consumer agents with no public tool hook yet.

This agent can't (yet) call external tools, so it can't spend through an API.
But it — or its user — can still PAY you: share your hosted checkout link (QR + one-tap wallet).
When the agent gains tool/MCP support, switch it to the MCP or SDK method above.

Share: https://www.acechange.io/pay/?order=ord_…  (buyer pays your wallet directly)

4 · Fund your agent

The agent spends from its OWN wallet, so give it crypto first — two ways:

① Send crypto directly

Send to the agent's registered wallet address (right coin + network). Instant, nothing extra needed — works for BTC / USDC / ETH / etc.

② Fiat on-ramp link

GET /fund/link?wallet=&amount=&crypto=&network= (or MCP ace_fund) → a card/bank → crypto link pre-filled to the agent wallet. A human completes the payment; the crypto lands in the wallet. Needs the operator's on-ramp key.

Non-custodial: funds go straight to the agent wallet — never through AceChange.

5 · Get a key & go live

Ask the operator for an agent key (it carries your spend limits). Then your bot can swap, pay, accept payments and pay-per-call. A human can watch it live via a read-only activity link.

Full reference: the human-readable API documentation (every endpoint, MCP tool, event and error code), the machine-readable capability card, and the open-source SDK on GitHub (Python & TypeScript — read exactly how it signs & that keys stay local).

A worked example: a $25/day API-paying agent

Here is the whole flow, end to end, for a common case — a LangChain or CrewAI agent that needs to call a paid data API and must stay inside a budget you set.

Get a key. The operator issues you an agent key carrying hard caps — for example $25 per transaction and $100 per day.
Create the wallet. Install the SDK and run AgentWallet.create(). The private key is generated and AES-256-GCM-encrypted on your machine — it never reaches AceChange.
Register the policy. Send the wallet’s public address plus a session policy (per-tx, daily, allowed tokens). We store only that — never a key.
Let it pay. When the API replies 402 Payment Required, your agent runs the x402 flow, signs the USDC authorization locally, and retries. The request goes through and the API gets paid — in real USDC, for a fraction of a cent.
Watch it live. Every payment, fee and status appears on the read-only activity dashboard you can share with a human.

The agent paid a real API, in real money, inside a budget you controlled — and at no point did AceChange hold, route or freeze the funds.

What each capability is for

A plain-language note on when to reach for each one.

Pay anyone

One-off transfers: settle an invoice, pay a supplier or another agent. Use when you know the recipient address and amount.

Micro-swap (Base)

Convert between tokens on Base with no minimum — e.g. turn ETH into USDC before paying. Gasless; the agent signs the 0x payload.

Cross-chain swap

When you must pay in native BTC, USDT (TRC20/ERC20) or XMR. Has a per-pair minimum; you deposit from your own wallet.

x402 / L402

Charge or pay per request — metered access to an API or content. x402 = USDC on Base; L402 = Bitcoin Lightning.

Commerce

Sell something: register your receive wallet, list a product, take a checkout that pays your wallet directly.

Subscriptions & invoicing

Recurring or usage-based billing. We raise an invoice each cycle; the payer settles — never an auto-debit.

Marcus Richardson — Founder & Privacy Research Lead · www.linkedin.com · Last updated June 19, 2026