ಕಲಿಯಿರಿ ಮಾರ್ಗದರ್ಶನಗಳುನಿಮ್ಮ ಎಂಸಿಪಿ ಸರ್ವರ್ ಅನ್ನು ಹಣಕಾಸು ಮಾಡಿ

ಮಾರ್ಗದರ್ಶಿ

10 ನಿಮಿಷಗಳಲ್ಲಿ ನಿಮ್ಮ ಎಂಸಿಪಿ ಸರ್ವರ್ ಅನ್ನು ಹಣಕಾಸು ಮಾಡಿ.

10 ನಿಮಿಷಗಳು

ಚಿಕ್ಕ ಉತ್ತರ

Install @blockchain0x/mcp, ಮತ್ತು ಒಬ್ಬ ಕರೆ ಮಾಡುವವರು ಪಾವತಿಸದಾಗ requirePayment ಅನ್ನು ಕರೆ ಮಾಡಿ - ಇದು ಹೋಸ್ಟೆಡ್ ಚೆಕ್‌ಔಟ್ URL ಹೊಂದಿರುವ x402 402 ಸವಾಲುಗಳನ್ನು ಮಿಂಟ್ ಮಾಡುತ್ತದೆ, ನೀವು ಅದನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತೀರಿ. ಪಾವತಿ.received ವೆಬ್‌ಹುಕ್ ನಿಗಮವನ್ನು ದೃಢೀಕರಿಸಿದ ನಂತರ, ನೀವು ಕರೆ ಮಾಡುವವರಿಗೆ ನಿಮ್ಮದೇ ಅಂಗಡಿಯಲ್ಲಿ ಪಾವತಿಸಿದ ಎಂದು ಗುರುತಿಸುತ್ತೀರಿ ಮತ್ತು ಸಾಧನ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ. ಉಚಿತ ಸಾಧನಗಳು ಉಚಿತವಾಗಿಯೇ ಉಳಿಯುತ್ತವೆ. ಸರಳ HTTP ಸರ್ವರ್‌ಗಾಗಿ, ಸ್ವೀಕರಿಸುವ ಬದಿಯ x402 ಅಡಾಪ್ಟರ್ ಅದೇ ಕೆಲಸವನ್ನು ಮಾಡುತ್ತದೆ.

ಅಗತ್ಯಗಳು

ನೀವು ಪ್ರಾರಂಭಿಸುವ ಮೊದಲು.

Node ಅಥವಾ Python ನಲ್ಲಿ ಅಧಿಕೃತ Model Context Protocol SDK ಅನ್ನು ಬಳಸುವ ಕಾರ್ಯನಿರ್ವಹಣೆಯ MCP ಸರ್ವರ್. ನೀವು ಇನ್ನೂ ಒಂದಿಲ್ಲದಿದ್ದರೆ, ಮೊದಲನೆಯದಾಗಿ ಮೇಲ್ಮಟ್ಟದ ಟೆಂಪ್ಲೇಟು ಬಳಸಿ ಒಂದನ್ನು ನಿರ್ಮಿಸಿ.
ಒಂದು Blockchain0x ಖಾತೆ ಮತ್ತು ಏಜೆಂಟ್ ಪ್ರೊಫೈಲ್ (5-ನಿಮಿಷಗಳ ಸೆಟಪ್‌ಗಾಗಿ add-payments-to-agent ಮಾರ್ಗದರ್ಶನ ಅನ್ನು ನೋಡಿ).
ಒಂದು API ಕೀ (ಈ ಮಾರ್ಗದರ್ಶನಕ್ಕಾಗಿ sk_test_ ಅನ್ನು ಬಳಸಿರಿ).
ಯಾರಾದರೂ ಪಾವತಿಸಿರುವುದನ್ನು ನೆನೆಸಲು ಒಂದು ಸಣ್ಣ ಅಂಗಡಿ (ಡೇಟಾಬೇಸ್ ಸಾಲು ಅಥವಾ Redis ಕೀ) - ನಿಮ್ಮ ಕೋಡ್ ಇದನ್ನು ಹೊಂದಿದೆ, ಪಾವತಿ ವೆಬ್‌ಹುಕ್ ಮೂಲಕ ನವೀಕರಿಸಲಾಗಿದೆ.
ನೀವು ಯಾವ ಸಾಧನಗಳಿಗೆ ಶುಲ್ಕ ವಿಧಿಸಲು ಬಯಸುತ್ತೀರಿ ಮತ್ತು ಪ್ರತಿ ಕರೆಗೆ ಬೆಲೆ ಏನು ಎಂಬುದರ ಸ್ಪಷ್ಟ ಅರಿವು. ವಿನ್ಯಾಸ ಮಾದರಿಗಳಿಗೆ ಪಾವತಿಸಿದ MCP ಸಾಧನ ಶಬ್ದಕೋಶದ ನೋಟ ನೋಡಿ.

