DEV Community: Luther Whiting-Collins

Your MCP Server Has 10 Distribution Channels You're Not Using

Luther Whiting-Collins — Sat, 04 Apr 2026 11:26:52 +0000

Most MCP server developers build their tool, publish it to npm, and hope someone finds it. That is not a distribution strategy. It is a wish.

The reality is that AI agents do not browse npm. They do not read your README. They need programmatic ways to discover, evaluate, and invoke tools at runtime — and most MCP servers are invisible to them.

Here are 10 distribution channels that exist today for MCP servers. Most developers are using zero of them.

1. The Official MCP Registry

The Model Context Protocol now has an official registry at registry.modelcontextprotocol.io. This is where MCP clients are starting to look for servers programmatically. Publishing here takes one command:

npx mcp-publisher publish

Your server gets a permanent entry that MCP clients can query. If you have published to npm, you are already halfway there — the registry pulls metadata from your package.json.

Why it matters: As MCP clients add auto-discovery features, this registry will be the first place they check. Being listed early means being found first.

2. Agent Discovery APIs

Some platforms expose REST APIs that AI agents query at runtime to find tools. An agent working on a task can search for "weather API under 5 cents per call" and get back a list of matching tools with pricing, ratings, and endpoints — all programmatically, no human in the loop.

GET /api/v1/discover?q=weather&max_cost=5&sort=popular

This is fundamentally different from a static directory listing. The agent decides what it needs, searches, evaluates, and invokes — in one workflow. If your tool is registered on a platform with a discovery API, agents find you without you doing anything.

Why it matters: The future of MCP tool distribution is agent-native, not human-browseable. Agents do not scroll through web pages.

3. Meta-MCP Servers

A meta-MCP server is a single MCP endpoint that aggregates many tools behind one connection. Instead of an agent configuring 20 separate MCP servers, it connects to one meta-server and gets access to all of them.

{
  "mcpServers": {
    "marketplace": {
      "url": "https://example.com/api/mcp"
    }
  }
}

One line of config. Every tool in the marketplace becomes callable. If your tool is listed on a platform that runs a meta-MCP server, every agent connected to that server can invoke your tool.

Why it matters: Agent developers want fewer connections, not more. A meta-server that includes your tool is distribution you do not have to maintain.

4. llms.txt

The llms.txt specification is a machine-readable file at the root of a website that tells AI assistants about available services. When Claude, ChatGPT, or Perplexity encounters a site with llms.txt, they can read it to understand what the site offers and how to use it.

If your MCP server is listed on a platform that maintains llms.txt with tool-level detail, AI assistants can recommend your specific tool when users ask for help.

Why it matters: 50% of all content cited by AI search engines is less than 13 weeks old. Having your tool in a well-maintained llms.txt means AI assistants can recommend it in conversations — passive distribution through every AI chat.

5. MCP Community Directories

There are now 7+ community directories specifically for MCP servers:

Smithery — 6,000+ servers with verified listings
PulseMCP — 12,000+ servers, ingests from the Official Registry
mcp.so — 17,000+ servers
Glama.ai — 9,000+ servers with previews
Cline Marketplace — GitHub-based, reviewed submissions
cursor.directory — plugins for Cursor IDE users
MCPMarket — community directory

Each listing is a backlink from a domain that search engines and LLM training crawlers index. Most accept submissions in under 5 minutes. Listing on all 7 takes about 30 minutes total.

Why it matters: Each directory listing is a permanent discovery surface. An agent developer browsing Smithery or a Cursor user browsing plugins could find your tool. These listings also feed into Google rankings and LLM training data.

6. Framework Integration Packages

AI agent frameworks like LangChain (90K+ GitHub stars), CrewAI (45K+), and n8n (400K+ users) have their own tool ecosystems. Publishing a framework-specific package — or listing your MCP server on a platform that has native framework integrations — puts your tool in front of developers who are already building agents.

For example, an n8n community node that wraps your MCP server makes it available to every n8n user as a drag-and-drop action in their workflows.

Why it matters: Framework users discover tools within their framework's ecosystem, not on npm. Meeting them where they are is more effective than hoping they search for your npm package.

7. Programmatic SEO Pages

When you publish a tool on certain platforms, you automatically get SEO-optimized pages created for you:

A tool detail page with Product schema and star ratings
Category landing pages ("Best weather APIs for AI agents")
Framework integration pages ("MCP tools for LangChain")
Collection pages ("Top data enrichment tools")

