Yes, ChatGPT supports MCP, but the answer depends on which door you walk through. A Business admin can publish a custom connector with write access. A Pro subscriber gets something narrower. And the ChatGPT desktop app does not behave like Claude Desktop, because it never reads a local config file or launches a server on your machine. If a setup tutorial ever skipped those differences and left you staring at a connector that refuses to load, you are in good company: OpenAI's own documentation has described the Plus and Pro situation in more than one way.
This article sorts out what each plan can do today, what the desktop app really changes, and how to reach a server that lives on your own laptop. Everything here reflects what could be verified in early October 2026, and every spot where sources disagree is flagged. Skim the table first, then jump to the section that matches your plan.
The Short Answer
Here is the quick version, plan by plan.
| Plan | Custom MCP servers | Write actions | Where it works |
|---|
| Plus and Pro | Developer mode on the web, read and fetch access | Disputed, see the Plus and Pro section | Web |
| Business | Admin enables developer mode and publishes apps | Beta, controlled by admins | Web |
| Enterprise and Edu | Same as Business, plus role based access | Per action controls | Web |
What works today
- Remote MCP servers reachable over a public HTTPS address
- Streamable HTTP, with SSE also accepted
- OAuth, no authentication, or a mix of both
- Read and fetch tools on individual plans
- Private servers through OpenAI's Secure MCP Tunnel, announced in May 2026
What still does not
- Local stdio servers that ChatGPT would launch by itself
- Anything pointed at
localhost
- MCP apps on mobile, since they run on the web only
💡 Fast test: open your settings and look for a developer mode toggle under Connectors or Apps. If it is there, your account can try custom servers. If it is missing, no tutorial will put it there.
What MCP Does Inside ChatGPT

The Model Context Protocol is an open standard Anthropic introduced in November 2024. Its pitch is simple: one plug shape for connecting AI apps to tools and data, the way USB-C replaced a drawer full of chargers. OpenAI adopted it in 2025, first in its Agents SDK and Responses API, then in ChatGPT itself when developer mode launched in September 2025.
Servers, tools and apps
An MCP server publishes a list of tools. Each tool has a name, a description and an input schema. ChatGPT reads that list, and the model decides when a tool is worth calling. That means your tool descriptions do more work than most people expect. A vague description makes ChatGPT pick the wrong tool, or none at all.
A typical call runs like this:
- You ask a question in the chat.
- The model checks the tool list and picks a tool that matches.
- For a write tool, ChatGPT asks you to confirm before anything is sent.
- ChatGPT sends the call to your server over HTTPS.
- The server returns data or performs the action.
- The model writes its answer using that result.
Servers that only read data usually expose two tools named search and fetch, which is the pattern OpenAI documented for deep research connectors. Anything that creates, edits or deletes data is a write action, and that is exactly where plan limits start to bite.
Why the names keep changing
If you have searched this topic, you have seen "connectors," "apps," "custom MCP connectors" and, in newer developer docs, "plugins." They all point at roughly the same idea: an MCP server that ChatGPT can talk to. OpenAI's help center article on developer mode and MCP apps is the page to bookmark, because it changes more often than any blog post, this one included.
Plus and Pro Accounts

Plus accounts
When OpenAI announced developer mode on September 11, 2025, Plus and Pro were the launch plans. The beta supported both read and write operations, asked for confirmation before writes by default, and OpenAI itself described the feature as "powerful but dangerous."
The original path was Settings, then Connectors, then the Developer mode switch in the extra settings area. Once it was on, an option to add connectors appeared inside the chat composer. Menu labels have shifted since then, so look under Apps if Connectors is missing.
Pro accounts

Pro is where the wording turns specific. The current help center text says full MCP support is "only available to Business and Enterprise/Edu users, currently," while Pro users can connect MCP servers in developer mode with read and fetch permissions. Pro accounts also need to keep developer mode switched on to use custom apps.
In practice, a read-only server is the safest bet on an individual plan: a docs search, a database lookup, a knowledge base. A server that books meetings, edits tickets or writes files is the one to test with extra care, and the one most likely to need a workspace plan.
Good first servers for an individual account:
- A search tool over your own documentation
- A product or price lookup against a public catalog
- A notes index that only returns text, never edits it
- A public data API wrapped in one or two read tools
Why the docs disagree
Three readings circulate right now:
- The original announcement: Plus and Pro get full read and write access.
- The help center: full MCP is a workspace feature, and individual Pro accounts get read and fetch only.
- Some 2026 write-ups: developer mode has since moved to workspace plans, leaving individual accounts with directory apps only.
One 2026 write-up suggests the developer docs and the help center may be describing two different mechanisms, and OpenAI has not reconciled them in public. Treat your own account's settings as the final word, and recheck after any ChatGPT release note that mentions apps.
Business, Enterprise and Edu Workspaces

Workspace plans are where custom MCP is designed to live. Full MCP support, including write actions, is rolling out in beta to Business, Enterprise and Edu on ChatGPT web.
Who flips the switch
Developer mode is an admin setting. The toggle sits under Workspace Settings, Permissions and Roles, Connected Data, labeled as developer mode or custom MCP connector creation. On Business, one write-up notes that each admin has to enable it for themselves and cannot hand that off. Enterprise and Edu add role based access, so you can give specific people the right to build connectors without handing them the whole admin panel.
Write actions and confirmations

