The problem

You built an MCP server with genuinely useful tools, and people, or agents, are using it, but you are not earning anything. The server gives its capabilities away for free, because there is no mechanism asking callers to pay. You would like to charge for the valuable tools, perhaps ones backed by expensive data or compute, but MCP itself offers no way to do it, so the server stays free and the costs of running it come out of your pocket.

This is the no-monetization problem, and it is common for anyone who has built something worth charging for on MCP. The tools are valuable, the demand is there, but the revenue is not, because the server has no payment layer. The symptom is a useful MCP server that earns nothing, and the cause is simply that monetization is not built in. The fix is to add the missing payment layer.

Why it happens

The root cause is that MCP has no built-in payment. The protocol defines how a client discovers and calls tools, but nothing about charging for them, so by default any caller can use any tool for free. That is fine for a personal or internal server, but for a server whose tools cost you to run or are worth selling, the absence of a payment layer means you give value away.

This is not a flaw in MCP; the protocol deliberately leaves payment out, the way HTTP leaves payment out. It just means monetization is something you add on top. The reason a valuable MCP server earns nothing is therefore structural: there is no payment in the stack unless you put it there. Once you see that the gap is a missing layer rather than a limitation you must live with, the fix follows, add the payment layer the protocol leaves to you.

The fix

The fix is to gate the MCP server's HTTP route with the x402 adapter, so calls require payment. You serve the server over the Streamable HTTP transport, which exposes an HTTP route, and register createX402Plugin (Fastify) or createX402Middleware (Express) in front of that route with per-route pricing. After that, an unpaid call gets an HTTP 402 quoting the price, the caller settles in USDC on Base, and only then does the MCP server run the tool.

This adds exactly the missing layer: a paywall in front of the server. Your tools do not change; the gate sits ahead of them and enforces payment. A machine caller, typically an agent, pays per call from its wallet with no signup, so any capable agent can pay and use your tools on first contact. The no-monetization problem is solved by inserting the payment layer MCP leaves out, which turns a free server into one that earns per call.

How to implement it

Implementing the fix has a clear order. First, make sure the server uses the Streamable HTTP transport, not stdio, because the adapter gates an HTTP route and stdio has none. This is the prerequisite. Second, register the adapter in front of the route with a price:

import Fastify from "fastify";
import { createClient } from "@blockchain0x/node";
import { createX402Plugin } from "@blockchain0x/x402/server/fastify";

const sdk = createClient({ apiKey: process.env.B0X_API_KEY! });
const app = Fastify();
await app.register(createX402Plugin, {
  sdk,
  defaultNetwork: "testnet",
  pricing: { "POST /mcp": { amountUsdc: "0.02", payToAddress: process.env.B0X_PAYTO_ADDRESS!, paymentRequestId: "pr_mcp" } },
});
// The MCP Streamable HTTP handler on POST /mcp runs only after payment.

Third, leave a free discovery route so callers can list your tools before paying. That is the whole shape: transport, gate, free discovery. The strategy around it is in how-to-monetize-mcp-server, and the unit you are charging for is explained in what-is-a-paid-mcp-tool.

Verify it works

Confirm the fix on Base Sepolia before going live. With a sk_test_ key, call the gated route without payment and check that a 402 comes back quoting your price. Then call it through a paying client and confirm the payment settles in test USDC, the MCP server runs the tool, and the result returns. Watch the dashboard for the matching payment.received on your account, and confirm the free discovery route still works without payment.

If an unpaid call is not getting a 402, the adapter may not be in front of the right route, or the route may be omitted from the pricing map. If the server is stdio, there is no HTTP route to gate, switch to Streamable HTTP first. Once the unpaid-gets-402, paid-runs loop holds on testnet, swapping to a sk_live_ key moves it to Base mainnet unchanged. That verified loop is proof the no-monetization problem is solved.

What to charge for

Solving monetization well means charging for the right things. Price the tools that cost you to run or deliver real value, ones backed by expensive data, heavy compute, or a specialized capability, and keep discovery and low-value tools free. A caller needs to see what the server offers before paying, so the tool-listing step stays free, and trivial tools are usually not worth the friction of payment.

Because x402 prices per route, you charge for tools by arranging them across routes by price tier, then pricing each route. So part of the fix is deciding which tools earn a price and grouping them accordingly, rather than gating everything indiscriminately. Set each price from the underlying cost plus a margin, and adjust on real usage. Monetizing is not just adding a paywall; it is adding it thoughtfully, charging for value and leaving discovery open, which is what makes a paid MCP server one callers actually use.

The economics of the fix

It is worth thinking about the economics, because monetization is not only a technical change but a business one. Before the fix, a valuable MCP server is a pure cost: you pay for the data, compute, and hosting its tools consume, and earn nothing back. After the fix, each paid call returns revenue, so the server can cover its costs and, ideally, profit. The shift is from a cost center to something that pays for itself or better.

Per-call pricing suits this especially well for machine callers. An agent that uses your server occasionally pays only for what it uses, which is fair and lowers the barrier to trying it, while a heavy user pays in proportion to its usage, which scales your revenue with demand. There is no subscription to negotiate and no signup to complete, so the addressable market is every capable agent rather than only those who would commit to a plan. That is why per-call monetization fits an agent-facing MCP server: it aligns what you earn with how much your tools are used, and it reaches callers a signup funnel never would. Add a small view of per-route revenue from the payment events, and you can see which tools earn and tune prices accordingly, turning the fix into an ongoing source of income rather than a one-time switch.

Related reading

If your MCP server has no monetization, the path forward is short. The strategy and steps are in how-to-monetize-mcp-server, and the concept of the unit you charge for is in what-is-a-paid-mcp-tool. Together they take you from a free server to one that earns per call, with discovery still open. Pricing is on the pricing page.