കൽപ്പന ചെയ്യുക ഗൈഡുകൾനിങ്ങളുടെ MCP സർവർ മോണിറ്റൈസ് ചെയ്യുക

ഗൈഡ്

10 മിനിറ്റിനുള്ളിൽ നിങ്ങളുടെ MCP സർവർ മോണിറ്റൈസ് ചെയ്യുക.

10 മിനിറ്റ്

ചുരുക്കം ഉത്തരം

@blockchain0x/mcp ഇൻസ്റ്റാൾ ചെയ്യുക, premium tool-നുള്ളിൽ caller പണം നൽകിയിട്ടില്ലെങ്കിൽ requirePayment വിളിക്കുക - ഇത് hosted checkout URL-ോടുകൂടി ഒരു x402 402 challenge സൃഷ്ടിക്കും, അത് നിങ്ങൾ തിരികെ നൽകുക. payment.received webhook settlement സ്ഥിരീകരിച്ച ശേഷം, നിങ്ങൾ സ്വന്തം store-ൽ caller-നെ paid ആയി അടയാളപ്പെടുത്തുകയും tool പ്രവർത്തിക്കുകയും ചെയ്യും. Free tools free തന്നെയാണ്. സാധാരണ HTTP server-ിന്, receive-side x402 adapter അതേ ജോലി ചെയ്യുന്നു.

മുൻകൂർ ആവശ്യങ്ങൾ

നിങ്ങൾ തുടങ്ങുന്നതിന് മുമ്പ്.

Node അല്ലെങ്കിൽ Python-ൽ ഔദ്യോഗിക Model Context Protocol SDK ഉപയോഗിച്ച് പ്രവർത്തിക്കുന്ന MCP സർവർ. നിങ്ങൾക്ക് ഇതുവരെ ഒന്നുമില്ലെങ്കിൽ, ആദ്യം ഉയർന്ന തലത്തിലുള്ള ടെംപ്ലേറ്റ് ഉപയോഗിച്ച് ഒരു സ്കാഫോൾഡ് ചെയ്യുക.
ഒരു Blockchain0x അക്കൗണ്ടും ഒരു ഏജന്റ് പ്രൊഫൈലും (5-മിനിറ്റ് സെറ്റപ്പിന് add-payments-to-agent guide കാണുക).
ഒരു API കീ (ഈ ഗൈഡിന് sk_test_ ഉപയോഗിക്കുക).
ആരായിരിക്കും പണമടച്ചത് ഓർമ്മിക്കാൻ ഒരു ചെറിയ സ്റ്റോർ (ഒരു ഡാറ്റാബേസ് വരി അല്ലെങ്കിൽ ഒരു Redis കീ) - നിങ്ങളുടെ കോഡ് ഇത് കൈവശമുണ്ട്, പണമടച്ച വെബ്‌ഹുക്ക് അപ്ഡേറ്റ് ചെയ്യുന്നു.
നിങ്ങൾക്ക് ചാർജ് ചെയ്യാൻ ആഗ്രഹിക്കുന്ന ഉപകരണങ്ങൾ ഏതൊക്കെയാണെന്നും ഓരോ വിളിക്കായി വില എത്രയാണെന്നും വ്യക്തമായ ധാരണ. രൂപകൽപ്പന മാതൃകകൾക്കായി പണമടച്ച MCP ഉപകരണം ഗ്ലോസറി എൻട്രി കാണുക.

ചുവടു 1 OF 4

പാക്കേജ് ഇൻസ്റ്റാൾ ചെയ്യുക.

@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

ചുവടു 2 OF 4

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.

MCP ഉപകരണം (TypeScript)

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) }] };
  },
);

സാധാരണ HTTP സെർവർ (സ്വീകരണ വശം x402)

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 }));

പണമടച്ചിട്ടില്ലാത്ത വിളിക്കാരനിലേക്ക് requirePayment തിരികെ നൽകുന്ന 402 ബോഡി:

// 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"
}

ചുവടു 3 OF 4

