How to Build and Sell MCP Servers: The Market Forming Right Now for Solo Builders

TL;DR: The Model Context Protocol (MCP) has become the universal standard for connecting AI agents to external tools. You can build a working MCP Server in a weekend using TypeScript or Python — and a paying market for specialized servers is just starting to form. This guide shows you how to build, test, and monetize your own.

There’s a window of opportunity that doesn’t stay open for long.

While most developers are still learning how to use Claude, GPT, and Gemini effectively, a new infrastructure layer is emerging beneath them: MCP Servers — the connectors that transform AI agents from chat interfaces into real software operators.

Solo builders who understand this shift early have an asymmetric advantage. Not as AI users. As AI tool builders.

What MCP Is (and Why Every Agent Needs It Now)

The Model Context Protocol is an open protocol created by Anthropic in 2024 that was quickly adopted by OpenAI, Google, and dozens of tools across the AI ecosystem.

The problem it solves is fundamental: how do you connect an LLM to external data sources and tools in a standardized, portable way?

Before MCP, every integration was custom. You’d write bespoke function-calling code for each LLM, with different schemas, different authentication patterns, and zero portability between models. The result was unmaintainable code that locked you to a single provider.

MCP defines a universal protocol built on three primitives:

• Tools: actions the agent can execute (query a database, send an email, create a file)
• Resources: data sources the agent can read (documents, repos, filesystems)
• Prompts: reusable instruction templates the server surfaces to the client

Build an MCP Server once, and it works with Claude Desktop, Cursor, Windsurf, Continue.dev, and any other compatible client. Write once, run everywhere.

Paid MCP Servers: The Business Opportunity Forming Right Now

Here’s what matters for solo builders: the market for MCP Servers is forming right now.

Directories like MCP.so and the official modelcontextprotocol/servers repository already list hundreds of servers. Most of them are open source, generic, and free.

The gap is in specialized, paid servers:

• MCP Servers wrapping niche data APIs (financial data, real estate, legal databases)
• Servers simplifying complex paid tools into agent-friendly interfaces
• Servers built around specific team workflows (agencies, law firms, e-commerce operations)
• Multi-source servers that unify several data streams into one coherent tool surface

These servers have real business value. Companies already paying for Claude Enterprise or OpenAI Teams have the budget and the need — what they lack is the integration layer. That’s your opportunity.

Anatomy of an MCP Server

Before building, understand the structure.

Transport Layer

MCP supports two transport types:

• stdio: communication via stdin/stdout — ideal for local tools (Claude Desktop, Cursor)
• SSE (Server-Sent Events): HTTP-based communication — required for remote, multi-user servers

For sellable products, you need SSE with authentication.

The Three Primitives in Practice

MCP Server
├── tools/          → executable actions
│   ├── get_customer   → fetch customer from CRM
│   ├── send_invoice   → trigger invoice via Stripe
│   └── query_reports  → pull analytics data
├── resources/      → readable data
│   ├── schema.sql  → database structure
│   └── docs.md     → product documentation
└── prompts/        → instruction templates
    └── support_agent → base prompt for customer support flows

The agent (Claude, GPT-4, Gemini) decides when and how to invoke each tool based on conversation context. You define what each tool does and what input schema it expects. The agent handles the reasoning.

Tutorial: Build Your First MCP Server in TypeScript

Prerequisites

• Node.js 18+
• TypeScript
• Claude Desktop (for testing)

1. Project Setup

mkdir my-mcp-server
cd my-mcp-server
npm init -y
npm install @modelcontextprotocol/sdk zod
npm install -D typescript @types/node tsx

Create tsconfig.json:

{
  "compilerOptions": {
    "target": "ES2022",
    "module": "Node16",
    "moduleResolution": "Node16",
    "outDir": "./dist",
    "strict": true
  }
}

2. Basic Server Structure

Create src/index.ts:

import { Server } from "@modelcontextprotocol/sdk/server/index.js";
import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
import {
  CallToolRequestSchema,
  ListToolsRequestSchema,
} from "@modelcontextprotocol/sdk/types.js";
import { z } from "zod";

