Crie um agente com createClient de @blockchain0x/node (ou o cliente Python), envie um pagamento USDC com payments.create e verifique o webhook assinado com webhooks.verify. Os controles de gastos são definidos no painel e são somente leitura pela API. O agente nunca toca nas chaves privadas diretamente. Menos de dez minutos do registro até o seu primeiro pagamento USDC no Base, em TypeScript ou Python.

Crie o perfil do agente.

O perfil do agente é a identidade endereçável por trás de cada pagamento que seu agente envia ou recebe. Ele contém o endereço da carteira, a página pública, os distintivos de verificação e (mais tarde) a política de gastos. Crie um por agente lógico.

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.

Gerencie o webhook.

Webhooks são como você descobre que um pagamento foi liquidado. No Node, webhooks.verify de @blockchain0x/node faz a verificação HMAC e retorna uma união discriminada; em outras linguagens, calcule o mesmo HMAC sobre o corpo bruto. Faça ramificações com base no tipo de evento (payment.received para inbound), responda 2xx rapidamente e coloque qualquer coisa mais pesada atrás do 2xx para que a entrega não expire.

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)

Teste todo o fluxo no Base Sepolia.

Antes de mudar para chaves sk_live_, execute todo o caminho de ponta a ponta com sk_test_. Uma chave de teste mantém tudo no Base Sepolia, onde você financia a carteira a partir da torneira pública e as formas de resposta correspondem ao vivo. O prefixo da chave escolhe a rede, então uma chave de teste não pode mover fundos da mainnet.

Exercite três cenários: um pagamento de caminho feliz que dispara payment.received, uma entrega perdida (apontar o webhook para uma URL morta, depois reconciliar buscando a transação com transactions.get), e uma nova tentativa de webhook (retornar um 500 na primeira vez, 200 na segunda, e confirmar que seu manipulador é idempotente). Quando os três passarem no teste, troque a chave e envie.

Uma vez que você tenha seu primeiro pagamento.

Com os pagamentos básicos funcionando, os seguimentos que mais compensam são controles de gastos (para que o agente não possa fugir com o orçamento), robustez de webhook (para que os pagamentos não caiam silenciosamente sob carga) e verificação de identidade (para que as contrapartes confiem na página pública do agente).

A referência completa da API está em docs.blockchain0x.com. Superfície de produto para as mesmas APIs: API de Pagamento.