പണമടച്ചത് സ്ഥിരീകരിക്കുക, പിന്നീട് ആരാണ് പണമടച്ചത് എന്നത് ഓർക്കുക.

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.

Webhook handler (TypeScript)

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");
});

ഒരു പണമിടപാട് എത്ര കാലം ആക്സസ് നൽകുന്നു എന്നത് നിങ്ങളുടെ തീരുമാനമാണ് - ഒരു ഏക വിളി, ഒരു സെഷൻ, ഒരു മണിക്കൂർ. ഉപകരണത്തിന്റെ വിലയിരുത്തുന്നതിന് അനുയോജ്യമായ പെയ്ഡ്-സ്റ്റേറ്റ് കീയിൽ ഒരു കാലാവധി സജ്ജീകരിക്കുക. ഒരു സാധാരണ സെഷൻ ഒരു പണമിടപാട് വീണ്ടും ഉപയോഗിക്കുന്നതിന് മതിയാകുന്നത്ര നീണ്ടതും, ദുരുപയോഗം നിയന്ത്രിതമായതും.

ചുവടു 4 OF 4

പ്രവർത്തിപ്പിക്കുക ಮತ್ತು സ്ഥിരീകരിക്കുക.

സർവർ അയക്കുക. സൗജന്യ ഉപകരണങ്ങൾ ഇപ്പോഴും അവരുടെ ഫലങ്ങൾ ഉടൻ തിരിച്ചുകൊടുക്കണം; ഗേറ്റഡ് ഉപകരണങ്ങൾ പുതിയ ക്ലയന്റിൽ നിന്ന് ആദ്യ വിളിയിൽ 402 ബോഡി തിരികെ നൽകണം, പിന്നെ ആ വിളിക്കാരൻ പണമടച്ചതായി അടയാളപ്പെടുത്തുമ്പോൾ പ്രവർത്തിക്കുക. ലൈവ് ആകുന്നതിന് മുമ്പ് Base Sepolia യിൽ sk_test_ കീ ഉപയോഗിച്ച് രണ്ടുപാതകളും സ്ഥിരീകരിക്കുക.

ദിവസം ഒന്നിന് ശ്രദ്ധിക്കേണ്ട രണ്ട് സിഗ്നലുകൾ: തിരികെ ലഭിച്ച 402-കളുടെ എണ്ണം (നിങ്ങളുടെ ടോപ്പ്-ഓഫ്-ഫണ്ണൽ) 402-ന് ശേഷം വിജയകരമായ ഉപകരണം പ്രവർത്തനങ്ങളുടെ എണ്ണം (നിങ്ങളുടെ പരിവർത്തനം). പരിവർത്തനം പ്രതീക്ഷിച്ചതിനെക്കാൾ വളരെ കുറവാണെങ്കിൽ, വില തെറ്റായിരിക്കാം. നിങ്ങളുടെ പണമടച്ച സംസ്ഥാന സ്റ്റോറിന്റെ ഹിറ്റ് നിരക്കും ശ്രദ്ധിക്കുക - ഇത് ശൂന്യത്തിന് അടുത്താണെങ്കിൽ, നിങ്ങളുടെ ആക്സസ് വിൻഡോ വളരെ ചെറുതാണ്, പണമടച്ച വിളിക്കുകയോ വീണ്ടും പണമടക്കാൻ ആവശ്യപ്പെടുന്നു.

സാധാരണ പിഴവുകൾ

ആദ്യമായി MCP പണം സമ്പാദിക്കുന്നവരെ കടിക്കാനുള്ള അഞ്ചു കാര്യങ്ങൾ.

അപ്രതീക്ഷിതമായി സൗജന്യ ഉപകരണങ്ങൾ ഗേറ്റ് ചെയ്യുന്നത്