const server = new Server(
  {
    name: "my-mcp-server",
    version: "1.0.0",
  },
  {
    capabilities: { tools: {} },
  }
);

const GetWeatherSchema = z.object({
  city: z.string().describe("City name to get weather for"),
  units: z.enum(["celsius", "fahrenheit"]).optional().default("celsius"),
});

// Expose available tools
server.setRequestHandler(ListToolsRequestSchema, async () => {
  return {
    tools: [
      {
        name: "get_weather",
        description: "Get current weather for any city",
        inputSchema: {
          type: "object",
          properties: {
            city: { type: "string", description: "City name" },
            units: {
              type: "string",
              enum: ["celsius", "fahrenheit"],
              description: "Temperature units",
            },
          },
          required: ["city"],
        },
      },
    ],
  };
});

// Handle tool calls
server.setRequestHandler(CallToolRequestSchema, async (request) => {
  if (request.params.name === "get_weather") {
    const { city, units } = GetWeatherSchema.parse(request.params.arguments);

    // Replace with your actual weather API call
    const response = await fetch(
      `https://wttr.in/${encodeURIComponent(city)}?format=3`
    );
    const weather = await response.text();

    return {
      content: [{ type: "text", text: weather.trim() }],
    };
  }

  throw new Error(`Unknown tool: ${request.params.name}`);
});

// Start server
async function main() {
  const transport = new StdioServerTransport();
  await server.connect(transport);
  console.error("MCP Server running via stdio");
}

main().catch(console.error);

3. Connect to Claude Desktop

Add to claude_desktop_config.json (Mac: ~/Library/Application Support/Claude/, Windows: %APPDATA%\Claude\):

{
  "mcpServers": {
    "my-mcp-server": {
      "command": "npx",
      "args": ["tsx", "/absolute/path/to/src/index.ts"]
    }
  }
}

Restart Claude Desktop. The tools icon will appear in the chat interface. Ask Claude: “What’s the weather like in Tokyo right now?” — and watch it invoke your tool.

4. Adding Resources

Resources let the agent read structured data from your server:

import {
  ListResourcesRequestSchema,
  ReadResourceRequestSchema,
} from "@modelcontextprotocol/sdk/types.js";

server.setRequestHandler(ListResourcesRequestSchema, async () => {
  return {
    resources: [
      {
        uri: "config://schema",
        name: "Database Schema",
        description: "Current database structure",
        mimeType: "text/plain",
      },
    ],
  };
});

server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
  if (request.params.uri === "config://schema") {
    return {
      contents: [
        {
          uri: "config://schema",
          mimeType: "text/plain",
          text: "CREATE TABLE orders (id UUID PRIMARY KEY, customer_id UUID, amount DECIMAL...)",
        },
      ],
    };
  }
  throw new Error("Resource not found");
});

5. Migrating from stdio to SSE (multi-tenant product)

The stdio server works locally and is fine for validation. To sell access to multiple simultaneous customers, you need SSE with authentication.

npm install express cors
npm install -D @types/express @types/cors

Create src/server-sse.ts:

import express from "express";
import cors from "cors";
import { Server } from "@modelcontextprotocol/sdk/server/index.js";
import { SSEServerTransport } from "@modelcontextprotocol/sdk/server/sse.js";
import { CallToolRequestSchema, ListToolsRequestSchema } from "@modelcontextprotocol/sdk/types.js";

if (!process.env.API_KEY) {
  console.error("Error: API_KEY environment variable is not set.");
  process.exit(1);
}

const app = express();
app.use(cors());
app.use(express.json());

// API key authentication
function authenticate(req: express.Request, res: express.Response, next: express.NextFunction) {
  const apiKey = req.headers["x-api-key"];
  if (!apiKey || apiKey !== process.env.API_KEY) {
    res.status(401).json({ error: "Unauthorized" });
    return;
  }
  next();
}

// Active sessions per client
const transports = new Map<string, SSEServerTransport>();

