ข้ามไปยังเนื้อหาหลัก
เรียนรู้คู่มือเพิ่มการชำระเงินให้กับตัวแทน AI ของคุณ
คู่มือ

วิธีการเพิ่มการชำระเงินให้กับเอเจนต์ AI ของคุณ.

10 minutes
คำตอบสั้น

สร้างเอเจนต์ด้วย createClient จาก @blockchain0x/node (หรือไคลเอนต์ Python) ส่งการชำระเงิน USDC ด้วย payments.create และตรวจสอบ webhook ที่ลงนามด้วย webhooks.verify การควบคุมการใช้จ่ายตั้งค่าในแดชบอร์ดและอ่านได้เฉพาะผ่าน API เอเจนต์ไม่เคยสัมผัสกุญแจส่วนตัวโดยตรง ใช้เวลาไม่ถึงสิบจากการลงทะเบียนจนถึงการชำระเงิน USDC ครั้งแรกของคุณบน Base ใน TypeScript หรือ Python.

ข้อกำหนดเบื้องต้น

ก่อนที่คุณจะเริ่ม.

  • บัญชี Blockchain0x (ลงทะเบียนฟรี).
  • คีย์ API จากแดชบอร์ด (ใช้คีย์ sk_test_ สำหรับคู่มือนี้; คุณจะเปลี่ยนไปใช้ sk_live_ ในภายหลัง)
  • Node.js 20+ หรือ Python 3.11+ ในการทำงานของ agent ของคุณ
  • เอเจนต์ที่สร้างขึ้นบนเฟรมเวิร์กใด ๆ - LangChain, CrewAI, AutoGen, LlamaIndex, OpenAI Agents SDK, MCP, หรือโค้ด SDK ธรรมดา คำแนะนำไม่มีการจำกัดเฟรมเวิร์ก
  • จุดสิ้นสุด HTTPS ที่เข้าถึงได้จากอินเทอร์เน็ตสาธารณะเพื่อรับเว็บฮุก (ngrok หรือการแสดงตัวอย่างการปรับใช้ก็ใช้ได้สำหรับการพัฒนา)
ขั้นตอนที่ 1 จาก 5

สร้างโปรไฟล์เอเจนต์.

โปรไฟล์เอเจนต์คือเอกลักษณ์ที่สามารถระบุได้เบื้องหลังการชำระเงินทุกครั้งที่เอเจนต์ของคุณส่งหรือรับ มันมีที่อยู่กระเป๋าเงิน, หน้าเว็บสาธารณะ, แท็กการตรวจสอบ, และ (ในภายหลัง) นโยบายการใช้จ่าย สร้างหนึ่งต่อเอเจนต์ที่มีเหตุผล.

TypeScript
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}
Python
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.

ขั้นตอนที่ 2 จาก 5

ส่งการชำระเงิน.

payments.create sends USDC from the agent wallet. amountWei is base units (USDC has 6 decimals), so 0.01 USDC is the string "10000". The SDK auto-stamps an Idempotency-Key, and the call can return 503 until the chain adapter is wired for your network. To RECEIVE instead, settle an invoice you created in the dashboard with paymentRequests.settle - see the payment API page.

TypeScript
// Send a USDC payment from the agent wallet. amountWei is base units
// (USDC has 6 decimals): "10000" is 0.01 USDC. payments.create auto-stamps an
// Idempotency-Key and can return 503 until the chain adapter is wired.
const tx = await client.payments.create({
  agentId: agent.id,
  to: "0xRecipient",
  amountWei: "10000",
});

console.log(tx); // the submitted transfer
Python
# amountWei is USDC base units (6 decimals): "10000" is 0.01 USDC.
tx = client.payments.create(body={
    "agentId": agent["id"],
    "to": "0xRecipient",
    "amountWei": "10000",
})

print(tx)  # the submitted transfer
ขั้นตอนที่ 3 จาก 5

จัดการ webhook.