എല്ലാ ഉപകരണങ്ങളും 'എന്തെങ്കിലും സംഭവിച്ചാൽ' ഗേറ്റ് ചെയ്യാൻ ആകർഷകമാണ്. ചെയ്യരുത്. പണമടയ്ക്കുന്ന MCP സർവറുകളുടെ മുഴുവൻ മൂല്യം സൗജന്യ ഉപകരണങ്ങൾ പണമടയ്ക്കുന്നവയുമായി ഒരേ സർവറിൽ സഹവാസം ചെയ്യുന്നതാണ്, അതിനാൽ ക്ലയന്റ് പണമടയ്ക്കാതെ സൗജന്യ കണ്ടെത്തൽ, മെറ്റാഡാറ്റാ ഉപകരണങ്ങൾ ഉപയോഗിക്കാം. പ്രീമിയം വിഭവങ്ങൾ യാഥാർത്ഥ്യത്തിൽ ഉപയോഗിക്കുന്ന ഉപകരണങ്ങൾക്കായി മാത്രമേ 402 നിർമ്മിക്കുക; ബാക്കി സാധാരണ ഫലങ്ങളായി വിടുക.

requirePayment ഒരു builder ആണ്, middleware അല്ല

requirePayment ഒരു pure function ആണ്: ഒരു tool unpaid ആയപ്പോൾ നിങ്ങൾ ഇത് വിളിക്കുന്നു, അത് { status: 402, body } തിരികെ നൽകുന്നു, പിന്നെ നിങ്ങൾ ആ body മടക്കുന്നു. ഇത് നിങ്ങളുടെ handler-നെ wrap ചെയ്യുകയോ ആരാണ് paid എന്ന് track ചെയ്യുകയോ ചെയ്യുന്നില്ല. ഇതിന് amountUsdc, payTo, hostedUrl, കൂടാതെ optional ആയ network, description എന്നിവ മാത്രം വേണ്ടിവരും - മറ്റൊന്നുമില്ല. ഒരു caller paid ആണോ എന്നത് നിങ്ങൾ നിങ്ങളുടെ സ്വന്തം store-ൽ പരിശോധിക്കുന്ന ഒന്നാണ്.

അയച്ച റിസീറ്റ് കാഷെ ഇല്ല

Blockchain0x 402 ബിൽഡറും സെറ്റിൽമെന്റ് വെബ്‌ഹുക്ക് അയക്കുന്നു, ഒരു റിസീറ്റ്-സ്റ്റോർ സഹായിയല്ല. 'ഈ വിളിക്കാരൻ പണമിടപാട് ചെയ്തു' എവിടെ ജീവിക്കണമെന്ന് നിങ്ങൾ തീരുമാനിക്കുന്നു - ഒരു ഡാറ്റാബേസ് വരി, ഒരു Redis കീ, ഒരു ഏക പ്രോസസ്സിന് ഒരു മെമ്മറി മാപ്പ് - പണമിടപാട്.received വെബ്‌ഹുക്ക് എത്തുമ്പോൾ നിങ്ങൾ അത് മാറ്റുന്നു. ഇത് നയം (ഒരു പണമിടപാട് എത്ര നേരം പ്രവേശനം നൽകുന്നു) നിങ്ങളുടെ കൈകളിൽ മുഴുവൻ സൂക്ഷിക്കുന്നു.

ക്ലയന്റ് കൈവശമുണ്ടെന്ന് അവകാശപ്പെടുന്ന ഒരു റിസീറ്റ് വിശ്വസിക്കുന്നു

വിളിച്ചവൻ പണമടച്ചതായി അവകാശവാദം ചെയ്യാൻ അനുവദിക്കരുത്. സത്യത്തിന്റെ ഉറവിടം payment.received വെബ് ഹുക്ക് ആണ്, webhooks.verify (അല്ലെങ്കിൽ രേഖപ്പെടുത്തിയ HMAC) ഉപയോഗിച്ച് നിങ്ങളുടെ വെബ് ഹുക്ക് രഹസ്യത്തിന് എതിരെ സ്ഥിരീകരിച്ചിരിക്കുന്നു. ഒരു സ്ഥിരീകരിച്ച ഇവന്റിന് ശേഷം മാത്രമേ പണമടച്ചവനെ പണമടച്ചതായി അടയാളപ്പെടുത്തേണ്ടതുള്ളൂ, ആ ഉപകരണം ആ സർവർ-പക്ഷത്തെ സംസ്ഥാനത്തെ അടിസ്ഥാനമാക്കി ഗേറ്റ് ചെയ്യുക - ക്ലയന്റ് അയക്കുന്ന എന്തെങ്കിലും അടിസ്ഥാനമാക്കിയുള്ളതല്ല.

