Créez un agent avec createClient de @blockchain0x/node (ou le client Python), envoyez un paiement USDC avec payments.create, et vérifiez le webhook signé avec webhooks.verify. Les contrôles de dépenses sont définis dans le tableau de bord et en lecture seule via l'API. L'agent ne touche jamais directement aux clés privées. Moins de dix minutes de l'inscription à votre premier paiement USDC sur Base, en TypeScript ou Python.

Créer le profil de l'agent.

Le profil de l'agent est l'identité adressable derrière chaque paiement que votre agent envoie ou reçoit. Il contient l'adresse du portefeuille, la page publique, les badges de vérification et (plus tard) la politique de dépenses. Créez-en un par agent logique.

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.

Gérez le webhook.

Les webhooks sont comment vous découvrez qu'un paiement est réglé. Dans Node, webhooks.verify de @blockchain0x/node effectue la vérification HMAC et renvoie une union discriminée ; dans d'autres langages, calculez le même HMAC sur le corps brut. Branchez-vous sur le type d'événement (payment.received pour les entrées), répondez rapidement 2xx et mettez en file d'attente tout ce qui est plus lourd derrière le 2xx afin que la livraison ne dépasse pas le délai.

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)

Testez l'ensemble du flux sur Base Sepolia.

Avant de passer aux clés sk_live_, exécutez le chemin complet de bout en bout avec sk_test_. Une clé de test garde tout sur Base Sepolia, où vous financez le portefeuille depuis le robinet public et les formes de réponse correspondent à la version en direct. Le préfixe de clé choisit le réseau, donc une clé de test ne peut pas déplacer des fonds du mainnet.

Exercez trois scénarios : un paiement sur la bonne voie qui déclenche payment.received, une livraison manquée (pointez le webhook vers une URL morte, puis réconciliez en récupérant la transaction avec transactions.get), et une nouvelle tentative de webhook (retournez un 500 la première fois, 200 la seconde, et confirmez que votre gestionnaire est idempotent). Lorsque les trois réussissent au test, échangez la clé et expédiez.

Une fois que vous avez votre premier paiement.

Avec des paiements de base fonctionnant, les suivis les plus rentables sont les contrôles de dépenses (pour que l'agent ne puisse pas s'enfuir avec le budget), la robustesse des webhooks (pour que les paiements ne tombent pas silencieusement sous charge) et la vérification d'identité (pour que les contreparties fassent confiance à la page publique de l'agent).

La référence API complète se trouve à docs.blockchain0x.com. Surface produit pour les mêmes API : API de paiement.