Webhooks เป็นวิธีที่คุณค้นพบว่าการชำระเงินได้ชำระแล้ว ใน Node, webhooks.verify จาก @blockchain0x/node จะทำการตรวจสอบ HMAC และส่งคืนการรวมที่แยกแยะ; ในภาษาอื่น ๆ คำนวณ HMAC เดียวกันกับเนื้อหาดิบ แยกตามประเภทเหตุการณ์ (payment.received สำหรับการเข้ามา) ตอบสนอง 2xx อย่างรวดเร็ว และรอคิวสิ่งที่หนักกว่าหลัง 2xx เพื่อไม่ให้การจัดส่งหมดเวลา

TypeScript (Express)
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");
});
Python (Flask)
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)
ขั้นตอนที่ 4 จาก 5

ตั้งค่าการควบคุมการใช้จ่ายในแดชบอร์ด

หากเอเจนต์ของคุณเพียงแค่รับ, คุณสามารถข้ามสิ่งนี้. หากมันยังจ่าย, ตั้งค่าการอนุญาตการใช้จ่าย - การอนุญาตต่อช่วงเวลาและขีดจำกัดต่อธุรกรรม - ในแดชบอร์ด. มันจะถูกบังคับใช้โดย backend ในทุกการชำระเงิน, ดังนั้นมันจึงสามารถอยู่รอดจากการฉีดคำสั่งในลักษณะที่กฎด้านเอเจนต์ไม่สามารถทำได้. ไม่มีการเรียก API หรือ SDK ที่เปลี่ยนแปลงสิทธิ์ (กุญแจของเอเจนต์เองไม่สามารถขยายขอบเขตได้); API เป็นแบบอ่านอย่างเดียว, ดังนั้นโค้ดของคุณสามารถดึงค่าปัจจุบันเพื่อแสดงหรือวางแผนรอบมัน.

อ่าน (curl)
curl https://api.blockchain0x.com/v1/agents/agt_123/spend-permissions \
  -H "Authorization: Bearer $BLOCKCHAIN0X_API_KEY"
การตอบสนอง
{
  "allowance_wei": "5000000",
  "per_tx_wei": "1000000",
  "period_seconds": 86400,
  "revoked_at": null
}
ขั้นตอนที่ 5 จาก 5

ทดสอบกระบวนการทั้งหมดบน Base Sepolia.

ก่อนที่จะเปลี่ยนไปใช้คีย์ sk_live_ ให้รันเส้นทางทั้งหมดจากต้นจนจบด้วย sk_test_ คีย์ทดสอบจะเก็บทุกอย่างไว้บน Base Sepolia ซึ่งคุณเติมเงินในกระเป๋าเงินจากก๊อกสาธารณะและรูปแบบการตอบสนองตรงกับแบบสด คีย์พรีฟิกเลือกเครือข่าย ดังนั้นคีย์ทดสอบจึงไม่สามารถย้ายเงินใน mainnet ได้

ฝึกฝนสามสถานการณ์: การชำระเงินที่ราบรื่นที่ทำให้เกิด payment.received, การจัดส่งที่พลาด (ชี้ webhook ไปที่ URL ที่ตายแล้ว, จากนั้นปรับสมดุลโดยการดึงธุรกรรมด้วย transactions.get), และการลองใหม่ของ webhook (ส่งกลับ 500 ครั้งแรก, 200 ครั้งที่สอง, และยืนยันว่าตัวจัดการของคุณเป็น idempotent). เมื่อทั้งสามผ่านการทดสอบ, เปลี่ยนกุญแจและส่ง.

ข้อผิดพลาดทั่วไป

ห้าข้อผิดพลาดที่ทำให้ทีมเสียเวลาไปหนึ่งสัปดาห์

ข้ามการตรวจสอบลายเซ็น webhook

หากคุณยอมรับ POST ใด ๆ ไปยัง /webhooks/payment เป็นอำนาจ, ผู้โจมตีสามารถสร้างเหตุการณ์การชำระเงินปลอมและหลอกล่อเอเจนต์ของคุณให้ส่งมอบงานฟรี. ตรวจสอบ HMAC เสมอด้วยความลับของ webhook, โดยใช้การเปรียบเทียบที่มีเวลาแน่นอน. การละเมิดครั้งแรกมักจะเป็นการตรวจสอบที่ขาดหายไป.

