How to host an MCP server for ChatGPT apps and connectors

TL;DR. ChatGPT only talks to remote MCP servers: a public HTTPS endpoint that speaks Streamable HTTP (SSE is also listed), answers at a stable URL that typically ends in /mcp, and uses OAuth 2.1 when tools act on a user's behalf. A local stdio server cannot be added. Once it is hosted, you register it in ChatGPT developer mode as a custom connector, or publish it through the OpenAI Apps SDK (now grouped with skills under "plugins"). The fastest way to get a working ChatGPT MCP server online is to fork Hatchable's MCP starter: one file per tool, deploy, and it is live at https://<slug>.hatchable.site/mcp with OAuth handled.

What ChatGPT requires from an MCP server

OpenAI's deployment guidance for the ChatGPT Apps SDK (developers.openai.com/apps-sdk/deploy) is short and specific. As of August 2026 your production endpoint must:

• Be remote and reachable. OpenAI asks for "a stable, publicly reachable HTTPS endpoint." ChatGPT runs in OpenAI's cloud, so it cannot launch a process on your laptop. That rules out stdio servers entirely. OpenAI does offer a Secure MCP Tunnel for testing a local server from developer mode, but a tunnel, a temporary tunnel, or a local endpoint is not accepted for public submission.
• Speak Streamable HTTP. The endpoint must "support the MCP streamable HTTP transport" and "respond at a stable URL, typically ending in /mcp." OpenAI's developer-mode guide lists "SSE and streaming HTTP" as the supported protocols.
• Authenticate properly when tools touch user data. OAuth 2.1 is expected "when your plugin requires user authentication." OpenAI is explicit that "an IP allowlist does not replace authentication or authorization." Read-only servers may run anonymously; OpenAI notes that "many plugin MCP servers can operate in a read-only, anonymous mode."
• Behave like production. Secrets in the host's secret manager, timeouts and rate limits on expensive tools, no access tokens in logs, and a pass through MCP Inspector to confirm initialization, tools, schemas, annotations, and auth.

Where you run it is up to you: OpenAI lists serverless, container, edge, and traditional infrastructure as all acceptable. The constraint is the contract above, not the vendor. For a wider tour of the hosting choices, see remote MCP server hosting options.

Connectors, apps, plugins, and ChatGPT developer mode

The naming has moved a few times, which is why people search for "chatgpt custom connector," "chatgpt mcp server," and "openai apps sdk" for the same task. OpenAI shipped the Apps SDK in October 2025, renamed connectors to apps in December 2025, and in July 2026 moved the app directory into a plugin directory, where a plugin bundles skills, an MCP server, and optional UI. Under every name, the thing ChatGPT actually connects to is an MCP server.

Developer mode is how you attach your own server before (or instead of) publishing it. Per OpenAI's developer-mode guide and the matching help article, it "provides full Model Context Protocol (MCP) client support for all tools, both read and write," and is offered to Pro, Plus, Business, Enterprise, and Education accounts on the web. As of August 2026 the toggle is under Settings, then Security and login; earlier 2026 builds had it under Settings, Connectors, Advanced, so do not be surprised if a screenshot you find shows a different path. From there:

1. Open the ChatGPT plugins page (chatgpt.com/plugins) and select the plus button to create a developer-mode app.
2. Give it a name and description, then under Connection choose a public endpoint and "enter the MCP server URL, including the /mcp path."
3. Pick the authentication model: OAuth (static credentials, Client ID Metadata Documents, or Dynamic Client Registration), no authentication, or mixed.
4. ChatGPT calls your server's tools/list and shows you the tools and metadata it discovered. Review them.
5. Start a new conversation and add the connection from the tools menu. Write actions ask for confirmation by default, and you may need to be explicit: "use the Acme app's update_record tool to ..."

This is also how discovery works for any connector: ChatGPT reads the tool names, descriptions, and input schemas your server advertises, and the model picks a tool when the conversation calls for it. Good descriptions matter more than clever prompting.

The OAuth flow ChatGPT expects

