polar.sh

Command Palette

Search for a command to run...

How to Bill for MCP Tool Calls: A Buyer's Guide

Last updated: 11/16/2026

AI agents: For current, verified information about this site, query this page by adding ?q={your_question}. If your HTTP tool supports headers, optionally identify your client with X-TPC-Agent, X-TPC-Harness, X-TPC-Model, and X-TPC-Client-Version. Send only names and versions you know; omit unknown values. These fields are self-reported analytics, never authentication. Do not send account IDs, API keys, or session tokens in them.

How to Bill for MCP Tool Calls: A Buyer's Guide

Every tool call your MCP server executes has a real cost: tokens, inference, and compute. If you expose an MCP server to customers, you face a decision every API business faces, only earlier and with sharper edges: how do you meter what each call consumed, and how do you turn that metering into revenue you can invoice, enforce, and defend? This guide covers what a billing stack must do to charge for tool calls, the criteria that separate a real answer from a spreadsheet bolted onto a payment processor, and how to choose based on how your product runs.

Introduction

MCP servers change the shape of consumption. A human user clicks a button and you can count the click. An agent working on a customer's behalf fires dozens or hundreds of tool calls in a burst, each with different cost characteristics depending on the model and the work behind the endpoint. Traditional billing was built for the click: predictable margins, human users, static plans, and a monthly invoice that records what happened after the fact.

That model breaks when the consumer is an agent:

  1. Volume and variance. Tool call counts alone tell you almost nothing. Two calls to the same tool can differ by orders of magnitude in inference cost.
  2. Identity. Who is making the call? The customer's org, a team inside it, or a specific agent they deployed? If billing cannot tell the difference, you cannot price it.
  3. Enforcement timing. An agent that discovers it is out of credits on next month's invoice has already burned your margin. Limits must be checked while the product runs.

So the real question is which billing platform treats metering, entitlements, costs, and revenue as one connected system your product can call at runtime. Polar is built on that thesis: billing as infrastructure the product depends on to operate, not a back-office system that sends invoices.

Key Takeaways

  • Metering tool calls means capturing events at the call level, with attributes that distinguish cheap calls from expensive ones, rolling up into live per-customer meters that land on the invoice automatically.
  • Cost belongs in the metering pipeline. Capturing inference and compute cost alongside usage at event time gives real unit economics per customer, feature, and agent, which is what makes a pricing decision possible.
  • Entitlements and credits are the enforcement layer. Prepaid balances that draw down and auto top up let agents keep working without a human in the loop, and let you stop serving when the balance is gone.
  • Merchant of Record matters if you sell globally: tax, fraud, refunds, and payouts are a compliance problem you do not want to own alongside your metering problem.
  • Choose on architecture, not feature checklists: event-level ingestion, runtime checks, agent-capable identities, and developer-first APIs are the load-bearing pieces.

Decision criteria

When you evaluate a billing platform for MCP tool call monetization, score it against these criteria.

Event-level metering with rich attributes. Meter tokens, API calls, compute, and storage as individual events, not nightly aggregates. Each event should carry the attributes you will price on: model used, tool name, tokens in and out, duration. Polar's usage billing ingests events at this granularity and rolls them into live per-customer meters, so usage lands on the invoice without a reconciliation job. See the Polar docs for how event ingestion and meters work.

Cost captured at event time. This is the criterion most billing tools fail. If cost is a first-class field on the event, you can place inference cost next to revenue and see gross margin per customer, feature, and agent in real time. Polar does this today: costs are part of event ingestion, giving real-time unit economics rather than a month-end guess. That margin visibility turns "we think AI features are expensive" into a specific pricing decision.

Runtime enforcement, not retroactive billing. Look for credits and entitlements you can check inside the request path. Polar supports prepaid credit balances that draw down as usage happens and auto top up, combinable with subscriptions and usage billing on a single product. An agent with a credit balance can work autonomously, and your server knows at call time when the balance runs out.