Each page is a potential Google search result that drives organic traffic to your tool. You do not write these pages — they are generated programmatically from your tool's metadata.

Why it matters: One published tool can generate 50+ indexed pages across category, framework, and collection combinations. That is SEO at scale without writing a single blog post.

8. Embeddable Badges

A live badge in your GitHub README shows your tool's name, per-call price, and invocation count — with a direct link to try it. Unlike a static shield.io badge, a dynamic badge updates in real time as your tool gets used.

[![SettleGrid](https://settlegrid.ai/api/badge/tool/my-tool)](https://settlegrid.ai/tools/my-tool)

Every visitor to your GitHub repo sees the badge. Every badge view is a potential click to your tool's page.

Why it matters: Your README is already your most-viewed marketing page. A badge turns it into a storefront without changing your code.

9. Edge-Cached Proxy Endpoints

Some platforms give your tool a permanent, cached URL that is faster and more reliable than calling your server directly. The platform caches responses at the edge, adds automatic failover, and handles rate limiting.

This means an agent calling your tool through the proxy gets:

Lower latency (edge-cached responses)
Higher reliability (failover to alternatives if your server is down)
Built-in fraud detection and budget enforcement

The proxy URL itself becomes a distribution asset — shareable, bookmarkable, and more trustworthy than a raw server endpoint.

Why it matters: Agents and consumers prefer calling a cached, reliable endpoint over a raw server URL. The proxy is not just infrastructure — it is a better distribution address.

10. Trending and Spotlight Features

Platforms with marketplaces often feature top-performing tools — trending this week, tool of the week, most invocations. If your tool performs well, it earns visibility organically through algorithmic selection, not paid promotion.

This creates a virtuous cycle: more invocations → higher ranking → more visibility → more invocations.

Why it matters: You cannot buy this visibility. You earn it by building a tool people actually use. But you have to be on a platform that has trending features in the first place.

The distribution gap

Most MCP server developers use exactly one distribution channel: npm. They run npm publish and consider distribution done.

But npm is a package registry, not a distribution platform. It does not have a discovery API. It does not run a meta-MCP server. It does not generate SEO pages. It does not have agent-native search. It does not cache your responses at the edge.

The developers who will earn meaningful revenue from their MCP tools are the ones who publish once and get distributed through all 10 channels automatically. The infrastructure for this exists today — most developers just have not plugged into it yet.

I build SettleGrid, which implements channels 1-10 described above. If you want to see how these channels work for a real MCP server, check out the platform page or try the free tools — no account required.

How to Monetize Any AI Tool — Not Just MCP Servers

Luther Whiting-Collins — Thu, 02 Apr 2026 20:48:24 +0000

Per-call billing for AI tools is not an MCP-only problem. If you have built anything that AI agents call — a REST API, a HuggingFace model, a LangChain tool, an n8n node, a data pipeline, a scraping service — you have the same monetization problem that MCP server developers have: how do you get paid every time an agent uses your work?

The answer is the same regardless of what kind of AI tool you built. You need three things: metering (count every call), billing (charge per call), and distribution (let agents find you). Here is how each works across every type of AI tool.

The 8 types of AI tools that can be monetized per-call

1. MCP Servers

Model Context Protocol servers are the most talked-about category because Claude, Cursor, and Windsurf use them natively. An MCP server exposes tools that AI agents call via a standardized protocol. Per-call billing is natural — every tools/call request is a billable event.

2. REST APIs

Any HTTP endpoint that returns data or performs computation. Weather APIs, translation services, geocoding, sentiment analysis. These are the oldest form of "AI tool" and the most straightforward to meter — every request has a URL, method, and response.

3. AI Model Endpoints

Inference endpoints on HuggingFace, Replicate, or your own infrastructure. Text generation, image classification, embedding computation, speech-to-text. Each inference call has a measurable cost (compute time, GPU usage) that maps directly to per-call pricing.

4. Agent Framework Tools

Tools built for LangChain, CrewAI, AutoGen, Semantic Kernel, or smolagents. These are Python or TypeScript functions that agents invoke during task execution. The framework handles orchestration; you need a billing layer that meters each invocation.

5. Automation Nodes

n8n community nodes, Zapier integrations, Make.com modules. Each execution of your node in someone's workflow is a billable event. The automation platform handles triggering; you handle the logic and need a way to charge for it.

6. Data APIs

Financial data feeds, market intelligence, public records, scientific datasets. Consumers query your data on demand. Per-call pricing aligns naturally — each query returns value proportional to the data served.

7. Scraping and Enrichment Services

Web scrapers, data enrichment tools, lead generation APIs. These are high-value per-call because each call produces unique, time-sensitive data that the consumer cannot get elsewhere.

8. SDK Packages

npm or PyPI packages that provide AI capabilities. The package itself is free to install, but premium features or higher rate limits are billed per-call when the package phones home to your API.

What all 8 have in common

Every one of these tools shares the same monetization requirements:

Metering — Count every call accurately, in real time, without adding latency. This is harder than it sounds. You need atomic counters, budget enforcement (stop calls when a consumer's balance hits zero), and fraud detection (block abusive patterns before they drain your revenue).

Billing — Charge consumers per call, with flexible pricing: flat rate, tiered, outcome-based, or method-specific (different prices for different endpoints). Handle payments in fiat and crypto. Support 15+ payment protocols because AI agents speak different payment languages — MCP, x402, AP2, Visa TAP, and others.

Distribution — Let AI agents discover your tool programmatically. A billing system without discovery is a cash register in an empty store. Agents need to search for "weather API under 5 cents" and find your tool without human intervention.

Payouts — Revenue flows to your bank account automatically. Connect Stripe once, set your pricing, and let the settlement layer handle splitting revenue, computing take rates, and scheduling deposits.

The billing stack you would have to build yourself

If you build per-call billing from scratch, here is what you are signing up for:

Redis-backed metering — atomic DECRBY for balance checks, sub-50ms latency requirement
Budget enforcement — spending limits per consumer, auto-reset periods, real-time threshold alerts
Stripe Connect integration — onboarding flow, destination charges, payout scheduling
Fraud detection — velocity checks, IP reputation, geographic anomalies, refund abuse patterns
Rate limiting — per-consumer, per-tool, tiered by plan
Multi-protocol support — detect whether the caller is using MCP, x402, REST, or another protocol
Analytics dashboard — revenue trends, consumer cohorts, latency percentiles, error rates
Webhook system — notify consumers of usage thresholds, failed payments, tool health changes

That is 2-4 weeks of engineering for the basics. Longer for enterprise-grade reliability.

Or you can wrap one function:

import { settlegrid } from "@settlegrid/mcp";

const sg = settlegrid.init({
  toolSlug: "my-tool",
  pricing: {
    defaultCostCents: 2,
    methods: {
      search: { costCents: 1 },
      analyze: { costCents: 5 },
    },
  },
});

const search = sg.wrap(async (args) => {
  return await mySearchFunction(args.query);
}, { method: "search" });

Two lines of meaningful code. Metering, billing, fraud detection, and distribution are handled.

Distribution is the part everyone forgets

Building a great AI tool is necessary but not sufficient. The harder problem is getting agents to find it.

Traditional distribution (write a blog post, tweet about it, submit to a directory) does not work for AI agents. Agents do not read tweets. They need:

Discovery APIs that return tools matching their criteria at runtime
Meta-MCP servers that aggregate tools behind a single connection
Machine-readable metadata (llms.txt, JSON-LD, OpenAPI specs) that AI assistants can parse
Programmatic SEO so that search-augmented LLMs find your tool when users ask for recommendations

The settlement layer you choose should handle distribution, not just billing. Otherwise, you are building a monetized tool that no one can find.

The economics

The question developers always ask: is per-call billing worth it?

Here is the math. A tool priced at $0.02 per call that receives 1,000 calls per day generates $600 per month. At 10,000 calls per day, that is $6,000 per month. These are realistic numbers for a well-distributed tool in a category with demand (weather, translation, financial data, code analysis).

The key variable is not price per call — it is distribution. A tool with 100 calls per day at $0.05 earns less ($150/month) than a tool with 10,000 calls per day at $0.01 ($3,000/month). Volume wins, and volume comes from distribution.

Progressive take rates mean you keep more as you grow. On platforms with 0% take on your first $1,000/month, your first $1,000 is entirely yours. Above that, take rates of 2-5% still leave you with 95-98% of revenue.

Getting started

Regardless of what type of AI tool you have built, the path to monetization is the same:

Wrap your function with a billing SDK (2 lines of code)
Set your price per call or per method
Connect Stripe for payouts (one-time setup)
Publish so agents can discover your tool

The infrastructure for monetizing any AI tool — not just MCP servers — exists today. The developers who act first in each category will capture the market before it gets crowded.

I build SettleGrid, a settlement layer for AI tool billing that supports MCP servers, REST APIs, AI models, agent tools, and more. The platform page explains how distribution works across 10 channels. You can try the free tools without an account.

How to Monetize Your MCP Server in 2026: The Complete Guide

Luther Whiting-Collins — Thu, 26 Mar 2026 20:34:30 +0000

There are over 20,000 MCP servers in the wild. Less than 5% make a single dollar. The rest are donated labor — talented developers building useful tools and getting nothing for it. This guide walks through adding per-call billing to any MCP server in under 5 minutes using SettleGrid, so your tools can start earning while you sleep.

The Opportunity: 95% of MCP Servers Earn Nothing

There are over 20,000 MCP servers listed on Glama, 19,000 on mcp.so, 12,500+ on the Official MCP Registry, and 6,000+ on Smithery. The MCP SDK is downloaded over 120 million times per month. Yet less than 5% of these servers generate any revenue at all. The total agent-to-tool payment volume globally is under $50K per day. This is not because developers do not want to earn money. It is because, until recently, adding billing to an MCP server required building payment infrastructure from scratch: Stripe integration, usage metering, invoice generation, webhook handling, and fraud detection.

SettleGrid eliminates that barrier. Two lines of code wrap your existing handler with per-call billing, usage metering, and Stripe payouts. No Stripe integration. No usage dashboards. No billing code. You focus on building great tools; SettleGrid handles the money.

Step 1: Install the SettleGrid SDK

Run npm install @settlegrid/mcp in your MCP server project. The SDK exports a withBilling wrapper that intercepts tool calls, meters usage, and settles payments automatically. It works with any MCP server implementation that follows the Model Context Protocol specification.

Alternatively, scaffold a new project with npx create-settlegrid-tool. The CLI creates a complete project with TypeScript, billing hooks, test harnesses, and deployment configs for Vercel, Railway, and Fly.io. You can pass flags like --category data or --pricing per-call to skip the prompts.

Verify your setup with npx settlegrid doctor. This checks your Node.js version, validates your tsconfig.json, and confirms the SDK can reach the SettleGrid API.

Step 2: Set Your Pricing

Configure pricing in your settlegrid.config.ts file. The simplest model is per-invocation: set a price in cents and every successful tool call charges that amount. For example, pricing: { model: "per-call", amount: 5 } charges 5 cents per call.

SettleGrid supports six pricing models: per-call, per-token, per-byte, per-second, tiered (different prices per method), and outcome-based (charge only on success). Start with per-call if you are unsure. It is the easiest to reason about and the easiest for consumers to understand.

Price based on value, not cost. A data enrichment tool that saves an agent 30 seconds of research is worth 10 to 25 cents, regardless of whether your compute cost is 0.1 cents. Most first-time tool builders underprice by 3 to 5 times.

Step 3: Wrap Your Handler

The core integration is two lines of code. Import settlegrid from @settlegrid/mcp, initialize it with your tool slug, and wrap your existing handler:

const sg = settlegrid.init({ toolSlug: "my-tool" })
const billed = sg.wrap(yourHandler, { costCents: 5 })

That is it. The wrap function intercepts every tool call, verifies the caller has sufficient credits, meters the usage, and settles the payment after your handler returns a successful response. Failed calls are not charged. Rate-limited calls return structured errors that agents can retry.

Your handler code does not change at all. The wrap function is transparent: it passes the same input to your handler and returns the same output to the caller. The only difference is that each call is now metered and billed.

Step 4: Deploy and Publish

Deploy your MCP server to any hosting provider. The SDK is runtime-agnostic and works in Node.js, Deno, and Bun. For serverless deployments, the SDK batches metering events and flushes them asynchronously to avoid adding latency.

Publish your tool to the SettleGrid marketplace by running npx settlegrid publish. Your listing appears in the explore page, category pages, search results, and the Discovery API that AI agents use to find tools. Listings go live within minutes.

Connect Stripe for payouts in the SettleGrid dashboard under Settings. SettleGrid uses Stripe Connect to pay tool publishers. Earnings transfer to your Stripe balance on a rolling 7-day schedule. You keep 95% of every transaction on the Free tier.

Step 5: Monitor and Grow

Use the SettleGrid dashboard to monitor usage, revenue, and consumer behavior in real time. Track calls per minute, p50/p95 latency, error rate, revenue by day, and top consumers. Set up alerts for anomalies.

Review your pricing after the first week. If your tool has high adoption but low revenue, your price is too low. If adoption is slow despite strong discovery metrics, your price may be too high or your listing needs improvement.

Add the SettleGrid badge to your GitHub README with npx settlegrid badge. Tools with README badges see 3x more discovery traffic. Register in MCP directories, write content about your tool, and leverage cross-promotion with complementary tools to accelerate growth.

Get Started

SettleGrid is free forever for most developers. The free tier includes 25,000 operations per month at 0% platform fee with 95% revenue share.

Documentation
Scaffold a new tool: npx create-settlegrid-tool
Browse 1,017 open-source templates
MCP Billing Platforms Compared

SettleGrid — the settlement layer for AI agent payments. Free tier, 95% revenue share, 2 lines of code.

How to Monetize Your MCP Server in 5 Minutes

Luther Whiting-Collins — Wed, 25 Mar 2026 15:40:29 +0000

There are 20,000+ MCP servers in the wild. Fewer than 5% have any form of monetization.

Developers build incredible AI tools, publish them for free, then abandon them because there's no revenue to sustain development. The MCP ecosystem has a payment problem.

I built https://settlegrid.ai to fix this — an open-source SDK that adds per-call billing to any MCP tool with 2 lines of code.

Step 1: Install the SDK

npm install @settlegrid/mcp

Or scaffold a complete project instantly:

npx create-settlegrid-tool

Step 2: Register Your Tool

Sign up free at https://settlegrid.ai/register. Create a tool, set your slug, choose a pricing model. No credit card required.

Step 3: Wrap Your Handler

import { settlegrid } from '@settlegrid/mcp'

const sg = settlegrid.init({
toolSlug: 'my-web-search',
pricing: { defaultCostCents: 5 },
})

const handler = sg.wrap(async (query) => {
const results = await searchTheWeb(query)
return results
})

That's it. Every call now validates the consumer's API key, checks their credit balance, executes your function, meters usage, and splits revenue — all in under 50ms.

Step 4: Choose Your Pricing

SettleGrid supports 6 pricing models:

Per-invocation — Search, lookups → 5¢/call
Per-token — LLM wrappers → $0.001/1K tokens
Per-byte — File processing → 1¢/MB
Per-second — Video/ML inference → 2¢/second
Tiered — Multi-method tools → read 1¢, write 5¢
Outcome-based — Lead gen, extraction → 25¢ on success

Benchmarks by tool type:

Simple lookups/search: 1-5 cents per call
Data enrichment: 5-25 cents per call
AI-powered analysis: 10-50 cents per call
Complex workflows: 25 cents - $1+ per call

The Revenue Math

100 AI agents × 20 calls/day × 5 cents = $3,000/month

And you keep 100% on the Free tier (0% platform fee). Paid tiers take 5%.

Step 5: Get Discovered

This is where SettleGrid is different from "just add Stripe." Your tool is automatically discoverable across:

SettleGrid Showcase — consumers browse and purchase credits
Discovery API — directories and apps query your tools programmatically
MCP Discovery Server — AI agents find your tools natively via MCP
8+ MCP registries — Official MCP Registry, Smithery, Glama, PulseMCP, and more

Every active tool is indexed everywhere. No extra configuration.

What I've Built So Far

1,017 open-source MCP server templates with billing pre-wired (https://settlegrid.ai/servers)
10 payment protocol support — MCP, MPP (Stripe), x402 (Coinbase), AP2 (Google), Visa TAP, and 5 more
CLI scaffolder — npx create-settlegrid-tool generates a complete project
Free Monetization Handbook — pricing strategies, growth tactics, revenue benchmarks (https://settlegrid.ai/learn/handbook)

The Free Tier

25,000 ops/month
0% take rate — you keep 100%
Unlimited tools
No credit card
$1 minimum payout

Most developers will never need to upgrade.

Links

Website: https://settlegrid.ai
SDK: https://www.npmjs.com/package/@settlegrid/mcp
GitHub: https://github.com/lexwhiting/settlegrid
Handbook: https://settlegrid.ai/learn/handbook
Docs: https://settlegrid.ai/docs

What tools would you want to monetize? I'm curious what categories people think are underserved. Drop a comment below.