10 ਮਿੰਟਾਂ ਵਿੱਚ ਆਪਣੇ MCP ਸਰਵਰ ਨੂੰ ਮੋਨੇਟਾਈਜ਼ ਕਰੋ।
Install @blockchain0x/mcp, ਅਤੇ ਇੱਕ ਪ੍ਰੀਮੀਅਮ ਟੂਲ ਦੇ ਅੰਦਰ requirePayment ਕਾਲ ਕਰੋ ਜਦੋਂ ਕਾਲ ਕਰਨ ਵਾਲੇ ਨੇ ਭੁਗਤਾਨ ਨਹੀਂ ਕੀਤਾ - ਇਹ ਇੱਕ ਹੋਸਟ ਕੀਤੀ ਚੈਕਆਉਟ URL ਨਾਲ ਇੱਕ x402 402 ਚੈਲੰਜ ਬਣਾਉਂਦਾ ਹੈ, ਜਿਸਨੂੰ ਤੁਸੀਂ ਵਾਪਸ ਕਰਦੇ ਹੋ। ਜਦੋਂ ਭੁਗਤਾਨ.received webhook ਨਿਪਟਾਰਾ ਦੀ ਪੁਸ਼ਟੀ ਕਰਦਾ ਹੈ, ਤਾਂ ਤੁਸੀਂ ਆਪਣੇ ਆਪਣੇ ਸਟੋਰ ਵਿੱਚ ਕਾਲ ਕਰਨ ਵਾਲੇ ਨੂੰ ਭੁਗਤਾਨ ਕੀਤਾ ਹੋਇਆ ਦਰਜ ਕਰਦੇ ਹੋ ਅਤੇ ਟੂਲ ਚੱਲਦਾ ਹੈ। ਮੁਫਤ ਟੂਲ ਮੁਫਤ ਰਹਿੰਦੇ ਹਨ। ਇੱਕ ਸਧਾਰਨ HTTP ਸਰਵਰ ਲਈ, ਪ੍ਰਾਪਤ-ਪਾਸੇ ਦਾ x402 ਐਡਾਪਟਰ ਉਹੀ ਕੰਮ ਕਰਦਾ ਹੈ।
ਤੁਸੀਂ ਸ਼ੁਰੂ ਕਰਨ ਤੋਂ ਪਹਿਲਾਂ।
- ਇੱਕ ਕੰਮ ਕਰਨ ਵਾਲਾ MCP ਸਰਵਰ ਜੋ Node ਜਾਂ Python ਵਿੱਚ ਸਰਕਾਰੀ Model Context Protocol SDK ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ। ਜੇਕਰ ਤੁਹਾਡੇ ਕੋਲ ਇੱਕ ਨਹੀਂ ਹੈ, ਤਾਂ ਪਹਿਲਾਂ ਉੱਪਰਲੇ ਟੈਂਪਲੇਟ ਨਾਲ ਇੱਕ ਬਣਾਓ।
- ਇੱਕ Blockchain0x ਖਾਤਾ ਅਤੇ ਇੱਕ ਏਜੰਟ ਪ੍ਰੋਫਾਈਲ (5 ਮਿੰਟ ਸੈੱਟਅਪ ਲਈ add-payments-to-agent guide ਵੇਖੋ)।
- ਇੱਕ 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/noderequirePayment ਨਾਲ ਇੱਕ ਟੂਲ ਨੂੰ ਗੇਟ ਕਰੋ।
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 body ਜੋ requirePayment unpaid caller ਨੂੰ return ਕਰਦਾ ਹੈ:
// 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 ਬਾਡੀ ਵਾਪਸ ਕਰਨੀ ਚਾਹੀਦੀ ਹੈ ਜੋ ਇੱਕ ਨਵੇਂ ਗਾਹਕ ਤੋਂ ਹੈ, ਫਿਰ ਚਲਾਉਣਾ ਜਦੋਂ ਉਹ ਕਾਲਰ ਭੁਗਤਾਨ ਕੀਤਾ ਗਿਆ ਹੈ। ਜੀਵੰਤ ਜਾਣ ਤੋਂ ਪਹਿਲਾਂ Base Sepolia 'ਤੇ sk_test_ ਕੁੰਜੀ 'ਤੇ ਦੋਹਾਂ ਪਾਥਾਂ ਦੀ ਪੁਸ਼ਟੀ ਕਰੋ।
ਪਹਿਲੇ ਦਿਨ ਦੇਖਣ ਲਈ ਦੋ ਸੰਕੇਤ: ਵਾਪਸ ਕੀਤੇ ਗਏ 402 ਦੀ ਗਿਣਤੀ (ਤੁਹਾਡਾ ਟਾਪ-ਆਫ-ਫਨਲ) ਅਤੇ 402 ਦੇ ਬਾਅਦ ਸਫਲ ਟੂਲ ਚਲਾਉਣ ਦੀ ਗਿਣਤੀ (ਤੁਹਾਡਾ ਬਦਲਾਅ)। ਜੇ ਬਦਲਾਅ ਉਮੀਦ ਤੋਂ ਕਾਫੀ ਘੱਟ ਹੈ, ਤਾਂ ਕੀਮਤ ਸ਼ਾਇਦ ਗਲਤ ਹੈ। ਆਪਣੇ ਭੁਗਤਾਨ-ਰਾਜ ਸਟੋਰ ਦੀ ਹਿੱਟ ਦਰ ਨੂੰ ਵੀ ਦੇਖੋ - ਜੇ ਇਹ ਜ਼ੀਰੋ ਦੇ ਨੇੜੇ ਹੈ, ਤਾਂ ਤੁਹਾਡਾ ਪਹੁੰਚ ਵਿੰਡੋ ਬਹੁਤ ਛੋਟਾ ਹੈ ਅਤੇ ਭੁਗਤਾਨ ਕਰਨ ਵਾਲੇ ਕਾਲਰਾਂ ਨੂੰ ਦੁਬਾਰਾ ਭੁਗਤਾਨ ਕਰਨ ਲਈ ਕਿਹਾ ਜਾ ਰਿਹਾ ਹੈ।
ਪੰਜ ਚੀਜ਼ਾਂ ਜੋ ਪਹਿਲੀ ਵਾਰੀ MCP ਮੋਨਟਾਈਜ਼ਰਾਂ ਨੂੰ ਸਮੱਸਿਆ ਪੈਦਾ ਕਰਦੀਆਂ ਹਨ।
ਗੈਟਿੰਗ ਮੁਫ਼ਤ ਟੂਲਾਂ ਨੂੰ ਅਚਾਨਕ
ਹਰ ਟੂਲ ਨੂੰ 'ਕੇਵਲ ਕਿਸੇ ਵੀ ਹਾਲਤ ਵਿੱਚ' ਗੇਟ ਕਰਨ ਦਾ ਲੁਭਾਉਣਾ ਹੈ। ਨਾ ਕਰੋ। ਭੁਗਤਾਨ ਕੀਤੇ MCP ਸਰਵਰਾਂ ਦੀ ਪੂਰੀ ਕੀਮਤ ਇਹ ਹੈ ਕਿ ਮੁਫਤ ਟੂਲ ਭੁਗਤਾਨ ਕੀਤੇ ਟੂਲਾਂ ਦੇ ਨਾਲ ਇੱਕੋ ਸਰਵਰ 'ਤੇ ਮੌਜੂਦ ਹਨ, ਇਸ ਲਈ ਕਲਾਇੰਟ ਮੁਫਤ ਖੋਜ ਅਤੇ ਮੈਟਾਡੇਟਾ ਟੂਲਾਂ ਨੂੰ ਭੁਗਤਾਨ ਕੀਤੇ ਬਿਨਾਂ ਵਰਤ ਸਕਦਾ ਹੈ। ਸਿਰਫ ਉਹਨਾਂ ਟੂਲਾਂ ਲਈ 402 ਬਣਾਓ ਜੋ ਵਾਸਤਵ ਵਿੱਚ ਪ੍ਰੀਮੀਅਮ ਸਰੋਤਾਂ ਦੀ ਖਪਤ ਕਰਦੇ ਹਨ; ਬਾਕੀ ਨੂੰ ਸਧਾਰਨ ਨਤੀਜਿਆਂ ਵਜੋਂ ਛੱਡ ਦਿਓ।
requirePayment ਇੱਕ ਬਿਲਡਰ ਹੈ, ਮਿਡਲਵੇਅਰ ਨਹੀਂ
requirePayment ਇੱਕ ਸ਼ੁੱਧ ਫੰਕਸ਼ਨ ਹੈ: ਤੁਸੀਂ ਇਸਨੂੰ ਉਸ ਵੇਲੇ ਕਾਲ ਕਰਦੇ ਹੋ ਜਦੋਂ ਇੱਕ ਸੰਦ ਅਣਭੁਗਤਾਨ ਹੁੰਦਾ ਹੈ, ਇਹ { status: 402, body } ਵਾਪਸ ਕਰਦਾ ਹੈ, ਅਤੇ ਤੁਸੀਂ ਉਸ ਸਰੀਰ ਨੂੰ ਵਾਪਸ ਕਰਦੇ ਹੋ। ਇਹ ਤੁਹਾਡੇ ਹੈਂਡਲਰ ਨੂੰ ਲਪੇਟਦਾ ਨਹੀਂ ਹੈ ਅਤੇ ਇਹ ਨਹੀਂ ਟ੍ਰੈਕ ਕਰਦਾ ਕਿ ਕਿਸਨੇ ਭੁਗਤਾਨ ਕੀਤਾ। ਇਹ amountUsdc, payTo, hostedUrl, ਅਤੇ ਇੱਕ ਵਿਕਲਪੀ ਨੈੱਟਵਰਕ ਅਤੇ ਵੇਰਵਾ ਲੈਂਦਾ ਹੈ - ਹੋਰ ਕੁਝ ਨਹੀਂ। ਕਿਸੇ ਕਾਲਰ ਨੇ ਭੁਗਤਾਨ ਕੀਤਾ ਹੈ ਜਾਂ ਨਹੀਂ, ਇਹ ਇੱਕ ਜਾਂਚ ਹੈ ਜੋ ਤੁਸੀਂ ਆਪਣੇ ਸਟੋਰ ਦੇ ਖਿਲਾਫ ਚਲਾਉਂਦੇ ਹੋ।
ਕੋਈ ਭੇਜਿਆ ਗਿਆ ਰਸੀਦ ਕੈਸ਼ ਨਹੀਂ ਹੈ
Blockchain0x 402 ਬਿਲਡਰ ਅਤੇ ਸੈਟਲਮੈਂਟ ਵੈਬਹੂਕ ਨੂੰ ਭੇਜਦਾ ਹੈ, ਨਾ ਕਿ ਇੱਕ ਰਸੀਦ-ਸਟੋਰ ਸਹਾਇਕ। ਤੁਸੀਂ ਇਹ ਫੈਸਲਾ ਕਰਦੇ ਹੋ ਕਿ 'ਇਹ ਕਾਲ ਕਰਨ ਵਾਲਾ ਭੁਗਤਾਨ ਕੀਤਾ' ਕਿੱਥੇ ਹੈ - ਇੱਕ ਡੇਟਾਬੇਸ ਪੰਗਤੀ, ਇੱਕ Redis ਕੁੰਜੀ, ਇੱਕ ਇਕੱਲੇ ਪ੍ਰਕਿਰਿਆ ਲਈ ਮੈਮੋਰੀ ਨਕਸ਼ਾ - ਅਤੇ ਤੁਸੀਂ ਇਸਨੂੰ ਉਸ ਵੇਲੇ ਪਲਟਦੇ ਹੋ ਜਦੋਂ ਭੁਗਤਾਨ.received ਵੈਬਹੂਕ ਆਉਂਦਾ ਹੈ। ਇਹ ਨੀਤੀ (ਭੁਗਤਾਨ ਕਿੰਨਾ ਸਮਾਂ ਪਹੁੰਚ ਦਿੰਦਾ ਹੈ) ਨੂੰ ਪੂਰੀ ਤਰ੍ਹਾਂ ਤੁਹਾਡੇ ਹੱਥਾਂ ਵਿੱਚ ਰੱਖਦਾ ਹੈ।
ਉਸ ਰਸੀਦ 'ਤੇ ਭਰੋਸਾ ਕਰਨਾ ਜਿਸਦਾ ਦਾਅਵਾ ਕਲਾਇੰਟ ਕਰਦਾ ਹੈ
ਕਾਲਰ ਨੂੰ ਇਹ ਦਾਅਵਾ ਕਰਨ ਨਾ ਦਿਓ ਕਿ ਇਸਨੇ ਭੁਗਤਾਨ ਕੀਤਾ। ਸੱਚਾਈ ਦਾ ਸਰੋਤ payment.received ਵੈਬਹੂਕ ਹੈ, ਜੋ webhooks.verify (ਜਾਂ ਦਸਤਾਵੇਜ਼ਿਤ HMAC) ਨਾਲ ਤੁਹਾਡੇ ਵੈਬਹੂਕ ਸਿਕ੍ਰੇਟ ਦੇ ਖਿਲਾਫ ਪੁਸ਼ਟੀ ਕੀਤੀ ਜਾਂਦੀ ਹੈ। ਭੁਗਤਾਨ ਕਰਨ ਵਾਲੇ ਨੂੰ ਸਿਰਫ ਇੱਕ ਪੁਸ਼ਟੀ ਕੀਤੀ ਇਵੈਂਟ ਤੋਂ ਬਾਅਦ ਭੁਗਤਾਨ ਕੀਤਾ ਗਿਆ ਮਾਰਕ ਕਰੋ, ਅਤੇ ਉਸ ਸਰਵਰ-ਪਾਸੇ ਦੀ ਸਥਿਤੀ 'ਤੇ ਟੂਲ ਨੂੰ ਗੇਟ ਕਰੋ - ਕਦੇ ਵੀ ਕੁਝ ਵੀ ਜੋ ਕਲਾਇੰਟ ਭੇਜਦਾ ਹੈ 'ਤੇ ਨਹੀਂ।
ਭੁਗਤਾਨ ਕੀਤੇ ਟੂਲ ਦੀ ਦੇਰੀ 'ਤੇ ਕੋਈ ਮੈਟਰਿਕਸ ਨਹੀਂ
ਗਾਹਕ ਅਤੇ ਟੂਲ ਕਾਰਵਾਈ ਦੇ ਵਿਚਕਾਰ ਭੁਗਤਾਨ ਦੇ ਕਦਮ ਨੂੰ ਰੱਖਣਾ ਪਹਿਲੀ ਕਾਲ 'ਤੇ ਭੁਗਤਾਨ ਕਰਨ ਅਤੇ ਸੈਟਲ ਕਰਨ ਲਈ ਕਾਲਰ ਨੂੰ ਲੱਗਣ ਵਾਲਾ ਸਮਾਂ ਜੋੜਦਾ ਹੈ, ਫਿਰ ਜਦੋਂ ਤੁਸੀਂ ਉਨ੍ਹਾਂ ਨੂੰ ਭੁਗਤਾਨ ਕੀਤਾ ਮਾਰਕ ਕਰਦੇ ਹੋ ਤਾਂ ਨੇੜੇ-ਜ਼ੀਰੋ। ਦੋਹਾਂ ਸ਼ਾਖਾਵਾਂ ਨੂੰ ਸਾਜ਼ਗਾਰ ਕਰੋ ਤਾਂ ਜੋ ਤੁਸੀਂ ਗਾਹਕ ਦੀ ਸ਼ਿਕਾਇਤ 'ਤੇ 'ਟੂਲ ਦੇਰੀ' ਅਤੇ 'ਭੁਗਤਾਨ ਦੇਰੀ' ਵਿੱਚ ਅੰਤਰ ਕਰ ਸਕੋ। ਮੈਟਰਿਕ ਦੇ ਬਿਨਾਂ ਤੁਸੀਂ ਬੋਤਲਨੈਕ ਨੂੰ ਗਲਤ ਨਿਧਾਰਤ ਕਰੋਗੇ।
ਜਦੋਂ ਭੁਗਤਾਨ ਕੀਤਾ ਗਿਆ ਟ੍ਰੈਫਿਕ ਚੱਲ ਰਿਹਾ ਹੈ।
Monetization ਸਥਾਪਤ ਹੋਣ ਤੋਂ ਬਾਅਦ, ਸਭ ਤੋਂ ਫਾਇਦੇਮੰਦ follow-ups ਹਨ dependable webhook handling (ਤਾਂ ਜੋ payment events ਨਾ miss ਹੋਣ), spend controls (ਤਾਂ ਜੋ ਤੁਹਾਡਾ ਬਣਾਇਆ MCP server ਜੋ ਹੋਰ agents ਨੂੰ ਵੀ pay ਕਰਦਾ ਹੈ bounded ਰਹੇ), ਅਤੇ testnet-first flow (ਤਾਂ ਜੋ ਤੁਸੀਂ real money ਸਾੜੇ ਬਿਨਾਂ pricing changes ship ਕਰ ਸਕੋ)।
ਵੈਬਹੂਕ ਪੈਟਰਨ ਜੋ ਵਿਕਾਸਕਾਂ ਨੇ ਸਭ ਤੋਂ ਵੱਧ ਪੁੱਛੇ ਹਨ
ਏਜੰਟ ਖਰਚ ਨਿਯੰਤਰਣ ਸੈੱਟ ਕਰੋ ਜੋ ਪ੍ਰੰਪਟ ਇੰਜੈਕਸ਼ਨ ਨੂੰ ਬਚਾਉਂਦੇ ਹਨ
ਅਸਲ ਪੈਸੇ ਦੇ ਬਿਨਾਂ ਏਜੰਟ ਭੁਗਤਾਨਾਂ ਦੀ ਜਾਂਚ ਕਰੋ
ਪੂਰੀ API ਹਵਾਲਾ docs.blockchain0x.com 'ਤੇ ਹੈ। ਸੰਬੰਧਿਤ ਉਤਪਾਦ ਸਤਹ: MCP integration.