app.get("/sse", authenticate, async (req, res) => {
  const transport = new SSEServerTransport("/messages", res);
  const sessionId = transport.sessionId;
  transports.set(sessionId, transport);

  const server = createServer();
  await server.connect(transport);

  res.on("close", () => transports.delete(sessionId));
});

app.post("/messages", authenticate, async (req, res) => {
  const sessionId = req.query.sessionId as string;
  const transport = transports.get(sessionId);
  if (!transport) {
    res.status(404).json({ error: "Session not found" });
    return;
  }
  await transport.handlePostMessage(req, res);
});

function createServer() {
  const server = new Server(
    { name: "my-mcp-server", version: "1.0.0" },
    { capabilities: { tools: {} } }
  );

  // Reuse the same handlers from your stdio version
  server.setRequestHandler(ListToolsRequestSchema, async () => ({
    tools: [{ name: "get_weather", description: "Get weather for a city", inputSchema: { type: "object", properties: { city: { type: "string" } }, required: ["city"] } }],
  }));

  server.setRequestHandler(CallToolRequestSchema, async (request) => {
    if (request.params.name === "get_weather") {
      const { city } = request.params.arguments as { city: string };
      const response = await fetch(`https://wttr.in/${encodeURIComponent(city)}?format=3`);
      const weather = await response.text();
      return { content: [{ type: "text", text: weather.trim() }] };
    }
    throw new Error(`Unknown tool: ${request.params.name}`);
  });

  return server;
}

app.listen(process.env.PORT || 3000, () => console.log("MCP SSE Server running"));

With this setup, each customer gets a unique API key. The server handles multiple simultaneous connections and is ready to deploy on Railway, Fly.io, or Cloudflare Workers.

5 MCP Server Types with Strong Monetization Potential

1. Niche Data API Wrappers

Connect agents to paid or complex APIs through a clean, agent-friendly interface.

High-value verticals:

• Business intelligence (company financials, firmographics)
• Real estate data (price history, comparable sales)
• Legal databases (case law, contracts, compliance)
• Local government data (permits, zoning, assessments)

Business model: Monthly subscription. You absorb the API cost and charge for the abstraction. Customers pay for convenience, not raw data access.

2. Productivity Tool Connectors

Build servers that connect agents to tools teams already use:

• Notion (create, update, query pages via conversation)
• Linear (manage issues through natural language)
• HubSpot, Pipedrive (update CRM by talking to the agent)
• Jira (sprint planning, ticket creation, velocity reports)

Business model: Per-workspace pricing. Teams pay readily for tools that eliminate manual context-switching.

3. E-commerce Operations

A server that connects an agent to Shopify, WooCommerce, or marketplace platforms:

• Check order status by name or email
• Update inventory across channels
• Generate sales reports for any date range
• Create draft products from description

Business model: Per-store pricing + usage tiers. High recurrence, clear ROI.

4. Proprietary Knowledge Bases

Index product documentation, legal precedents, or internal knowledge and expose it through MCP:

• MCP Server that “knows” everything about a SaaS product
• Company HR policy server for employee self-service
• Law firm precedent database for case research

Business model: Setup fee + monthly subscription. Sold as “your company’s custom AI brain.”

5. Industry-Specific Workflow Automation

Build servers executing specialized workflows for vertical markets:

• Healthcare: appointment scheduling, patient record lookup
• Real estate: property filtering, offer generation
• Accounting: ledger reconciliation, financial statement queries
• Logistics: shipment tracking, carrier comparison

Business model: Per-client licensing or white-label. High value, low competition.

How to Monetize Your MCP Server: Distribution, Pricing, and Revenue Models

Distribution Channels

Open core model: release the core server as open source on GitHub, charge for the hosted version or advanced features. Proven playbook in the developer ecosystem — see Supabase, PostHog, PlanetScale.

MCP directories: submit to MCP.so, the official modelcontextprotocol/servers repo, and communities like r/ClaudeAI and r/mcp. Free visibility.

