Forem: Roman V

How to Monetize Your MCP Server in 10 Minutes

Roman V — Wed, 15 Apr 2026 23:54:34 +0000

You built an MCP server. It works. Agents call your tools, get results, everybody's happy — except you're paying for compute and API calls out of pocket.

You want to charge for it. But now you're looking at building: payment verification, usage tracking, API key management, subscription tiers, credit balances, revenue splits, Stripe integration, webhook handling. That's 2–4 weeks of work that has nothing to do with the tool you actually built.

This is the billing problem every MCP server operator hits. You can build tools in a weekend, but monetizing them takes weeks. Most operators choose "not monetizing" and either burn money or shut down.

mcp-billing-gateway solves this. It's a reverse proxy that sits in front of your MCP server and handles all billing — Stripe subscriptions, per-call credits, and x402 crypto payments. Your server stays unchanged. You register it, set pricing, and start earning.

Architecture: How It Works

AI Agent (caller)
    │
    ├─ Authorization: Bearer cgwcl_...
    │
    ▼
┌──────────────────────────┐
│   mcp-billing-gateway    │
│                          │
│  1. Authenticate caller  │
│  2. Check credits/sub    │
│  3. Debit payment        │
│  4. Forward JSON-RPC     │
│  5. Record usage         │
│  6. Return response      │
└──────────┬───────────────┘
           │
           ▼
┌──────────────────────────┐
│  Your MCP Server         │
│  (unchanged, untouched)  │
└──────────────────────────┘

Your MCP server never sees billing logic. The gateway proxies JSON-RPC requests, handling authentication, payment verification, and usage metering transparently. If a caller doesn't have credits or a valid subscription, they get a 402 Payment Required before your server is even contacted.

Step 1: Register as an Operator

curl -X POST https://mcp-billing-gateway-production.up.railway.app/api/v1/operator/register \
  -H "Content-Type: application/json" \
  -d '{
    "email": "you@yourcompany.com",
    "name": "Your Company"
  }'

Response:

{
  "operator_id": "op_01jvz...",
  "api_key": "cgwop_abcd1234...",
  "stripe_onboard_url": "https://connect.stripe.com/setup/abc123..."
}

Save that API key — it's shown once. Visit the stripe_onboard_url to connect your Stripe account (business info + bank account for payouts). This uses Stripe Connect Express, so you get a managed account without handling PCI compliance yourself.

Step 2: Register Your MCP Server

Point the gateway at your upstream server:

curl -X POST https://mcp-billing-gateway-production.up.railway.app/api/v1/operator/servers \
  -H "Authorization: Bearer cgwop_abcd1234..." \
  -H "Content-Type: application/json" \
  -d '{
    "name": "Weather MCP",
    "description": "Real-time weather data for AI agents",
    "upstream_url": "https://your-mcp-server.com/mcp",
    "proxy_slug": "weather",
    "auth_mode": "header",
    "upstream_auth_token": "your-server-secret",
    "transport": "http",
    "is_public": true
  }'

Your server is now proxied at:

https://mcp-billing-gateway-production.up.railway.app/proxy/weather

The auth_mode field controls how the gateway authenticates to your upstream: header injects a Bearer token, query appends it as a query parameter, none sends requests unauthenticated. The upstream_auth_token is your server's own auth — callers never see it.

Step 3: Set Pricing

The gateway supports three billing models. You can have multiple plans per server.

Per-call (pay-as-you-go):

curl -X POST https://mcp-billing-gateway-production.up.railway.app/api/v1/operator/servers/srv_01jvz.../plans \
  -H "Authorization: Bearer cgwop_abcd1234..." \
  -H "Content-Type: application/json" \
  -d '{
    "name": "Pay-as-you-go",
    "billing_model": "per_call",
    "price_per_call_usd_micro": 10000,
    "free_calls_per_month": 100,
    "is_default": true
  }'

That's $0.01 per call (prices are in micro-units: 10,000 micro = $0.01) with 100 free calls per month. The free tier resets monthly.

Monthly subscription:

curl -X POST https://mcp-billing-gateway-production.up.railway.app/api/v1/operator/servers/srv_01jvz.../plans \
  -H "Authorization: Bearer cgwop_abcd1234..." \
  -H "Content-Type: application/json" \
  -d '{
    "name": "Pro",
    "billing_model": "subscription",
    "subscription_price_usd_cents": 999,
    "subscription_interval": "monthly",
    "subscription_call_limit": 10000,
    "is_default": false
  }'

$9.99/month for up to 10,000 calls. Managed via Stripe, with automatic period tracking and cancellation handling.

