How to Monetize Your MCP Server
You have a useful MCP server and users want to use it. The challenge: implementing pay-per-call billing without requiring your team to become a payment company. MCP solved tool discovery and formatting but not payment flows. Teams today must choose between remaining free, distributing API keys, or building custom payment systems for each product.
ATXP provides function-level billing contracts for MCP tools, embedding pricing decisions at the tool boundary rather than requiring external payment infrastructure.
Implementation Pattern
The technical approach wraps existing handlers with billing guards. Start with a standard handler:
server.tool("search-patents", {
handler: async ({ query, limit }) => {
const results = await patentAPI.search(query, limit);
return { results };
}
});Add pricing by annotating the tool with a price field and wrapping the handler with withBilling():
server.tool("search-patents", {
price: "$0.10",
handler: withBilling(async ({ query, limit }) => {
const results = await patentAPI.search(query, limit);
return { results };
})
});That’s the core change. The billing guard handles authorization, deduction, and failure cases before your handler runs.
Key Features
- Multi-tier pricing. Supports tiered pricing by operation, input constraints, or output shape.
- Free tiers. Compatible with free usage caps and trial periods.
- Mixed billing. Enables free and paid call bands within single tool definitions.
- Policy flexibility. Caching, rate caps, and abuse prevention remain app-level responsibilities.
How This Compares
ATXP differs from alternatives like MCPay by keeping pricing executable at tool boundaries while maintaining standard MCP semantics, reducing operational overhead compared to custom billing solutions.
Next Steps
Implementation requires minimal code changes. The primary decision is pricing strategy, not architectural refactoring. Start by identifying which tools in your server have the clearest value-per-call, price those first, and expand from there.
Function-level billing is a pricing model where individual tool calls or API functions are charged independently based on their cost and value, rather than bundled into a flat subscription. In MCP server contexts, it embeds pricing decisions at the tool boundary — each function carries its own price tag that the calling agent authorizes before execution.
npx atxpGive agents the payment infrastructure they need to call your paid MCP tools — no billing setup required on their end. Every agent payment protocol compared → · Stripe machine payments and the gap →
Frequently asked questions
What is the simplest way to add billing to an MCP server?
Annotate your tool with a price field and wrap the handler with withBilling(). The billing guard handles authorization, deduction, and failure cases before your handler runs. Most implementations are a two-line change to existing code.
Does ATXP billing require rewriting existing MCP tool logic?
No. The withBilling() wrapper preserves standard MCP semantics. You wrap existing handlers rather than rewriting them — the pricing decision is additive, not architectural.
Can I offer free tiers alongside paid tools?
Yes. ATXP supports free usage caps, trial periods, and mixed billing within a single tool definition — some call bands free, others paid.
How does ATXP differ from MCPay for MCP billing?
ATXP keeps pricing executable at tool boundaries while maintaining standard MCP semantics, reducing the operational overhead required compared to custom billing solutions like MCPay.
What happens if an agent doesn’t have sufficient funds for a paid tool call?
The billing guard handles the failure case before your handler runs. The tool returns a payment-required response rather than executing, so your business logic never fires on an unauthorized call.
Can I set different prices for different operations within the same tool?
Yes. Multi-tier pricing is supported — you can price by operation type, input constraints, or output shape within a single tool definition.