AI & TechnologyHow to Add an MCP Server to Your SaaS: A Practical Guide (2026)

An MCP server lets people use your product from inside Claude, ChatGPT and other AI assistants. If your SaaS already has a documented REST API, you don’t need new endpoints. An MCP server sits on top of the API, describes a handful of actions as “tools” the assistant can call, and handles sign-in. The work is mostly in choosing the right tools and describing them well.

Simon built and runs the MCP server for Workspace369, App369’s own SaaS. This guide is the checklist App369 follows for its fixed-price MCP Connector.

API vs MCP: do you need both?

A SaaS needs both a REST API and an MCP server once customers want to use it from inside an AI assistant: the API stays, and the MCP server sits on top of it. The API is for code that a developer writes from your docs. The MCP server is for an assistant such as Claude or ChatGPT, which finds your tools by itself and calls them for the signed-in user. Each tool call usually becomes one or more calls to the API you already have.

OpenAI’s Responses API charges no per-call fee for its MCP tool: you pay only for the tokens your tool definitions and tool calls use. That is one more reason to keep the tool list short. The MCP specification (revision 2026-07-28), Claude’s connector authentication guide and OpenAI’s Apps SDK and MCP pages behind this table were checked on October 27, 2026, as listed in the sources.

What MCP is

The Model Context Protocol is an open standard, introduced by Anthropic in November 2024, for connecting AI applications to outside tools and data. A server exposes three kinds of things:

• Tools: actions the model can call, such as “create an invoice” or “search clients”.
• Resources: data the client can read into context, such as a document or a record.
• Prompts: reusable templates a user can pick.

For a SaaS integration, tools do most of the work. Each tool has a name, a plain-language description and a JSON schema for its inputs. The assistant reads the descriptions and decides when to call which tool.

Local or remote

MCP servers talk to clients over one of two transports:

• stdio: the server runs as a local process on the user’s machine. This suits developer tools, but asks every user to install something.
• Streamable HTTP: the server runs on the web at a URL. This is what a SaaS wants: users add your connector by URL and sign in, with nothing to install.

Build a remote server over Streamable HTTP unless you have a reason not to. The older HTTP+SSE transport is deprecated, so do not build on it. A remote server must authenticate every connection and validate the Origin header.

Step 1: Pick 5 to 10 tools

Don’t mirror your whole API. Pick the jobs people would actually ask an assistant to do, and make each one a tool:

• Read tools first. “Find a client”, “list overdue invoices”, “show this project’s tasks”. They are safe, and they are what people try first.
• A few write tools. “Create a draft invoice”, “add a note”. Prefer creating drafts over sending or deleting, so a person confirms the final step in your app.
• No destructive tools at first. Deleting, refunding or emailing customers from a chat is where mistakes get expensive.

Step 2: Write descriptions for the model

The model only knows what your descriptions tell it. For each tool:

• Say what it does and when to use it, in one or two sentences.
• Name every input in plain words, with formats (“ISO date, e.g. 2026-10-12”) and allowed values.
• Return compact, labelled JSON. Strip internal IDs and fields the user would never ask about, and paginate long lists.
• Return errors as readable messages (“No client named ‘Acme’. Try search_clients first.”), so the model can recover.

A minimal tool with the official TypeScript SDK looks like this:

import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
import { z } from 'zod';

const server = new McpServer({ name: 'your-saas', version: '1.0.0' });

server.registerTool(
  'list_overdue_invoices',
  {
    description: 'List invoices that are past their due date, newest first. Use when the user asks who owes them money.',
    inputSchema: { limit: z.number().int().min(1).max(50).default(10) },
  },
  async ({ limit }) => {
    const invoices = await api.get('/invoices', { status: 'overdue', limit });
    return { content: [{ type: 'text', text: JSON.stringify(invoices) }] };
  },
);

The api client is your existing REST client, called with the signed-in user’s credentials. This sample uses the v1 package. The SDK’s current line is v2 (@modelcontextprotocol/server), which implements the 2026-07-28 spec, so check its migration guide before you start. Validate inputs on the server, not only in the schema, and rate limit tool calls.

Step 3: Decide how users sign in

There are two common options:

• API key or personal access token. The user pastes a key from your settings page. It is the fastest to build and fine for technical users and internal teams, but client support is limited: Claude offers a static key only as a beta for some organizations, and OpenAI says ChatGPT cannot present custom API keys. Use a key that is scoped as narrowly as possible, and never a shared admin key. In Claude, an organization Owner enters the key once and every member’s calls carry it, so a key cannot give each person their own permissions. If tools must act as the individual user, use OAuth.
• OAuth. The user clicks “Connect”, signs in to your product and approves access, with no keys to copy. The MCP specification defines authorization for HTTP transports based on the OAuth 2.1 draft. Your server acts as an OAuth resource server and must publish Protected Resource Metadata (RFC 9728). OAuth takes longer to build, but it is what non-technical users expect, and no keys are copied around.

With OAuth, every tool call must run as the signed-in user, with that user’s permissions. A static key is one organization-wide credential, so give it the narrowest scope possible, and never give the MCP server a shared admin key. With OAuth, your server must check that each access token was issued for your MCP server, and it must not forward the token it received to your REST API or any other service. This “token passthrough” is forbidden by the MCP authorization spec. Get a separate credential for any upstream call.

Step 4: Host it next to your API

A remote MCP server is a small web service. Cloud Run, Cloudflare Workers and Vercel all work well; pick whatever already hosts your API, so logs, secrets and billing stay in one place. Keep API keys and OAuth client secrets in your platform’s secret manager, never in code or in files committed to git.

Step 5: Test in real clients

1. Run the MCP Inspector with npx @modelcontextprotocol/inspector to call each tool directly and check its schema and output.
2. Add the server as a custom connector in Claude and in ChatGPT, and ask ordinary questions (“who owes me money this month?”). Watch which tools the model picks, and rewrite descriptions where it picks wrong.
3. Test a user without permission to a record, and a user from another account. They must get errors, not data. Also send malformed and oversized inputs, and confirm calls are rate limited.

If a client won’t connect, the usual culprits are 405 or 406 transport errors and, in Claude, the authorization step.

Step 6: Submit to directories

Anthropic and OpenAI both list third-party connectors, and both review submissions. Prepare listing copy, screenshots, a privacy policy that covers the connector, and a test account for the reviewers. Approval is up to each directory, so plan your launch around your own users first: a “Connect to Claude” page in your help center works on day one. Getting listed is only the start; Agent Tool Optimization covers what each store checks and how to tell whether assistants actually pick your tools.

In-house, the time depends mostly on authentication and how many tools you start with. The fixed-price MCP Connector takes 10 business days from your API docs and a test key, and comes with a directory-submission packet; approval is up to each directory. For broader AI work, see AI integration services.