Tiered pricing:

curl -X POST https://mcp-billing-gateway-production.up.railway.app/api/v1/operator/servers/srv_01jvz.../plans \
  -H "Authorization: Bearer cgwop_abcd1234..." \
  -H "Content-Type: application/json" \
  -d '{
    "name": "Volume",
    "billing_model": "tiered",
    "tiers": [
      {"up_to": 1000, "price_usd_micro": 0},
      {"up_to": 10000, "price_usd_micro": 5000},
      {"up_to": null, "price_usd_micro": 10000}
    ],
    "is_default": false
  }'

First 1,000 calls free, next 9,000 at $0.005 each, everything above at $0.01.

Step 4: Callers Start Using Your Server

From the caller's perspective, the integration is straightforward. Using the TypeScript SDK:

import { GatewayCallerSDK } from '@mcp-billing-gateway/caller-sdk';

const client = new GatewayCallerSDK({
  baseUrl: 'https://mcp-billing-gateway-production.up.railway.app'
});

// Register (one-time)
const { api_key } = await client.register('bot@myapp.com', 'My Agent');
client.setApiKey(api_key);

// Add credits ($10.00)
await client.topupCredits(1000, 'pm_stripe_payment_method_id');

// Call your tool — billing happens automatically
const result = await client.callTool('weather', 'get_weather', {
  city: 'Berlin'
});
console.log(result);

Or with plain curl:

curl -X POST https://mcp-billing-gateway-production.up.railway.app/proxy/weather \
  -H "Authorization: Bearer cgwcl_caller_key..." \
  -H "Content-Type: application/json" \
  -d '{
    "jsonrpc": "2.0",
    "id": "req-1",
    "method": "tools/call",
    "params": {
      "name": "get_weather",
      "arguments": {"city": "Berlin"}
    }
  }'

The gateway authenticates the caller, checks their credit balance, debits the call cost, forwards the JSON-RPC request to your server, and returns the response. If the upstream returns an error, credits are automatically refunded.

x402 Crypto Payments

For agent-to-agent transactions where callers have crypto wallets, the gateway supports x402 payments — USDC on Base chain. No API key needed. The caller sends a payment claim header:

curl -X POST https://mcp-billing-gateway-production.up.railway.app/proxy/weather \
  -H "X-402-Payment: <base64-encoded-payment-claim>" \
  -H "Content-Type: application/json" \
  -d '{
    "jsonrpc": "2.0",
    "id": "req-1",
    "method": "tools/call",
    "params": {"name": "get_weather", "arguments": {"city": "Berlin"}}
  }'

If a caller sends a request without valid payment, they get a structured 402 response with pricing info:

{
  "jsonrpc": "2.0",
  "id": "req-1",
  "error": {
    "code": 402,
    "message": "Payment Required",
    "data": {
      "price_usd_micro": 10000,
      "x402_address": "0x...",
      "chain": "base"
    }
  }
}

This means your single server can accept both fiat (Stripe) and crypto (USDC) payments simultaneously, depending on what the caller supports.

Revenue and Analytics

Track how your server is being used and how much you're earning:

# Usage analytics
curl "https://mcp-billing-gateway-production.up.railway.app/api/v1/operator/servers/srv_01jvz.../usage?from=2026-04-01&to=2026-04-15" \
  -H "Authorization: Bearer cgwop_abcd1234..."

The response includes usage broken down by day, by tool name, by billing rail (fiat vs. x402), and top callers. You see exactly which tools are popular and which pricing model callers prefer.

# Revenue and payouts
curl https://mcp-billing-gateway-production.up.railway.app/api/v1/operator/revenue \
  -H "Authorization: Bearer cgwop_abcd1234..."

The default revenue split is 85/15 — you keep 85% of each call's revenue, the platform takes 15%. When you're ready to collect:

curl -X POST https://mcp-billing-gateway-production.up.railway.app/api/v1/operator/payouts/request \
  -H "Authorization: Bearer cgwop_abcd1234..."

Funds transfer to your linked Stripe account within 1–2 business days. Minimum payout: $1.00.

Self-Hosting

The gateway is open for self-hosting if you want full control:

docker run -p 3000:3000 \
  -e DB_PATH=/data/billing.db \
  -e STRIPE_SECRET_KEY=sk_test_... \
  -e STRIPE_WEBHOOK_SECRET=whsec_... \
  -e PLATFORM_URL=https://your-domain.com \
  -v billing-data:/data \
  mcp-billing-gateway