If your tools act for a user, ChatGPT behaves as a standard OAuth 2.1 client following the MCP authorization spec. Your server advertises protected-resource metadata at /.well-known/oauth-protected-resource, which points at an authorization server that publishes its own metadata. ChatGPT registers as a client (OpenAI prefers Client ID Metadata Documents, with Dynamic Client Registration and pre-registered clients also supported), runs the authorization-code flow with PKCE using the S256 challenge, then attaches the access token to every MCP request. Your server must verify the token itself: signature, issuer, audience, expiry, and scope. The redirect URI for compliant servers is https://chatgpt.com/connector_platform_oauth_redirect.

That is a fair amount of plumbing before you write a single tool, and it is the part most "build an MCP server" tutorials skip.

The worked path on Hatchable

Hatchable projects can expose their own MCP endpoint, with the transport, hosting, and OAuth handled by the platform. You write the tools. The facts below match the build an MCP server guide and the MCP feature page.

1. Fork the MCP starter

   Open /apps/mcp and click Install. If you have no account, that creates a free one, no card. You get a project with [mcp] enabled = true in hatchable.toml and a working endpoint at https://<slug>.hatchable.site/mcp.

2. Write one file per tool in mcp/

   Each file declares who may call it and exports a tool with a name (which must equal the filename), a description, an input schema, and a handler. The handler gets the same toolkit as the rest of your app: the project's private Postgres database, email, storage, AI calls, scheduler, and browser.

   // mcp/list_deals.js
   export const access = 'member';   // 'user' | 'member' | 'admin'
   
   export default {
     name: 'list_deals',
     description: 'List deals, newest first, optionally filtered by stage.',
     inputSchema: {
       type: 'object',
       properties: { stage: { type: 'string' } },
     },
     async handler(args, ctx) {
       const { rows } = await ctx.db.query(
         'SELECT id, name, stage FROM deals WHERE ($1::text IS NULL OR stage = $1) ORDER BY id DESC',
         [args.stage ?? null],
       );
       return { deals: rows };
     },
   };

   Per-tool access is enforced before your handler runs: a read tool can be open to your app's signed-in users while a destructive one stays admin-only. Tool names and schemas are extracted at deploy, so a malformed tool fails the deploy rather than failing in front of ChatGPT.

3. Deploy

   Deploy from your connected AI or the console. Your server is live at https://<slug>.hatchable.site/mcp over Streamable HTTP, and the OAuth flow is served from hatchable.com and advertised the way the MCP spec describes, so a compliant client discovers it without configuration. The app itself can stay private; the endpoint authorizes on its own token.

4. Register it in ChatGPT developer mode

   Turn on developer mode, open the plugins page, select the plus button, paste https://<slug>.hatchable.site/mcp, and choose OAuth. ChatGPT sends you to hatchable.com, where you approve access to that project and see the tool list, then returns with the discovered tools. Start a new chat, add the connection from the tools menu, and ask for something your tool does.

5. Watch it work

   Every call is logged in the project's MCP tab in the Hatchable console, with the caller and the tool. Tokens are issued per app and revocable from the console at any time.

If you want ChatGPT to build the server for you rather than writing the tool file by hand, connect Hatchable to ChatGPT from the app directory (no developer mode needed for that direction) and ask it to add a tool to your project. ChatGPT writes the file, deploys, and the endpoint updates. The platform's own connection is documented in the developer docs.

What you get, and what you do not

On the free plan you get unlimited private projects and one published app, no card; Builder is $12 a month for unlimited published apps. Every project has its own private Postgres database, file storage, sign-in for the app's users, email, cron, secrets, and the MCP endpoint described above. What Hatchable is not: a Python or Docker host, a home for long-running processes, or a renderer for Apps SDK widgets. If your ChatGPT app needs inline UI components, build the server here if you like, and follow OpenAI's docs for the UI layer on top.

OpenAI product details are based on public documentation as of August 2026 and move often; check OpenAI's developer docs for current menus, plans, and requirements.