പണമടച്ച ഉപകരണത്തിന്റെ ലേറ്റൻസിയിൽ മെട്രിക്‌സ് ഇല്ല

ക്ലയന്റും ഉപകരണത്തിന്റെ പ്രവർത്തനവും തമ്മിൽ ഒരു പേയ്മെന്റ് ഘട്ടം ചേർക്കുന്നത് ആദ്യത്തെ വിളിയിൽ പേയ്‌മെന്റ് ചെയ്യാനും തീർപ്പാക്കാനും വിളിക്കാവുന്ന സമയത്തെ കൂട്ടിക്കുന്നു, പിന്നീട് നിങ്ങൾ അവയെ പേയ്ഡ് ആയി അടയാളപ്പെടുത്തിയാൽ അടുത്ത-zero ആകുന്നു. ഒരു ഉപഭോക്താവ് പരാതിപ്പെടുമ്പോൾ 'ഉപകരണം മന്ദഗതിയിലാണ്' എന്നതും 'പേയ്മെന്റ് മന്ദഗതിയിലാണ്' എന്നതും തിരിച്ചറിയാൻ നിങ്ങൾക്ക് രണ്ട് ശാഖകളെയും ഉപകരണം ചെയ്യണം. മെട്രിക് ഇല്ലാതെ നിങ്ങൾ ബോട്ടിൽ നെക്ക് തെറ്റിദ്ധരിപ്പിക്കും.

അടുത്ത ചുവടുകൾ

ഒരു തവണ പണമടച്ച ട്രാഫിക് ഒഴുകുമ്പോൾ.

മണിതൈസേഷൻ നിലവിലുണ്ടായാൽ, ഏറ്റവും പ്രയോജനകരമായ ഫോളോ-അപ്പുകൾ വിശ്വസനീയമായ വെബ്‌ഹുക്ക് കൈകാര്യം ചെയ്യൽ (അത് കൊണ്ട് നിങ്ങൾ പേയ്മെന്റ് ഇവന്റുകൾ നഷ്ടപ്പെടുന്നില്ല), ചെലവു നിയന്ത്രണങ്ങൾ (നിങ്ങൾ നിർമ്മിക്കുന്ന MCP സർവറിന് മറ്റ് ഏജന്റുകൾക്കും പണമടയ്ക്കുന്നത് ബൗണ്ടഡ് ആയിരിക്കണം), ടെസ്റ്റ്‌നെറ്റ്-ഫസ്റ്റ് പ്രവാഹം (നിങ്ങൾ യാഥാർത്ഥ്യ പണം കത്തിക്കാതെ വില മാറ്റങ്ങൾ അയക്കാൻ കഴിയും).

മുഴുവൻ API റഫറൻസുകൾ docs.blockchain0x.comൽ. ബന്ധപ്പെട്ട ഉൽപ്പന്ന ഉപരിതലങ്ങൾ: MCP ഇന്റഗ്രേഷൻ.

അവസാനമായി അവലോകനം ചെയ്തത്: 2026-05-15. CC BY 4.0 പ്രകാരം പ്രസിദ്ധീകരിച്ചു.

ഉപകരണ വിളിക്കലിന് ചാർജ് ചെയ്യുക.

402 തിരികെ നൽകുക, നിങ്ങളുടെ വില ക്രമീകരിക്കുക, USDC സ്വീകരിക്കുക. ആരംഭിക്കാൻ സൗജന്യമാണ്.