SQLite for storage (no Postgres dependency), Stripe for payment processing, and the full operator + caller API available at your own domain. Set DEFAULT_TAKE_RATE_BPS to adjust the revenue split (default 1500 = 15%).

What You Don't Have to Build

Here's what the gateway handles so you don't have to:

Concern	Without Gateway	With Gateway
API key management	Build auth system	Built-in (hashed, scoped, revocable)
Payment processing	Integrate Stripe SDK	Pre-integrated via Stripe Connect
Usage metering	Build tracking system	Per-call metering with breakdown
Subscription management	Handle Stripe webhooks	Automatic period tracking + cancellation
Credit system	Build ledger + balance tracking	Prepaid credits with auto-refund on errors
x402 crypto payments	Implement payment verification	Built-in x402 validation + anti-replay
Revenue analytics	Build dashboard	Usage by day, tool, billing rail, caller
Payouts	Manual Stripe transfers	One API call, automatic splits

Getting Started

Register as an operator (30 seconds)
Complete Stripe onboarding (2 minutes)
Register your server with a proxy slug (1 minute)
Create a pricing plan (1 minute)
Share the proxy URL with your users

Your MCP server is now monetized. No code changes to your server, no new dependencies, no payment infrastructure to maintain.

Live gateway: mcp-billing-gateway-production.up.railway.app
SDK docs: sapph1re/mcp-billing-gateway-sdk
Glama listing: glama.ai/mcp/servers/sapph1re/mcp-billing-gateway-sdk

How to Stop AI Agent Cost Blowups Before They Happen

Roman V — Wed, 15 Apr 2026 23:54:14 +0000

You deploy a four-agent pipeline that should cost about $0.80 per run. By end of day it has burned through $47 on a single stuck researcher loop. Sound familiar?

If you're running AI agents in production, cost blowups are not a question of if but when. 57% of organizations already have agents in production, yet 90% of agent projects fail within 30 days — and runaway LLM costs are the number one pain point.

The core problem: agents make autonomous decisions about how many LLM calls to issue. A retry loop, an overly verbose chain-of-thought, or a stuck tool call can silently 10x your bill before you notice.

The Current State of Agent Cost Control

Most teams handle this with one of three approaches, all of which fall short:

Manual monitoring. You watch dashboards and kill processes when costs spike. This works until you're asleep, in a meeting, or running 20 agents in parallel.

Provider-level spending caps. OpenAI and Anthropic offer monthly limits, but they're account-wide. You can't set a $5 budget for a specific research pipeline while allowing your coding agent $50.

Gateway proxies (Helicone, Portkey). These require routing all traffic through an external service. They add latency, a point of failure, and vendor lock-in. And they still don't give you per-agent circuit breakers.

What's missing is a framework-native solution: something that hooks directly into CrewAI, AutoGen, or LangGraph at the process level, enforces hard limits before each LLM call, and trips a circuit breaker when things go wrong — without requiring any external infrastructure.

Introducing agent-cost-guardrails

agent-cost-guardrails is an open-source Python library that does exactly this. Pure Python, zero infrastructure, framework-native hooks.

pip install agent-cost-guardrails

Here's what it gives you:

Hard budget limits — raises BudgetExceededError when spend exceeds your cap
Per-call token limits — prevents any single LLM call from consuming too many tokens
Rate limiting — tokens-per-minute sliding window to control burst spend
Circuit breaker — trips after N consecutive violations, requires manual reset
Alert callbacks — fire at configurable thresholds (50%, 80%, 100%)
Cost breakdown — track spend by model and by agent
Bundled pricing — 30+ models from OpenAI, Anthropic, Google, Mistral, DeepSeek, and Meta

Quick Start: The Context Manager

The simplest way to use it:

from agent_cost_guardrails import BudgetGuard

with BudgetGuard(max_usd=5.00) as guard:
    guard.pre_call_check(estimated_tokens=2000)
    # ... your LLM call here ...
    cost = guard.post_call_record(
        model="gpt-4o",
        input_tokens=1500,
        output_tokens=800
    )
    print(f"Call cost: ${cost:.4f}")
    print(guard.cost_report())

pre_call_check() validates the budget, rate limit, and circuit breaker before the call happens. post_call_record() tracks the actual spend. If the budget is exceeded, BudgetExceededError stops execution immediately.

CrewAI Integration

CrewAI is the most popular multi-agent framework, and it has the worst cost visibility out of the box. The logging inside Tasks is broken, and there's no built-in token cap.

from crewai import Agent, Task, Crew
from agent_cost_guardrails.integrations import CrewAIGuardrails