ಹಂತ 1 ನ 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 ನ 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 unpaid caller ಗೆ return ಮಾಡುವ 402 body:

// 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 ನ 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 ನ 4

ತಯಾರಿಸಿ ಮತ್ತು ಪರಿಶೀಲಿಸಿ.

ಸರ್ವರ್ ಅನ್ನು ಸಾಗಿಸಿ. ಉಚಿತ ಸಾಧನಗಳು ತಕ್ಷಣವೇ ತಮ್ಮ ಫಲಿತಾಂಶವನ್ನು ಹಿಂತಿರುಗಿಸಬೇಕು; ಗೇಟೆಡ್ ಸಾಧನಗಳು ಹೊಸ ಕ್ಲೈಂಟ್‌ನಿಂದ ಮೊದಲ ಕರೆ ಮಾಡಿದಾಗ 402 ಶರೀರವನ್ನು ಹಿಂತಿರುಗಿಸಬೇಕು, ನಂತರ ಆ ಕರೆ ಮಾಡಿದವರು ಪಾವತಿಯಾಗಿರುವಾಗ ಓಡಬೇಕು. ಲೈವ್ ಹೋಗುವ ಮೊದಲು Base Sepolia ವಿರುದ್ಧ sk_test_ ಕೀ ಮೇಲೆ ಎರಡೂ ಮಾರ್ಗಗಳನ್ನು ಪರಿಶೀಲಿಸಿ.

ಮೊದಲ ದಿನದಲ್ಲಿ ಗಮನಿಸಲು ಎರಡು ಸಂಕೇತಗಳು: 402 ಗಳ ಸಂಖ್ಯೆಯನ್ನು ಹಿಂತಿರುಗಿಸಲಾಗಿದೆ (ನಿಮ್ಮ ಟಾಪ್-ಆಫ್-ಫನಲ್) ಮತ್ತು 402 ನಂತರ ಯಶಸ್ವಿ ಸಾಧನ ಓಟಗಳ ಸಂಖ್ಯೆಯನ್ನು (ನಿಮ್ಮ ಪರಿವರ್ತನೆ). ಪರಿವರ್ತನೆ ನಿರೀಕ್ಷಿತಕ್ಕಿಂತ ಕಡಿಮೆ ಇದ್ದರೆ, ಬೆಲೆ ತಪ್ಪಾಗಿರಬಹುದು. ನಿಮ್ಮ ಪಾವತಿತ ರಾಜ್ಯ ಅಂಗಡಿಯ ಹಿಟ್ ದರವನ್ನು ಕೂಡ ನೋಡಿ - ಇದು ಶೂನ್ಯದ ಹತ್ತಿರ ಇದ್ದರೆ, ನಿಮ್ಮ ಪ್ರವೇಶ ಕಿಟಕಿ ತುಂಬಾ ಕಡಿಮೆ ಮತ್ತು ಪಾವತಿಸುತ್ತಿರುವ ಕರೆ ಮಾಡುವವರಿಗೆ ಪುನಃ ಪಾವತಿಸಲು ಕೇಳಲಾಗುತ್ತಿದೆ.

ಸಾಮಾನ್ಯ ಬಿಕ್ಕಟ್ಟುಗಳು

ಮೊದಲ ಬಾರಿಗೆ MCP ಹಣಕಾಸು ಮಾಡುವವರಿಗೆ ಕಚ್ಚುವ ಐದು ವಿಷಯಗಳು.

ಯಾದೃಚ್ಛಿಕವಾಗಿ ಉಚಿತ ಸಾಧನಗಳನ್ನು ತಡೆಹಿಡಿಯುವುದು

ಪ್ರತಿಯೊಂದು ಸಾಧನವನ್ನು 'ಅವಶ್ಯಕತೆಗಾಗಿ' ನಿರ್ವಹಿಸಲು ಆಕರ್ಷಕವಾಗಿದೆ. ಬೇಡ. ಪಾವತಿಸಿದ MCP ಸರ್ವರ್‌ಗಳ ಸಂಪೂರ್ಣ ಮೌಲ್ಯವೆಂದರೆ ಉಚಿತ ಸಾಧನಗಳು ಒಂದೇ ಸರ್ವರ್‌ನಲ್ಲಿ ಪಾವತಿಸಿದ ಸಾಧನಗಳೊಂದಿಗೆ ಸಹವಾಸಿಸುತ್ತವೆ, ಆದ್ದರಿಂದ ಗ್ರಾಹಕ ಉಚಿತ ಅನ್ವೇಷಣೆ ಮತ್ತು ಮೆಟಾಡೇಟಾ ಸಾಧನಗಳನ್ನು ಪಾವತಿಸದೆ ಬಳಸಬಹುದು. ವಾಸ್ತವವಾಗಿ ಪ್ರೀಮಿಯಂ ಸಂಪತ್ತುಗಳನ್ನು ಬಳಸುವ ಸಾಧನಗಳಿಗೆ ಮಾತ್ರ 402 ಅನ್ನು ಮಿಂಟ್ ಮಾಡಿ; ಉಳಿದವುಗಳನ್ನು ಸರಳ ಫಲಿತಾಂಶಗಳಂತೆ ಬಿಡಿ.