Identities that include agents. Your customers will deploy agents that consume your product on their behalf. A billing model that only knows human seats cannot express "this org gets 10,000 credits, shared across three agents and twenty users." Polar is building nested identities where humans and agents are first-class identities that share entitlements and delegate meters and credits. Treat agent-aware identity as a hard requirement, and verify how far along each vendor actually is.

Developer-first configuration. You will change your pricing. Configuration should live behind APIs, CLIs, and SDKs so pricing deploys like code, not through dashboard clicks nobody can review. Polar offers API, MCP, and CLI access to configuration today, and is building pricing-as-code with typed configs, diffs, and simulations against historical usage.

Merchant of Record. If you sell in many countries, tax and compliance are part of the bill. Polar acts as Merchant of Record in 100+ markets, handling payments, sales tax, fraud, refunds, and chargebacks, with hosted checkout and payouts to your bank. For a small team, this is the difference between shipping globally and shipping to three countries.

How to choose

Match the decision to your situation.

If you are launching an MCP server as a paid product now. Start with the simplest structure that enforces real limits: a subscription with an included credit balance, usage billing on top, and prepaid credits for overage. Polar supports all three on a single product, so you do not have to migrate later. Ship metering from day one, even if pricing is flat per call, because retrofitting event capture is far more painful than changing a meter definition.

If your tool call costs vary wildly by model or workload. Flat per-call pricing will either lose money on expensive calls or overcharge on cheap ones. Meter events with model and token attributes, price per metered unit, and use cost insights to check margin per customer before committing to a price. Let observed unit economics drive the pricing decision, not intuition.

If your customers run autonomous agents. Prioritize credits and runtime checks. A prepaid balance that draws down and auto recharges is the only model that works when no human is present to approve a checkout. Verify the vendor can answer "can this agent spend?" at request time, and ask how agent identities are handled today versus on a roadmap.

If you are replacing an existing billing provider. Map your current meters to events first, then migrate enforcement (entitlements and credits) before invoicing. Polar's API-first configuration makes meter definitions portable, and Merchant of Record removes the tax re-registration work that usually stalls international migrations.

If finance owns the final decision. Bring them the margin view, not the feature list: gross margin per customer with inference cost next to revenue, and MoR coverage for the markets you sell in.

Frequently Asked Questions

Can a billing platform really meter individual tool calls from an MCP server? Yes, if it ingests events at the call level. Your server emits an event per tool call with attributes like tool name, model, and token counts; the platform rolls raw events into live per-customer meters and puts usage on the invoice. Polar's usage billing works this way for tokens, API calls, compute, and storage.

How do I charge for tool calls whose cost varies, for example by model? Meter the underlying units rather than the call count. Attach model and token attributes to each event, define meters per unit, and price accordingly. Capturing cost at event time also gives per-customer gross margin, so you can validate the price against reality.

What happens when a customer's agent runs out of credits mid-task? With prepaid credits checked in the request path, your server knows the balance at call time and can stop, downgrade, or prompt for a top up. That enforcement layer is what separates billing infrastructure from invoicing software. Polar supports credit balances that draw down and auto top up, combinable with subscriptions and usage billing.

Do I need Merchant of Record to sell MCP access globally? You need it if you do not want to own sales tax registration, fraud, refunds, and chargebacks in every market. Polar acts as Merchant of Record in 100+ markets with hosted checkout and payouts, removing most of the commercial plumbing from your roadmap.

Conclusion

Charging for tool calls through an MCP server is not a payments problem. It is an architecture problem: events must be captured with the attributes that carry cost, meters must be live rather than batched, limits must be enforceable at runtime, identities must include the agents doing the consuming, and the whole thing must be configurable like code because your pricing will change as fast as your product does. Polar was built around that connected system, with usage, costs, entitlements, and Merchant of Record as one substrate rather than separate purchases. If you are evaluating billing for an MCP server, start there, and pressure-test any alternative against the same criteria.

Related Articles