Write actions stay off until a workspace admin turns them on under Workspace settings, Apps, Manage actions for each app. Enterprise and Edu admins can switch individual actions on or off after publishing. Business admins cannot edit an app once it is published, so any change to tools or metadata means recreating and republishing it. Build a staging version first and publish only when the tool list is final.
Three risks OpenAI names
OpenAI's warning at launch listed three risks:
- Prompt injection and similar attacks hidden in content the model reads.
- Model mistakes on write actions that could destroy data.
- Malicious MCP servers that try to steal information.
A few habits keep those risks small:
- Connect only servers you or your company control, or trust just as much.
- Expose the smallest set of write tools that gets the job done.
- Read every confirmation prompt before approving it.
- Test against a sandbox account or a copy of your data.
💡 A confirmation prompt is a checkpoint, not a formality. If the arguments look wrong, decline the call and fix the tool description instead of clicking through.
The Desktop App Question

Search for "ChatGPT desktop MCP" and you land on a pile of posts that treat the desktop app as its own integration point. Mostly, it is not.
No local config file
Claude Desktop reads a JSON config file and starts the servers listed in it as local processes. Nothing in OpenAI's documentation or the third-party write-ups points to an equivalent for the ChatGPT desktop app. Connectors belong to your account, not your device, so what your account can use on the web is what the desktop app shows. A server running on the same machine as the app will not connect by itself, because ChatGPT talks to servers it can reach over HTTPS from OpenAI's side, not to processes on your hard drive.
How Claude Desktop differs
| ChatGPT, web and desktop | Claude Desktop |
|---|
| Local stdio servers | Not launched by the app, use the tunnel | Launched from a local config file |
| Remote servers | HTTPS, streamable HTTP or SSE | Supported as remote connectors |
| Where servers are defined | Your account or workspace | Your device, plus account connectors |
| Effort for a stdio server | Needs a tunnel or a hosted copy | Add it to the config and restart the app |
The practical lesson is simple: a tutorial that says "paste this JSON into your config" was written for Claude Desktop, and it will not work in ChatGPT as written.
If you want that same server in ChatGPT, you have three realistic routes:
- Host it remotely behind HTTPS and add it as a custom server
- Run the Secure MCP Tunnel and keep the server on your machine
- Stay in Claude Desktop for local-only tools and use ChatGPT for everything else
Remote Servers and Local Tunnels

What a remote server needs
- A public HTTPS address that ChatGPT can reach
- A transport ChatGPT speaks: streamable HTTP, usually at
/mcp, or SSE
- An authentication choice: OAuth, none, or mixed
- Tool names and descriptions written for a model, not for a human reader
If you pick OAuth, watch for one known snag. Some identity providers do not issue refresh tokens unless the offline_access scope is requested, and the connection then fails once the first token expires. Check that scope before blaming ChatGPT.
Secure MCP Tunnel explained

Many MCP servers in the wild ship only a stdio transport, which is why so many tutorials work in Claude Desktop and fail in ChatGPT. OpenAI's answer, announced on May 27, 2026, is the Secure MCP Tunnel.
A small client called tunnel-client runs inside your network or on your own machine and opens an outbound HTTPS connection to OpenAI. It long-polls for queued MCP requests, forwards the JSON-RPC to your private server (a local stdio process or an internal HTTP service) and posts the answers back. No inbound port opens, and no public URL is needed. The same tunneled server can serve ChatGPT, Codex and the Responses API.
The setup order looks like this:
- Run your MCP server locally, over stdio or HTTP.
- Start the tunnel client and point it at that server.
- In ChatGPT's developer settings, add a custom MCP server, give it a name and description, and choose the tunnel as the connection method.
- Configure authentication, create the connection and review the tools ChatGPT finds on your server.
- Disable any tool you do not need before you start chatting.
💡 The pages I found do not say which plans include the tunnel. Check your own workspace settings before you build around it.
Use GPT Models on PicassoIA
If your real goal is to use OpenAI models without configuring a single connector, PicassoIA hosts several of them in the browser:
PicassoIA also has a developer API at https://api.picassoia.com/v1 with bearer token authentication and Replicate style endpoints: you create a prediction, poll it, then fetch the result. The API and the MCP connection expose four models: PicassoIA Image, PicassoIA Image Editor Pro, PicassoIA Video and Seedance 2.5 Lite. Each account can run 5 predictions at once, shared across tokens and MCP connections. MCP connections are managed from your PicassoIA account page.
💡 Whether a given client can use that MCP connection depends on the client's own rules, which is the whole point of the sections above. Check your ChatGPT plan's developer mode before you build a workflow around it, and check PicassoIA's pricing page for what your plan includes.
How to Use GPT 5.6 Terra
Here is a task that ties back to this article: writing a better tool description for your own MCP server.
- Open the GPT 5.6 Terra page.
- In the prompt field, describe the job: "Write a tool description for an MCP server that searches my support docs. Keep it under 60 words and say when the model should not call it."
- Fill the system prompt to fix the role, for example "You are a technical writer for developer documentation."
- Leave reasoning effort on
none for quick drafts. Raise it to medium or high for tricky planning, and raise max completion tokens at the same time, because reasoning can use up the whole budget and leave an empty answer.
- Set verbosity to
low for tight copy or high for longer explanations.
- Attach a screenshot through image input if you want the model to read an error dialog.
- Run it, then keep a running thread through the messages field to refine the draft.
💡 Tool descriptions are read by a model, so test them the same way: ask GPT 5.6 Terra which of two descriptions would make it call the tool, then keep the clearer one.
Make Your Own Images Next

Protocols are the plumbing. The fun part of any AI setup is what comes out of it. Picasso IA puts image and video models in one place, with no connector to configure and no server to host.
Start small. Take one sentence from your own project and turn it into a photo with PicassoIA Image. Fix a detail you do not like with PicassoIA Image Editor Pro. Then bring the still to life with PicassoIA Video or Seedance 2.5 Lite.
Every image in this article started as a written prompt, and yours can too. Browse the full catalog at picassoia.com/en/all-models, pick a model, and run your first prompt today.