def cost_alert(threshold, current, budget):
    print(f"WARNING: {threshold*100:.0f}% of ${budget:.2f} budget used")

guards = CrewAIGuardrails(
    max_usd=5.00,
    max_tokens_per_call=4096,
    on_alert=cost_alert
)
guards.install()

researcher = Agent(
    role="Market Researcher",
    goal="Find competitor pricing data",
    llm="gpt-4o"
)
task = Task(
    description="Research competitor pricing for SaaS analytics tools",
    agent=researcher
)
crew = Crew(agents=[researcher], tasks=[task])
crew.kickoff()

report = guards.cost_report()
print(f"Total: ${report['total_cost_usd']:.4f}")
print(f"By agent: {report['cost_by_agent']}")

guards.uninstall()

guards.install() registers @before_llm_call and @after_llm_call hooks globally. Every LLM call CrewAI makes — across all agents and tasks — gets checked and tracked automatically.

AutoGen / AG2 Integration

AutoGen's register_hook() system gives us a clean interception point:

from autogen import AssistantAgent, UserProxyAgent
from agent_cost_guardrails.integrations import AutoGenGuardrails

guards = AutoGenGuardrails(max_usd=10.00)

assistant = AssistantAgent("analyst", llm_config={"model": "gpt-4o"})
proxy = UserProxyAgent("user", human_input_mode="NEVER")

guards.wrap_agent(assistant)
guards.wrap_agent(proxy)

proxy.initiate_chat(assistant, message="Analyze Q1 revenue trends")

print(guards.cost_report())

The library uses AG2's safeguard_llm_inputs / safeguard_llm_outputs hooks with automatic fallback to legacy hook names for older AutoGen versions.

LangGraph / LangChain Integration

LangGraph uses LangChain's callback system, so the integration plugs in via BaseCallbackHandler:

from langgraph.graph import StateGraph
from agent_cost_guardrails.integrations import LangGraphGuardrails

guards = LangGraphGuardrails(max_usd=2.00)

graph = build_your_graph()  # your StateGraph
result = graph.invoke(
    initial_state,
    config={"callbacks": [guards.callback_handler]}
)

report = guards.cost_report()
print(f"Remaining budget: ${report['remaining_usd']:.2f}")

The callback handler intercepts on_llm_start, on_chat_model_start, and on_llm_end events. It extracts actual token usage from the response when available, and falls back to tiktoken estimation when not.

Circuit Breaker: Your Safety Net

The circuit breaker is what separates this from basic cost tracking. When an agent enters a failure loop — retrying the same failed tool call, generating invalid outputs, or hitting rate limits — the circuit breaker trips after N consecutive violations and stops all LLM calls until you explicitly reset it.

guard = BudgetGuard(
    max_usd=10.00,
    max_tokens_per_call=8192,
    circuit_breaker_max_violations=3
)

# After 3 consecutive per-call violations:
# CircuitBreakerTrippedError is raised on the next pre_call_check()
# All agents stop. No more silent cost accumulation.

This is the difference between a $5 mistake and a $500 one.

Custom Model Pricing

The library ships with pricing for 30+ models, but you can override or extend it:

from agent_cost_guardrails import set_custom_pricing

set_custom_pricing({
    "my-fine-tuned-gpt4": {
        "input_per_mtok": 6.00,
        "output_per_mtok": 18.00,
    }
})

Pricing is maintained per million tokens (input and output separately) and supports prefix matching — so gpt-4o-2024-05-13 automatically resolves to the gpt-4o price.

Before and After

Before agent-cost-guardrails:

4-agent pipeline expected cost: ~$0.80/run
Actual cost with stuck loops: $3–$12/run
Worst case (overnight): $47 in a single stuck session
Discovery: next morning, checking the billing dashboard

After:

Hard cap: $2.00/run, enforced at the framework level
Circuit breaker trips after 3 violations — no silent loops
Alert at 80% budget → you get notified before hitting the cap
Per-agent breakdown → identify which agent is the problem

Getting Started

pip install agent-cost-guardrails          # core
pip install agent-cost-guardrails[crewai]  # + CrewAI hooks
pip install agent-cost-guardrails[autogen] # + AutoGen hooks
pip install agent-cost-guardrails[langgraph] # + LangGraph callbacks
pip install agent-cost-guardrails[all]     # everything

The library is MIT-licensed. Source, docs, and examples on GitHub:

PyPI: agent-cost-guardrails
GitHub: sapph1re/agent-cost-guardrails

If you're running agents in production and haven't had a cost blowup yet, you will. The question is whether you'll catch it at $2 or at $200.