About agentic-pay
agentic-pay is a cross-platform payment engine for AI agents to send and receive seven cryptocurrencies. It combines per-agent spending policies and an idempotent ledger, with self-hosted and hosted options.
Key features
- 01Send and receive seven cryptocurrencies
- 02Per-agent and daily spending caps
- 03Human-confirmation thresholds
- 04Address allowlisting
- 05Idempotent payment ledger
Use cases
- 01Let an AI agent pay across supported crypto rails
- 02Set limits on agent payment activity
- 03Prevent duplicate payments after a retry
MCP support
The project documents integration with MCP clients and exposes an HTTP-based agent integration path. The input does not specify an MCP server interface or tools.
Configuration
Local server config is the same for every client. Copy it into your client’s MCP config file.
npx -y @shieldcubed/agentic-payAGENTIC_PAY_AGENT_IDIdentifier for this agent, used to look up its spend-limit policy in config.json.AGENTIC_PAY_CONFIGAbsolute path to your config.json (spend limits, API keys, static prices). Defaults to config/config.json in the install directory.BTC_WIFSecretWIF-encoded Bitcoin private key for the funding wallet. Only required if using the BTC rail.ETH_RPC_URLEVM JSON-RPC endpoint URL. Only required if using the ETH/USDT/USDC rails.ETH_PRIVATE_KEYSecret0x-prefixed Ethereum private key for the funding wallet. Only required if using the ETH/USDT/USDC rails.Local servers need a runtime on your machine (e.g. Node.js 18+). Config file locations differ by client; see your client’s docs.
Tools
5Saved tool list · updated 3w ago
This tool takes no parameters.
Details
From the project READMEAgentic Pay 
A cross-platform payment engine that lets third-party AI agents send and receive payments over seven crypto rails: BTC, ETH, USDT, USDC, XRP, XMR, ZEC.
One Node.js core runs unmodified on Linux, Windows, and macOS. The same backend is reachable from iOS and Android via an installable Progressive Web App (PWA) — there is no separate native mobile codebase to maintain.
Architecture
┌───────────────────────────┐
│ core/railManager.js │ <- one call-site for
│ (policy + ledger + auth) │ every asset
└─────────────┬─────────────┘
│
┌───────────┬─────────────┼─────────────┬───────────┬──────────┐
│ │ │ │ │ │
rails/btc rails/eth rails/xrp rails/xmr rails/zec │
(bitcoinjs) (ethers.js, (xrpl.js) (JSON-RPC to (JSON-RPC to │
ETH+USDT+ monero- zcashd) │
USDC ERC20) wallet-rpc) │
│
Agent-facing surfaces (both call railManager, never a rail │
adapter directly): │
┌────────────────────────┐ ┌───────────────────────────┐ │
│ server/restApi.js │ │ server/mcpServer.mjs │ │
│ HTTP/JSON, API-key │ │ MCP stdio server for │ │
│ auth, for any HTTP- │ │ Claude / other MCP- │ │
│ capable agent stack │ │ compatible agent clients │ │
└────────────────────────┘ └───────────────────────────┘ │
│
Human-facing surfaces: │
┌────────────────────────┐ ┌───────────────────────────┐ │
│ cli/index.js │ │ web/ (PWA) │ │
│ Linux/Windows/macOS │ │ served by server/ │ │
│ terminal │ │ staticWeb.js, installable │ │
│ │ │ on iOS/Android home screen │ │
└────────────────────────┘ └───────────────────────────┘ │
Every send, from any surface, passes through core/limits.js (per-agent
spend caps + human-confirmation floor) and core/ledger.js (idempotency,
so a retried tool call can never double-pay).
Quick start (any OS with Node.js 18+)
git clone <this repo> # or unzip the delivered archive
cd agentic-pay
npm install
cp config/.env.example .env
cp config/config.example.json config/config.json
# edit both files — see docs/SETUP_<YOUR_OS>.md for exact values per rail
npm run start:rest # REST API on :8787
npm run start:web # PWA on :8788 (optional, for mobile/browser access)
npm run start:mcp # MCP stdio server (for Claude Desktop / Claude Code)
node cli/index.js rails # sanity check from the terminal
Start on testnets first. Every rail's example config defaults to a
testnet or requires you to explicitly fill in mainnet values — this is
intentional. Do not point real funds at this system until you've reviewed
core/limits.js and set spend caps you're comfortable with.
Hosted (custodial) — skip the setup
Don't want to run your own node? Aumnium operates a hosted instance at https://api.aumnium.tech — deposit USDC, get a spendable custodial balance, and start sending across all seven rails without installing or funding anything yourself.
This is a different trust model than the self-hosted instructions above: your funds sit in a pooled wallet operated by Aumnium (not your own keys), and each send is charged a 1% fee plus network cost, deducted from your balance. The self-hosted path above remains fully non-custodial; this hosted path trades that for convenience.
# 1. Get your deposit address
curl -H "x-api-key: YOUR_KEY" https://api.aumnium.tech/v1/deposit/address
# 2. Send USDC to that address on Ethereum mainnet
# 3. Claim your deposit once it confirms
curl -X POST -H "x-api-key: YOUR_KEY" -H "Content-Type: application/json" \
-d \'{"txHash":"0x..."}\' \
https://api.aumnium.tech/v1/deposit/claim
# 4. Send payments (billed per-call via x402, USDC on Base)
curl -X POST -H "x-api-key: YOUR_KEY" -H "Content-Type: application/json" \
-d \'{"asset":"USDC","to":"0x...","amount":1,"idempotencyKey":"unique-key"}\' \
https://api.aumnium.tech/v1/send
Contact [email protected] for an API key. Full endpoint list at https://api.aumnium.tech.
Where to go next
docs/SETUP_LINUX.mddocs/SETUP_WINDOWS.mddocs/SETUP_MACOS.mddocs/SETUP_MOBILE.md— iOS and Android via PWAdocs/AGENT_INTEGRATION.md— wiring up Claude, MCP clients, or any HTTP-based agent frameworkdocs/SECURITY.md— key management, spend limits, and legal/regulatory considerations — read this before sending real funds
What's genuinely production-ready here vs. what's a starting point
- Production-shaped: the policy engine (per-tx cap, daily cap, confirmation floor, address allowlisting), the idempotent ledger, and the unified rail interface.
- Starting point, needs hardening for real money at scale: the
JSON-file ledger (swap for a real database under load), the static
USD price table (wire in a live price feed), and key storage (move
from
.envto an OS keychain or HSM/KMS for anything beyond development — seecore/keystore.jsfor the extension point).
License
agentic-pay is licensed under the Business Source License 1.1 (see
LICENSE). In plain terms:
- You can use, modify, and self-host this freely — for yourself, your own organization, or your own agents, including production use.
- You cannot turn around and offer it as a competing hosted/managed payments-as-a-service product to third parties without a commercial license.
- On 2030-07-14, this version automatically converts to the Apache License 2.0 — fully open source, no restrictions.
Want a commercial license for a hosted/managed offering before then? Contact [email protected].
Comments
New to MCP?
From what the protocol is to installing your first server, these answers cover most first questions.
An open protocol that defines how AI applications connect to external tools and data in a uniform way. Clients talk to the model; MCP servers provide tools, resources and prompt templates. They exchange standard messages, so one server can be reused by many clients.