Direct B2B sales: companies using Claude Enterprise or OpenAI Teams have budget. LinkedIn + cold email works better than you’d expect for genuine infrastructure solutions.

Developer communities: Ship.it, IndieHackers, Hacker News — show what you built and the problem it solves.

Pricing Models

Worked Pricing Example: E-commerce MCP Server

Product: MCP Server connecting a support agent to Shopify

Target buyer: E-commerce store owner with 500–5,000 orders/month who uses Claude Desktop or Cursor internally

Problem: support team spends 40% of time looking up order status, updating tracking info, and answering questions the agent could handle automatically

Value delivered: automates ~60% of support queries within 10 minutes of setup

Your operating cost:

• Cloudflare Workers: ~$5/month for up to 10M requests
• Maintenance: ~2h/month

Pricing tiers:

Why this pricing works: if the server automates 20 tickets per day at an average cost of $3 each (agent time), the monthly savings are ~$1,800. The customer pays $79 and saves $1,800. The ROI is obvious — and the sales conversation takes five minutes.

Recommended Infrastructure for Remote Servers

• Cloudflare Workers: zero cold start, global edge deployment, generous free tier
• Railway or Fly.io: simple containerized deployment for more complex servers
• Auth: OAuth 2.0 or API keys per client with rate limiting via Upstash Redis

From MVP to First Payment: The Real Workflow for Launching an MCP Server

1. Find an integration everyone needs but nobody built well
   ↓
2. Build the MVP in stdio (local, fast to test)
   ↓
3. Migrate to SSE + authentication
   ↓
4. Deploy to Cloudflare Workers or Railway
   ↓
5. Simple landing page + early access form
   ↓
6. 10 free beta users → validate real usage
   ↓
7. Start charging at customer #11

The full cycle from zero to first payment can happen in 2–3 weeks. The technical barrier is low. Execution is what separates builders from observers.

Frequently Asked Questions about MCP Servers

Do I need TypeScript to build an MCP Server?

No. The official SDK exists in TypeScript and Python. If you’re a Python developer, the mcp package has a nearly identical API. Unofficial SDKs also exist in Go, Rust, and Kotlin.

Can I build MCP Servers without requiring my customers to use Claude?

Yes. MCP has been adopted by multiple AI clients: Cursor, Windsurf, Continue.dev, Cline, and others. Your server works with any MCP-compatible client. You’re not locked to Anthropic’s ecosystem.

What’s the difference between an MCP Server and a regular REST API?

A REST API requires the developer to know exactly which endpoints to call and in what sequence. An MCP Server exposes capabilities — and the agent decides how and when to use them based on the conversation context. This fundamentally changes the end-user experience from “developer integration” to “natural conversation.” To see how an existing SaaS product can be adapted for direct agent consumption via the MCP protocol, see WebMCP.

Can I monetize an open source MCP Server?

Yes. The open core model works well: open source the code, charge for the managed hosted version. You can also offer support contracts, customization services, and premium features as paid products. The model is validated across the open source ecosystem.

How do I handle authentication for multiple customers in an MCP Server?

Use OAuth 2.0 with per-workspace tokens or unique API keys per customer. The MCP SDK supports authentication at the transport level. For simplicity, use Clerk or Auth.js for identity and generate proprietary API keys for server access. Stripe handles billing.

Ship Something

The modelcontextprotocol/servers repository on GitHub has over 8,000 stars and grows every week. MCP.so lists hundreds of servers — almost all of them open source, generic, and free. The first specialized paid servers that are emerging charge between $19 and $99/month and have waitlists.

This isn’t speculation about the future. It’s the current state of the market.

The technical barrier to build a working MCP Server is lower than for any other type of software product: no database to design, no frontend to build, no REST API to document. You define tools, implement logic, wire up the transport. That’s it.

What determines who captures this market isn’t technical experience. It’s who stops reading and starts building.

Further reading: how Claude Code Skills work as local behavior extensions, and how Subagents enable parallel multi-agent orchestration — both integrate naturally with MCP architecture.