Create an agent with createClient from @blockchain0x/node (or the Python client), send a USDC payment with payments.create, and verify the signed webhook with webhooks.verify. Spend controls are set in the dashboard and read-only over the API. The agent never touches private keys directly. Under ten minutes from sign-up to your first USDC payment on Base, in TypeScript or Python.

Create the agent profile.

The agent profile is the addressable identity behind every payment your agent sends or receives. It carries the wallet address, the public page, the verification badges, and (later) the spend policy. Create one per logical agent.

import { createClient } from "@blockchain0x/node";

const client = createClient({ apiKey: process.env.BLOCKCHAIN0X_API_KEY! }); // sk_test_ / sk_live_

const agent = await client.agents.create({ name: "research-bot" });

console.log(agent.id); // "agt_..."
// Public page: https://wallet.blockchain0x.com/a/{slug}

from blockchain0x import Client

client = Client()  # reads BLOCKCHAIN0X_API_KEY from the environment

agent = client.agents.create(body={"name": "research-bot"})

print(agent["id"])  # "agt_..."
# Public page: https://wallet.blockchain0x.com/a/{slug}

After this call, the agent has a public page at https://wallet.blockchain0x.com/a/<slug> that any counterparty (human or agent) can hover for verification info. See the agent payment identity glossary entry for what that page exposes.

Handle the webhook.

Webhooks are how you find out a payment settled. In Node, webhooks.verify from @blockchain0x/node does the HMAC check and returns a discriminated union; in other languages, compute the same HMAC over the raw body. Branch on the event type (payment.received for inbound), respond 2xx quickly, and queue anything heavier behind the 2xx so the delivery does not time out.

import express from "express";
import { webhooks } from "@blockchain0x/node";

const app = express();
// Capture the RAW body. The HMAC is over the exact bytes on the wire.
app.use(express.raw({ type: "application/json" }));

app.post("/webhooks/payment", (req, res) => {
  const result = webhooks.verify({
    headers: req.headers,
    rawBody: req.body, // Buffer, raw bytes
    secret: process.env.BLOCKCHAIN0X_WEBHOOK_SECRET!,
  });
  if (!result.ok) return res.status(400).json({ code: result.code });

  if (result.eventType === "payment.received") {
    // USDC landed - deliver the work, fulfil the order, etc.
    void deliver(result.eventId);
  }
  res.status(200).send("ok");
});

import hmac, hashlib, os, time
from flask import Flask, request, abort

app = Flask(__name__)
SECRET = os.environ["BLOCKCHAIN0X_WEBHOOK_SECRET"].encode()

@app.post("/webhooks/payment")
def webhook():
    raw = request.get_data()  # RAW bytes - do not parse first
    sig = request.headers.get("X-Blockchain0x-Signature", "")
    ts = request.headers.get("X-Blockchain0x-Timestamp", "")
    parts = dict(p.split("=", 1) for p in sig.split(",") if "=" in p)
    t, v1 = parts.get("t", ts), parts.get("v1", sig)
    want = hmac.new(SECRET, t.encode() + b"." + raw, hashlib.sha256).hexdigest()
    if not hmac.compare_digest(want, v1) or abs(time.time() - int(t)) > 300:
        abort(401)
    if request.headers.get("X-Blockchain0x-Event-Type") == "payment.received":
        deliver(request.get_json())  # USDC landed
    return ("ok", 200)

Test the whole flow on Base Sepolia.

Before flipping to sk_live_ keys, run the full path end-to-end with sk_test_. A test key keeps everything on Base Sepolia, where you fund the wallet from the public faucet and the response shapes match live. The key prefix picks the network, so a test key cannot move mainnet funds.

Exercise three scenarios: a happy-path payment that fires payment.received, a missed delivery (point the webhook at a dead URL, then reconcile by fetching the transaction with transactions.get), and a webhook retry (return a 500 the first time, 200 the second, and confirm your handler is idempotent). When all three pass on test, swap the key and ship.

Once you have your first payment.

With basic payments working, the follow-ups that pay off most are spend controls (so the agent cannot run away with the budget), webhook robustness (so payments do not silently drop under load), and identity verification (so counterparties trust the agent's public page).

Full API reference lives at docs.blockchain0x.com. Product surface for the same APIs: Payment API.