สร้างรายได้จากเซิร์ฟเวอร์ MCP ของคุณใน 10 นาที
ติดตั้ง @blockchain0x/mcp, และภายในเครื่องมือพรีเมียมให้เรียก requirePayment เมื่อผู้เรียกยังไม่ได้ชำระเงิน - มันจะสร้างความท้าทาย x402 402 พร้อม URL การชำระเงินที่โฮสต์, ซึ่งคุณส่งกลับ. เมื่อ webhook payment.received ยืนยันการชำระเงิน, คุณจะทำเครื่องหมายว่าผู้เรียกได้ชำระเงินในร้านของคุณเองและเครื่องมือทำงาน. เครื่องมือฟรียังคงฟรี. สำหรับเซิร์ฟเวอร์ HTTP ธรรมดา, ตัวเชื่อม x402 ด้านการรับทำงานเช่นเดียวกัน.
ก่อนที่คุณจะเริ่ม.
- เซิร์ฟเวอร์ MCP ที่ใช้งานได้โดยใช้ SDK Model Context Protocol อย่างเป็นทางการใน Node หรือ Python หากคุณยังไม่มี ให้สร้างโครงสร้างด้วยเทมเพลตต้นน้ำก่อน
- บัญชี Blockchain0x และโปรไฟล์เอเจนต์ (ดูที่ add-payments-to-agent guide สำหรับการตั้งค่า 5 นาที)
- คีย์ API (ใช้
sk_test_สำหรับคู่มือนี้) - ร้านขนาดเล็กเพื่อจดจำว่าผู้ใดได้ชำระเงิน (แถวฐานข้อมูลหรือคีย์ Redis) - โค้ดของคุณเป็นเจ้าของสิ่งนี้ อัปเดตโดย webhook การชำระเงิน.
- ความชัดเจนเกี่ยวกับเครื่องมือที่คุณต้องการเรียกเก็บเงินและราคาแต่ละการเรียกดู ดูที่ รายการพจนานุกรมเครื่องมือ MCP ที่ต้องชำระเงิน สำหรับรูปแบบการออกแบบ.
ติดตั้งแพ็คเกจ
@blockchain0x/mcp exports requirePayment, a pure function that mints an x402 402 challenge for a tool. It is npm (TypeScript) only. If you run a plain HTTP server instead of an MCP one, install the receive-side x402 adapter and gate routes with it.
# Gate your own MCP tools with the requirePayment 402 builder:
npm install @blockchain0x/mcp
# Or gate a plain HTTP server with the receive-side x402 adapter + SDK:
npm install @blockchain0x/x402 @blockchain0x/nodeกำหนดเครื่องมือด้วย requirePayment
Inside the tool, check your own paid-state for the caller. If they have not paid, call requirePayment and return the resulting 402 body; if they have, run the work. requirePayment is a pure builder - it does not wrap the handler and does not track payment, so the gating policy stays in your code.
import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
import { requirePayment } from "@blockchain0x/mcp";
import { z } from "zod";
const server = new McpServer({ name: "premium-data-mcp", version: "1.0.0" });
server.tool(
"get_quote_realtime",
"Real-time quote (paid)",
{ ticker: z.string() },
async ({ ticker }, extra) => {
if (!hasPaid(extra)) {
// Pure function: mint an x402 402 challenge and hand the body back.
const { body } = requirePayment({
amountUsdc: "0.005",
payTo: "0xYourWallet",
hostedUrl: "https://pay.blockchain0x.com/checkout/abc",
});
return { content: [{ type: "text", text: JSON.stringify(body) }], isError: true };
}
const quote = await fetchLiveQuote(ticker);
return { content: [{ type: "text", text: JSON.stringify(quote) }] };
},
);import express from "express";
import { createX402Middleware } from "@blockchain0x/x402/server/express";
import { createClient } from "@blockchain0x/node";
const sdk = createClient({ apiKey: process.env.BLOCKCHAIN0X_API_KEY! });
const app = express();
// Not an MCP server? Gate a plain HTTP route the same way. The middleware
// answers unpaid requests with a 402 and lets paid ones through.
// Configure the price and recipient per the x402 docs.
app.use("/quote", createX402Middleware({ sdk }));ร่าง 402 requirePayment ส่งคืนให้กับผู้โทรที่ยังไม่ได้ชำระเงิน:
// requirePayment returns { status: 402, body }. The body an unpaid caller sees:
{
"error": "payment_required",
"amountUsdc": "0.005",
"payTo": "0xYourWallet",
"hostedUrl": "https://pay.blockchain0x.com/checkout/abc",
"network": "mainnet"
}ยืนยันการชำระเงิน จากนั้นจดจำว่าผู้ใดได้ชำระเงิน.
When a caller pays the checkout, Blockchain0x POSTs a signed payment.received event to your webhook. Verify it with webhooks.verify from @blockchain0x/node, then write the paid state to a store you control - a database row, a Redis key, your call. That store is what the tool checks in Step 2. There is no shipped receipt cache; you own where paid-state lives and how long it lasts.
import express from "express";
import { webhooks } from "@blockchain0x/node";
const app = express();
app.use(express.raw({ type: "application/json" }));
app.post("/webhooks/payment", (req, res) => {
const result = webhooks.verify({
headers: req.headers,
rawBody: req.body, // RAW bytes
secret: process.env.BLOCKCHAIN0X_WEBHOOK_SECRET!,
});
if (!result.ok) return res.status(400).json({ code: result.code });
if (result.eventType === "payment.received") {
// Remember the payer however you like - a DB row, a Redis key, your call.
markPaid(result.eventId);
}
res.status(200).send("ok");
});ระยะเวลาที่การชำระเงินให้การเข้าถึงเป็นการตัดสินใจของคุณ - การเรียกครั้งเดียว, เซสชัน, หนึ่งชั่วโมง. ตั้งเวลาหมดอายุบนคีย์สถานะการชำระเงินที่ตรงกับวิธีที่คุณตั้งราคาเครื่องมือ. ยาวพอที่เซสชันปกติจะใช้การชำระเงินหนึ่งครั้ง, สั้นพอที่การละเมิดจะถูกจำกัด.
ปรับใช้และตรวจสอบ.
ส่งเซิร์ฟเวอร์ เครื่องมือฟรีควรส่งผลลัพธ์ทันที เครื่องมือที่มีการจำกัดควรส่งคืนร่าง 402 ในการเรียกครั้งแรกจากลูกค้าใหม่ จากนั้นทำงานเมื่อผู้โทรนั้นถูกทำเครื่องหมายว่าได้รับเงินแล้ว ตรวจสอบทั้งสองเส้นทางบนกุญแจ sk_test_ กับ Base Sepolia ก่อนที่จะเปิดใช้งาน
สัญญาณสองอย่างที่ควรสังเกตในวันแรก: จำนวน 402 ที่ส่งกลับ (ยอดฟunnel ของคุณ) และจำนวนการเรียกใช้เครื่องมือที่ประสบความสำเร็จหลังจาก 402 (การแปลงของคุณ) หากการแปลงต่ำกว่าที่คาดไว้มาก ราคาน่าจะผิด Watch อัตราการเข้าถึงของร้านค้าสถานะที่ชำระเงินของคุณด้วย - หากใกล้ศูนย์ ช่องทางการเข้าถึงของคุณสั้นเกินไปและผู้โทรที่ชำระเงินถูกขอให้ชำระเงินอีกครั้ง
ห้าสิ่งที่ทำให้ผู้สร้างรายได้ MCP ครั้งแรกเจ็บ
กำหนดเครื่องมือฟรีโดยบังเอิญ
มันดึงดูดใจที่จะจำกัดเครื่องมือทุกอย่าง 'เผื่อไว้' อย่าทำเช่นนั้น มูลค่าทั้งหมดของเซิร์ฟเวอร์ MCP ที่ต้องชำระเงินคือเครื่องมือฟรีอยู่ร่วมกับเครื่องมือที่ต้องชำระเงินบนเซิร์ฟเวอร์เดียวกัน ดังนั้นลูกค้าสามารถใช้เครื่องมือการค้นพบและข้อมูลเมตาฟรีโดยไม่ต้องชำระเงิน สร้าง 402 เฉพาะสำหรับเครื่องมือที่ใช้ทรัพยากรพรีเมียมจริงๆ; ทิ้งที่เหลือไว้เป็นผลลัพธ์ธรรมดา
requirePayment เป็นผู้สร้าง ไม่ใช่ middleware
requirePayment เป็นฟังก์ชันที่บริสุทธิ์: คุณเรียกมันเมื่อเครื่องมือไม่ได้ชำระเงิน มันจะส่งกลับ { status: 402, body } และคุณส่งคืน body นั้น มันไม่ห่อหุ้มตัวจัดการของคุณและไม่ติดตามว่าใครจ่าย มันใช้ amountUsdc, payTo, hostedUrl และเครือข่ายและคำอธิบายที่เลือกได้ - ไม่มีอย่างอื่น การตรวจสอบว่าผู้โทรได้ชำระเงินหรือไม่เป็นการตรวจสอบที่คุณทำกับร้านค้าของคุณเอง.
ไม่มีแคชใบเสร็จที่จัดส่ง
Blockchain0x ส่งตัวสร้าง 402 และ webhook การตั้งถิ่นฐาน ไม่ใช่ตัวช่วยในการเก็บใบเสร็จ คุณตัดสินใจว่า 'ผู้โทรนี้ได้ชำระเงิน' อยู่ที่ไหน - แถวในฐานข้อมูล คีย์ Redis แผนที่ในหน่วยความจำสำหรับกระบวนการเดียว - และคุณพลิกมันเมื่อ webhook payment.received มาถึง นั่นทำให้คุณควบคุมนโยบาย (ระยะเวลาที่การชำระเงินให้สิทธิ์การเข้าถึง) ได้อย่างเต็มที่.
เชื่อถือใบเสร็จที่ลูกค้าอ้างว่ามี
อย่าให้ผู้โทรอ้างว่าชำระเงินแล้ว แหล่งข้อมูลที่ถูกต้องคือ webhook payment.received ซึ่งตรวจสอบโดย webhooks.verify (หรือ HMAC ที่บันทึกไว้) กับความลับของ webhook ของคุณ ทำเครื่องหมายผู้จ่ายว่าได้ชำระเงินแล้วเฉพาะหลังจากเหตุการณ์ที่ได้รับการตรวจสอบ และควบคุมเครื่องมือในสถานะเซิร์ฟเวอร์ด้านนั้น - ไม่เคยบนสิ่งที่ไคลเอนต์ส่ง.
ไม่มีเมตริกเกี่ยวกับความล่าช้าของเครื่องมือที่ชำระเงิน
การใส่ขั้นตอนการชำระเงินระหว่างลูกค้าและการดำเนินการเครื่องมือเพิ่มเวลาที่ผู้โทรใช้ในการชำระเงินและชำระเงินในครั้งแรก จากนั้นจะใกล้เคียงกับศูนย์เมื่อคุณทำเครื่องหมายว่าชำระเงินแล้ว อุปกรณ์ทั้งสองสาขาเพื่อให้คุณสามารถบอกได้ว่า 'เครื่องมือช้า' จาก 'การชำระเงินช้า' เมื่อมีลูกค้าบ่น โดยไม่มีเมตริกคุณจะวินิจฉัยข้อขัดข้องผิด.
เมื่อการจราจรที่ชำระเงินเริ่มไหล
เมื่อมีการสร้างรายได้ การติดตามที่มีประโยชน์ที่สุดคือการจัดการ webhook ที่เชื่อถือได้ (เพื่อให้คุณไม่พลาดเหตุการณ์การชำระเงิน) การควบคุมการใช้จ่าย (เพื่อให้เซิร์ฟเวอร์ MCP ที่คุณสร้างซึ่งจ่ายให้กับตัวแทนอื่น ๆ ยังคงมีขอบเขต) และการไหลของ testnet-first (เพื่อให้คุณสามารถส่งการเปลี่ยนแปลงราคาโดยไม่ต้องใช้เงินจริง)
รูปแบบ webhook ที่นักพัฒนาถามบ่อยที่สุด
ตั้งค่าการควบคุมการใช้จ่ายของเอเจนต์ที่สามารถอยู่รอดจากการฉีดคำสั่ง
ทดสอบการชำระเงินของตัวแทนโดยไม่ใช้เงินจริง
เอกสารอ้างอิง API เต็มรูปแบบที่ docs.blockchain0x.com. พื้นผิวผลิตภัณฑ์ที่เกี่ยวข้อง: MCP integration.