# Give Your AI Agent a Wallet — Autonomous USDC Payments in 10 Minutes

Human                          Agent
  │                              │
  ├─ Register & KYC              │
  ├─ Create agent wallet         │
  ├─ Set spend policy            │
  │  (max $10/tx, AgentToMerchant only)
  ├─ Fund via Stripe ($50 USDC)  │
  │                              │
  │                    ┌─────────┴──────────┐
  │                    │  Agent runs task   │
  │                    │  Needs to pay $1   │
  │                    │  for data API      │
  │                    └─────────┬──────────┘
  │                              │
  │                    POST /agent/payments/merchant
  │                    X-Agent-Key: wlt_live_...
  │                              │
  │                    ← 202 Accepted
  │                    ← Solana tx confirmed in ~3s

wlt_live_8c4a6407-2635-401d-8ef7-eaed31d1973f_a3x9k2m...

curl https://api.walleteer.ai/agent/balance \
  -H "X-Agent-Key: wlt_live_YOUR_KEY_HERE"

{
  "amount": 10.00,
  "currency": "USDC"
}

import httpx

AGENT_KEY = "wlt_live_YOUR_KEY_HERE"
BASE_URL = "https://api.walleteer.ai"

headers = {"X-Agent-Key": AGENT_KEY}

response = httpx.get(f"{BASE_URL}/agent/balance", headers=headers)
balance = response.json()
print(f"Balance: {balance['amount']} {balance['currency']}")
# Balance: 10.00 USDC

const AGENT_KEY = "wlt_live_YOUR_KEY_HERE";
const BASE_URL = "https://api.walleteer.ai";

const response = await fetch(`${BASE_URL}/agent/balance`, {
  headers: { "X-Agent-Key": AGENT_KEY }
});
const balance = await response.json();
console.log(`Balance: ${balance.amount} ${balance.currency}`);
// Balance: 10.00 USDC

response = httpx.get(f"{BASE_URL}/merchants", headers=headers)
merchants = response.json()

for merchant in merchants:
    print(f"{merchant['name']} — code: {merchant['merchantCode']}")

import uuid

payment = httpx.post(
    f"{BASE_URL}/agent/payments/merchant",
    headers={**headers, "Content-Type": "application/json"},
    json={
        "merchantCode": "DATAAPI01",
        "amount": 1.00,
        "currency": "USDC",
        "idempotencyKey": str(uuid.uuid4()),  # unique per payment attempt
        "itemizedDetails": "web_scrape:url=example.com"
    }
)

result = payment.json()
print(f"Payment {result['status']} — tx: {result['transactionId']}")
# Payment Completed — tx: f81eb8ef-b99a-4548-...

# Agent A pays Agent B for completing a research subtask
payment = httpx.post(
    f"{BASE_URL}/agent/payments/agent",
    headers={**headers, "Content-Type": "application/json"},
    json={
        "recipientAgentId": "af9669b2-f3ee-4d94-8cdc-510afc6a3f9c",
        "amount": 0.50,
        "currency": "USDC",
        "idempotencyKey": str(uuid.uuid4())
    }
)

import httpx
import uuid

class WalleteerClient:
    def __init__(self, agent_key: str):
        self.headers = {
            "X-Agent-Key": agent_key,
            "Content-Type": "application/json"
        }
        self.base_url = "https://api.walleteer.ai"

    def get_balance(self) -> float:
        r = httpx.get(f"{self.base_url}/agent/balance", headers=self.headers)
        return r.json()["amount"]

    def pay_merchant(self, merchant_code: str, amount: float, details: str = "") -> dict:
        r = httpx.post(
            f"{self.base_url}/agent/payments/merchant",
            headers=self.headers,
            json={
                "merchantCode": merchant_code,
                "amount": amount,
                "currency": "USDC",
                "idempotencyKey": str(uuid.uuid4()),
                "itemizedDetails": details
            }
        )
        r.raise_for_status()
        return r.json()


# In your agent loop
wallet = WalleteerClient("wlt_live_YOUR_KEY_HERE")

def run_agent_task(task: str):
    # Check balance before spending
    balance = wallet.get_balance()
    if balance < 1.0:
        raise ValueError("Insufficient balance — human needs to top up")

    # Agent decides it needs data
    print("Fetching research data...")
    payment = wallet.pay_merchant(
        merchant_code="DATAAPI01",
        amount=1.00,
        details=f"task:{task}"
    )
    print(f"Paid $1.00 USDC — {payment['status']}")

    # Continue with task using the paid-for data
    # ...

Max transaction amount: $10 USDC
Allowed corridors: AgentToMerchant, AgentToAgent
Daily limit: (coming soon)

from flask import Flask, request
import hmac
import hashlib

app = Flask(__name__)
WEBHOOK_SECRET = "your-webhook-secret"

@app.route("/webhooks/walleteer", methods=["POST"])
def handle_payment():
    # Verify signature
    sig = request.headers.get("X-Walleteer-Signature", "")
    expected = "sha256=" + hmac.new(
        WEBHOOK_SECRET.encode(),
        request.data,
        hashlib.sha256
    ).hexdigest()

    if not hmac.compare_digest(expected, sig):
        return "Forbidden", 403

    payload = request.get_json()
    if payload["event"] == "payment.completed":
        order_id = payload["orderId"]
        amount = payload["amount"]
        print(f"Received {amount} USDC for order {order_id}")
        fulfill_order(order_id)

    return "", 200