requirePayment ಒಂದು ನಿರ್ಮಾಪಕ, ಮಧ್ಯಮವಿಲ್ಲ

requirePayment ಒಂದು ಶುದ್ಧ ಕಾರ್ಯವಾಗಿದೆ: ನೀವು ಒಂದು ಸಾಧನವನ್ನು ಪಾವತಿಸದಾಗ ಇದನ್ನು ಕರೆ ಮಾಡುತ್ತೀರಿ, ಇದು { status: 402, body } ಅನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ, ಮತ್ತು ನೀವು ಶರೀರವನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತೀರಿ. ಇದು ನಿಮ್ಮ ಹ್ಯಾಂಡ್ಲರ್ ಅನ್ನು ಮಡಿಸುತ್ತಿಲ್ಲ ಮತ್ತು ಯಾರಿಗೆ ಪಾವತಿಸಲಾಗಿದೆ ಎಂಬುದನ್ನು ಹಿಂಡುತ್ತಿಲ್ಲ. ಇದು amountUsdc, payTo, hostedUrl, ಮತ್ತು ಆಯ್ಕೆಯ ನೆಟ್‌ವರ್ಕ್ ಮತ್ತು ವಿವರಣೆಯನ್ನು ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ - ಇನ್ನೇನೂ ಇಲ್ಲ. ಕರೆ ಮಾಡುವುದು ಪಾವತಿಸಿದೆಯೇ ಎಂಬುದನ್ನು ನೀವು ನಿಮ್ಮದೇ ಅಂಗಡಿಗೆ ವಿರುದ್ಧವಾಗಿ ಓಡಿಸುತ್ತೀರಿ.

ಕಳುಹಿಸಲಾದ ರಶೀದಿಯ ಕ್ಯಾಶೆ ಇಲ್ಲ

Blockchain0x 402 ನಿರ್ಮಾಪಕ ಮತ್ತು ನಿಗಮ ವೆಬ್‌ಹುಕ್ ಅನ್ನು ಕಳುಹಿಸುತ್ತದೆ, ರಸೀದಿಯ ಅಂಗಸಾಧಕವಲ್ಲ. 'ಈ ಕರೆದಾರನು ಪಾವತಿಸಿದ' ಎಲ್ಲಿ ಇರುವುದೆಂದು ನೀವು ನಿರ್ಧರಿಸುತ್ತೀರಿ - ಡೇಟಾಬೇಸ್ ಸಾಲು, Redis ಕೀ, ಒಬ್ಬ ಪ್ರಕ್ರಿಯೆಗೆ ಮೆಮೊರಿ ನಕ್ಷೆ - ಮತ್ತು ಪಾವತಿ.received ವೆಬ್‌ಹುಕ್ ಬರುವಾಗ ನೀವು ಅದನ್ನು ತಿರುಗಿಸುತ್ತೀರಿ. ಇದು ನೀವೆಲ್ಲಾ ಕೈಯಲ್ಲಿರುವ ನೀತಿ (ಪಾವತಿ ಎಷ್ಟು ಕಾಲ ಪ್ರವೇಶವನ್ನು ನೀಡುತ್ತದೆ) ಅನ್ನು ಉಳಿಸುತ್ತದೆ.

ಗ್ರಾಹಕ ಹೊಂದಿರುವ ಎಂದು ಒಪ್ಪಿಸುವ ರಶೀದಿಗೆ ವಿಶ್ವಾಸವಿಡುತ್ತೇವೆ

ಕರೆದಾರನು ಪಾವತಿಸಿದ ಎಂದು ದೃಢೀಕರಿಸಲು ಅವಕಾಶ ನೀಡಬೇಡಿ. ಸತ್ಯದ ಮೂಲವು ಪಾವತಿ.received ವೆಬ್‌ಹುಕ್, webhooks.verify (ಅಥವಾ ದಾಖಲೆಗೊಳಿಸಿದ HMAC) ನೊಂದಿಗೆ ನಿಮ್ಮ ವೆಬ್‌ಹುಕ್ ರಹಸ್ಯದ ವಿರುದ್ಧ ದೃಢೀಕರಿಸಲಾಗಿದೆ. ದೃಢೀಕರಿತ ಘಟನೆ ನಂತರ ಮಾತ್ರ ಪಾವತಿದಾರನನ್ನು ಪಾವತಿಸಿದ ಎಂದು ಗುರುತಿಸಿ, ಮತ್ತು ಆ ಸರ್ವರ್-ಪಕ್ಷದ ರಾಜ್ಯದಲ್ಲಿ ಸಾಧನವನ್ನು ಗೇಟು ಮಾಡಿ - ಕ್ಲೈಂಟ್ ಕಳುಹಿಸುವುದರ ಮೇಲೆ ಎಂದಿಗೂ ಅಲ್ಲ.

