Crea un agente con createClient da @blockchain0x/node (o il client Python), invia un pagamento USDC con payments.create e verifica il webhook firmato con webhooks.verify. I controlli di spesa sono impostati nel dashboard e in sola lettura tramite l'API. L'agente non tocca mai direttamente le chiavi private. Meno di dieci minuti dall'iscrizione al tuo primo pagamento USDC su Base, in TypeScript o Python.

Crea il profilo dell'agente.

Il profilo dell'agente è l'identità indirizzabile dietro ogni pagamento che il tuo agente invia o riceve. Contiene l'indirizzo del wallet, la pagina pubblica, i badge di verifica e (in seguito) la politica di spesa. Creane uno per ogni agente logico.

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.

Gestisci il webhook.

I webhook sono come scopri che un pagamento è stato regolato. In Node, webhooks.verify da @blockchain0x/node esegue il controllo HMAC e restituisce un'unione discriminata; in altre lingue, calcola lo stesso HMAC sul corpo grezzo. Dirama in base al tipo di evento (payment.received per in entrata), rispondi rapidamente con 2xx e metti in coda qualsiasi cosa più pesante dietro il 2xx in modo che la consegna non scada.

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)

Testa l'intero flusso su Base Sepolia.

Prima di passare a sk_live_ chiavi, esegui l'intero percorso end-to-end con sk_test_. Una chiave di test mantiene tutto su Base Sepolia, dove finanzi il portafoglio dal rubinetto pubblico e le forme di risposta corrispondono a quelle live. Il prefisso della chiave sceglie la rete, quindi una chiave di test non può muovere fondi di mainnet.

Esercita tre scenari: un pagamento a percorso felice che attiva payment.received, una consegna mancata (puntare il webhook a un URL non funzionante, quindi riconciliare recuperando la transazione con transactions.get), e un tentativo di webhook (restituire un 500 la prima volta, 200 la seconda, e confermare che il tuo gestore è idempotente). Quando tutti e tre superano il test, scambia la chiave e spediscila.

Una volta che hai il tuo primo pagamento.

Con i pagamenti di base funzionanti, i seguiti che rendono di più sono i controlli di spesa (così l'agente non può scappare con il budget), la robustezza dei webhook (così i pagamenti non vengono silenziosamente persi sotto carico) e la verifica dell'identità (così le controparti si fidano della pagina pubblica dell'agente).

Il riferimento completo dell'API si trova su docs.blockchain0x.com. Superficie di prodotto per le stesse API: Payment API.