Ga naar hoofdinhoud
LerenGidsenMonetiseer je MCP-server
GIDS

Monetiseer je MCP-server in 10 minuten.

10 minuten
KORTE ANTWOORD

Installeer @blockchain0x/mcp, en roep binnen een premium tool requirePayment aan wanneer de beller niet heeft betaald - het genereert een x402 402-uitdaging met een gehoste checkout-URL, die je retourneert. Zodra de payment.received webhook de afwikkeling bevestigt, markeer je de beller als betaald in je eigen opslag en draait de tool. Gratis tools blijven gratis. Voor een gewone HTTP-server doet de ontvangzijde x402-adapter hetzelfde werk.

VOORWAARDEN

Voordat je begint.

  • Een werkende MCP-server die de officiële Model Context Protocol SDK in Node of Python gebruikt. Als je er nog geen hebt, scaffold er dan eerst een met de upstream-sjabloon.
  • Een Blockchain0x-account en een agentprofiel (zie de add-payments-to-agent guide voor de 5-minuten setup).
  • Een API-sleutel (gebruik sk_test_ voor deze gids).
  • Een kleine opslag om te onthouden wie heeft betaald (een database rij of een Redis sleutel) - jouw code bezit dit, bijgewerkt door de betalingswebhook.
  • Een duidelijk gevoel van welke tools u wilt laten betalen en de prijs per oproep. Zie de betaalde MCP-toolglossaire-invoer voor ontwerppatronen.
STAP 1 VAN 4

Installeer het pakket.

@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.

Installeer
# 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
STAP 2 VAN 4

Beperk een tool met 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-tool (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) }] };
  },
);
Eenvoudige HTTP-server (ontvangzijde 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 }));

Het 402-lichaam requirePayment retourneert naar een niet-betaalde oproeper:

// 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"
}
STAP 3 VAN 4

Bevestig betaling en onthoud wie heeft betaald.

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

Hoe lang een betaling toegang verleent is jouw beslissing - een enkele oproep, een sessie, een uur. Stel een vervaldatum in op de betaalde-toestand sleutel die overeenkomt met hoe je de tool prijst. Lang genoeg zodat een normale sessie één betaling hergebruikt, kort genoeg zodat misbruik beperkt blijft.

STAP 4 VAN 4

Implementeren en verifiëren.

Verzend de server. Gratis tools moeten nog steeds onmiddellijk hun resultaat teruggeven; afgeschermde tools moeten het 402-lichaam retourneren bij de eerste oproep van een nieuwe klant, en vervolgens draaien zodra die oproeper als betaald is gemarkeerd. Verifieer beide paden op een sk_test_ sleutel tegen Base Sepolia voordat je live gaat.

Twee signalen om op de eerste dag op te letten: het aantal 402's dat is teruggegeven (je top-of-funnel) en het aantal succesvolle toolruns na een 402 (je conversie). Als de conversie veel lager is dan verwacht, is de prijs waarschijnlijk verkeerd. Let ook op de hitrate van je betaalde-statusopslag - als deze dicht bij nul is, is je toegangvenster te kort en worden betalende oproepers gevraagd om opnieuw te betalen.

GEMEENSCHAPPELIJKE VALKUILEN

Vijf dingen die eerste MCP-monetizers pijn doen.

Per ongeluk de gratis tools beperken

Het is verleidelijk om elke tool 'voor de zekerheid' te beperken. Doe dat niet. De hele waarde van betaalde MCP-servers is dat gratis tools naast betaalde tools op dezelfde server bestaan, zodat de client de gratis ontdekking- en metadata-tools kan gebruiken zonder te betalen. Genereer een 402 alleen voor de tools die daadwerkelijk premium bronnen verbruiken; laat de rest als gewone resultaten.

requirePayment is een bouwer, geen middleware

requirePayment is een pure functie: je roept het aan wanneer een tool niet betaald is, het retourneert { status: 402, body }, en je geeft het lichaam terug. Het omhult je handler niet en het houdt niet bij wie heeft betaald. Het neemt amountUsdc, payTo, hostedUrl, en een optioneel netwerk en beschrijving - niets anders. Of een beller heeft betaald is een controle die je uitvoert tegen je eigen winkel.

Er is geen verzonden ontvangstcache

Blockchain0x levert de 402-builder en de afreken-webhook, geen ontvangstbewijshulp. U beslist waar 'deze beller heeft betaald' zich bevindt - een database rij, een Redis-sleutel, een in-geheugen kaart voor een enkel proces - en u draait het om wanneer de payment.received webhook arriveert. Dat houdt het beleid (hoe lang een betaling toegang verleent) volledig in uw handen.

Vertrouwen op een ontvangstbewijs dat de klant beweert te hebben

Laat de beller niet beweren dat hij heeft betaald. De bron van waarheid is de payment.received webhook, geverifieerd met webhooks.verify (of de gedocumenteerde HMAC) tegen je webhook-geheim. Markeer de betaler als betaald alleen na een geverifieerd evenement, en beperk de tool op die server-side status - nooit op iets dat de client verzendt.

Geen statistieken over de latentie van betaalde tools

Het plaatsen van een betalingsstap tussen de client en de uitvoering van de tool voegt de tijd toe die de aanroeper nodig heeft om te betalen en af te handelen bij de eerste aanroep, daarna bijna nul zodra je ze als betaald hebt gemarkeerd. Instrumenteer beide takken zodat je kunt onderscheiden 'tool is traag' van 'betaling is traag' wanneer een klant klaagt. Zonder de metriek zul je de bottleneck verkeerd diagnosticeren.

VOLGENDE STAPPEN

Zodra betaalde verkeer stroomt.

Met monetisatie op zijn plaats, zijn de meest nuttige vervolgacties betrouwbare webhook-afhandeling (zodat je geen betalingsgebeurtenissen mist), uitgavencontroles (zodat een MCP-server die je bouwt die ook andere agents betaalt binnen de grenzen blijft), en een testnet-eerst flow (zodat je prijswijzigingen kunt verzenden zonder echt geld te verbranden).

Volledige API-referentie op docs.blockchain0x.com. Gerelateerde productoppervlak: MCP-integratie.

Laatst beoordeeld: 2026-05-15. Gepubliceerd onder CC BY 4.0.

Vraag per toolaanroep.

Retourneer 402, stel je prijs in, accepteer USDC. Gratis om te beginnen.