ಪಾವತಿಸಿದ ಸಾಧನದ ವಿಳಂಬದ ಮೇಲೆ ಯಾವುದೇ ಮೆಟ್ರಿಕ್‌ಗಳು ಇಲ್ಲ

ಗ್ರಾಹಕ ಮತ್ತು ಸಾಧನ ಕಾರ್ಯಗತಗೊಳಿಸುವಿಕೆಯ ನಡುವಿನ ಪಾವತಿ ಹಂತವನ್ನು ಸೇರಿಸುವುದರಿಂದ ಕರೆ ಮಾಡುವವರು ಮೊದಲ ಕರೆ ಮಾಡುವಾಗ ಪಾವತಿಸಲು ಮತ್ತು ನಿಗಮಿಸಲು ತೆಗೆದುಕೊಳ್ಳುವ ಸಮಯವನ್ನು ಸೇರಿಸುತ್ತದೆ, ನಂತರ ನೀವು ಅವರನ್ನು ಪಾವತಿಸಿದಂತೆ ಗುರುತಿಸಿದಾಗ ಸಮೀಪ-ಶೂನ್ಯ. ಗ್ರಾಹಕ ತೀವ್ರವಾಗಿ ದೂರು ನೀಡಿದಾಗ 'ಸಾಧನ ನಿಧಾನವಾಗಿದೆ' ಮತ್ತು 'ಪಾವತಿ ನಿಧಾನವಾಗಿದೆ' ಎಂದು ತಿಳಿಯಲು ಎರಡೂ ಶಾಖೆಗಳನ್ನು ಸಾಧನಗೊಳಿಸಿ. ಮೆಟ್ರಿಕ್ ಇಲ್ಲದಿದ್ದರೆ ನೀವು ಬಾಟ್ಲ್ನಾಕ್ ಅನ್ನು ತಪ್ಪಾಗಿ ನಿರ್ಧರಿಸುತ್ತೀರಿ.

ಮುಂದಿನ ಹಂತಗಳು

ಒಮ್ಮೆ ಪಾವತಿಸಿದ ಟ್ರಾಫಿಕ್ ಹರಿಯುತ್ತಿದೆ.

monetization ಸಿದ್ಧವಾಗಿರುವಾಗ, ಅತ್ಯಂತ ಉಪಯುಕ್ತ ಮುಂದಿನ ಕ್ರಮಗಳು ನಂಬಲರ್ಹ webhook handling (ಹೀಗಾಗಿ payment events ತಪ್ಪಿಹೋಗದಂತೆ), spend controls (ಹೀಗಾಗಿ ನೀವು ನಿರ್ಮಿಸುವ ಮತ್ತು ಇತರ agentsಗೆ ಪಾವತಿಸುವ MCP server ಮಿತಿಯೊಳಗೆ ಇರುವುದು), ಮತ್ತು testnet-first flow (ಹೀಗಾಗಿ ನಿಜವಾದ ಹಣವನ್ನು ಖರ್ಚು ಮಾಡದೆ pricing changes ಅನ್ನು ship ಮಾಡಬಹುದು) ಆಗಿವೆ.

docs.blockchain0x.com ನಲ್ಲಿ ಸಂಪೂರ್ಣ API ಉಲ್ಲೇಖ. ಸಂಬಂಧಿತ ಉತ್ಪನ್ನ ಮೇಲ್ಮಟ್ಟ: MCP ಏಕೀಕರಣ.

ಕೊನೆಯ ವಿಮರ್ಶೆ: 2026-05-15. CC BY 4.0 ಅಡಿಯಲ್ಲಿ ಪ್ರಕಟಿಸಲಾಗಿದೆ.

ಪ್ರತಿ ಸಾಧನ ಕರೆಗೆ ಶುಲ್ಕ ವಿಧಿಸಿ.

402 ಅನ್ನು ಹಿಂತಿರುಗಿಸಿ, ನಿಮ್ಮ ಬೆಲೆಯನ್ನು ಹೊಂದಿಸಿ, USDC ಅನ್ನು ಒಪ್ಪಿಕೊಳ್ಳಿ. ಪ್ರಾರಂಭಿಸಲು ಉಚಿತ.