สมมติว่ามีเหตุการณ์การยืนยันแยกต่างหาก

เหตุการณ์ที่จัดส่งคือ payment.received, payment.sent, wallet.deployed และ webhook.test - ไม่มีเหตุการณ์ยืนยันแยกต่างหาก payment.received จะเกิดขึ้นเมื่อการโอนอยู่ในบล็อก สำหรับงานส่วนใหญ่ นั่นคือสัญญาณของคุณในการส่งมอบ สำหรับสิ่งที่มีค่าใช้จ่ายสูงหรือไม่สามารถย้อนกลับได้ ให้ตรวจสอบธุรกรรมด้วย transactions.get และใช้เกณฑ์การยืนยันของคุณเองก่อนที่จะดำเนินการ; อย่ารอเหตุการณ์ที่ไม่มีอยู่.

ไม่มี idempotency บนตัวจัดการ webhook

Webhooks จะลองใหม่ในกรณีที่ไม่ใช่การตอบสนอง 2xx และเหตุการณ์เดียวกันจะมาถึงหลายครั้งภายใต้ภาระงาน Handler ของคุณต้องเป็นอิดempotent: เก็บตารางเล็ก ๆ ของ ID เหตุการณ์ที่คุณได้ประมวลผลแล้วและข้ามรายการที่ซ้ำกัน มิฉะนั้น การกระพริบชั่วคราวจะส่งมอบงานเดียวกันสองครั้งและคุณจะใช้เวลาหลายชั่วโมงในการดีบักการทำงานซ้ำ

การผสมผสานคีย์ API ทดสอบและใช้งานจริง

คีย์ทดสอบ (sk_test_) จะเข้าถึง sandbox และใช้ Base Sepolia; คีย์สด (sk_live_) จะเข้าถึงการผลิตและใช้ Base mainnet การผสมผสานในการกำหนดค่าของสภาพแวดล้อมเป็นสาเหตุของตั๋ว 'ทำงานใน dev, ล้มเหลวใน prod' ส่วนใหญ่ การล้มเหลวอย่างรุนแรงในระหว่างการเริ่มต้นหากสภาพแวดล้อมการทำงานและคีย์พรีฟิกไม่ตรงกัน

ถือว่าการขาด webhook เป็นการชำระเงินที่ล้มเหลว

ไม่มีเหตุการณ์ล้มเหลว และ webhook อาจพลาด (จุดสิ้นสุดของคุณล่ม การจัดส่งถูกทิ้ง). อย่าปล่อยให้ตัวแทนติดอยู่ในลูป 'รอเงิน'. ปรับยอด: ดึงธุรกรรมด้วย transactions.get เพื่อเรียนรู้สถานะจริง และกำหนดเวลาออกสำหรับการรอใดๆ เพื่อให้การชำระเงินที่ถูกทอดทิ้งปล่อยทรัพยากรที่ถูกถือไว้แทนที่จะหยุดนิ่งตลอดไป.

ขั้นตอนถัดไป

เมื่อคุณมีการชำระเงินครั้งแรก

เมื่อการชำระเงินพื้นฐานทำงานได้ การติดตามที่ให้ผลตอบแทนมากที่สุดคือการควบคุมการใช้จ่าย (เพื่อให้ตัวแทนไม่สามารถหนีไปกับงบประมาณ) ความแข็งแกร่งของ webhook (เพื่อให้การชำระเงินไม่ถูกละทิ้งโดยเงียบ ๆ ภายใต้ภาระงาน) และการตรวจสอบตัวตน (เพื่อให้คู่ค้าเชื่อมั่นในหน้าสาธารณะของตัวแทน)

เอกสารอ้างอิง API เต็มรูปแบบอยู่ที่ docs.blockchain0x.com. พื้นผิวผลิตภัณฑ์สำหรับ API เดียวกัน: Payment API.

ตรวจสอบล่าสุด: 2026-05-15. เผยแพร่ภายใต้ CC BY 4.0.

หนึ่ง POST และเอเจนต์ของคุณกำลังได้รับเงิน

เริ่มต้นฟรี รวมคีย์ทดสอบ การชำระเงินครั้งแรกยืนยันภายในสิบ นาที