Headless CMS MCP servers: where each one stops a write on read-only access
Six headless CMS MCP servers, one question: on the narrowest access, what stops a write? Cmssy tested by us, the others per their own docs (Nov 2026).
"This connection is read-only. Reconnect the app with read and write access to change content."
That's what our server answers when an agent on a read-only Cmssy connection tries to change anything. It comes from the server, before the change runs, whatever the prompt said. We wanted to know where every other headless CMS MCP server draws the same line, so we wrote one probe, ran it on ours, and read each vendor's docs for where the same request should stop.
Disclosure: we build Cmssy, one of the six. Only the Cmssy result below is something we ran and recorded. Everything about the other five comes from each vendor's own MCP docs, checked 20 November 2026; the links are at the end. If you run the probe and see something different, tell us and we'll correct the post.
The probe
- Create one entry or page called MCP probe.
- Connect the agent (Claude Code) with the narrowest access the vendor offers for content: a read-only mode if there is one, otherwise a token or key whose role can only read.
- Ask:
Rename the entry "MCP probe" to "MCP probe - written".
- Note who stops it, and how: the tool never appears, the server rejects the call, the content API refuses the token, the client asks first, or nobody.
Who stops it is what we compare. All six can be locked down; they differ in where the lock sits, and that decides what you configure and what you trust.

Choose by where you want the stop
- Choose Strapi or Payload if you run your own servers and want a narrow token to make write tools disappear. The agent can't call what it can't see.
- Choose Contentful's hosted server if an admin, not each developer, should decide per environment which tool categories are read-only.
- Choose Sanity if the agent should work on schemas and datasets too, and drafts-by-default is the safety you want on content.
- Choose Storyblok if you want deletes to need an explicit confirmation from the user.
- Choose Cmssy if the agent should run a store as well as pages, and you want the read-only decision made once, at sign-in, for that one connection.
- Already on one of these? Use its server. Moving CMS for MCP alone rarely pays.
Where each server should stop it (per vendor docs, checked Nov 2026)
| CMS | Narrowest access for the probe | Where the write should stop | Server runs |
|---|---|---|---|
| Sanity | Token whose role can't write | Content API refuses (role); no separate read-only mode in the docs | Hosted, mcp.sanity.io |
| Contentful (hosted) | Admin sets "entries" to read-only for the environment | Server rejects the call: disabled tools are rejected even if called directly | Hosted, mcp.contentful.com |
| Contentful (local) | Management token | Token permissions only; no per-tool layer | Your machine |
| Storyblok | Token limited to one space and minimal permissions | Management API refuses (permissions); deletes need user confirmation | Hosted, mcp.storyblok.com |
| Cmssy (tested by us) | Hosted connection granted read only | Server refuses before the change runs | Hosted api.cmssy.io/mcp, or npm |
| Strapi | Admin token without update on the type | The update tool isn't exposed at all | Your Strapi server, 5.47.0+ |
| Payload | API key with only find on the collection |
Write operations disabled for that key | Inside your Payload app |
Sanity: the role behind the token decides
According to Sanity's docs, its server is hosted at mcp.sanity.io and signs you in with OAuth by default, or takes an API token; with a token, tool calls are limited to that token's role and permissions. The docs don't describe a separate read-only mode for the connection, so for the probe you'd create a token with a role that can't write, and the refusal should come from Sanity's API.
The docs also describe a second soft guard on content: document patches go to the draft or a release version, never straight to published content, and publishing is its own tool (publish_documents). So even a write-capable agent shouldn't change the live site until something publishes.
Where Sanity is ahead: per the docs, the agent can read and deploy schemas, manage datasets and create projects. If you want the agent to change your content model, not only your content, no other server here goes that far.
Contentful: an admin allow-list per environment
According to Contentful's docs, there are two servers. The hosted one at mcp.contentful.com uses OAuth 2.1 and adds a layer the others don't have: an admin opens the MCP app's settings for each environment and sets tool categories (entries, assets, content types, environments, AI Actions) to read-only or read/write. The docs say disabled tools are rejected even if a client tries to call them directly. So with entries set to read-only in the environment, the rename should be rejected by the server.
The local, open-source server is different: per the same docs it authenticates with a Management API token and does whatever the token allows, with no per-environment gate.
Where Contentful is ahead: the decision sits with an admin and is per environment, so staging can be read/write while production stays read-only, for every developer at once.
Storyblok: separate tools, and deletes ask first
According to Storyblok's docs, its server is hosted at mcp.storyblok.com/mcp and exposes the Management API only, so it can't read published content through the Delivery API. It splits work into three tools: execute_readonly for GET, execute_mutating for POST, PUT and PATCH, and execute_destructive for DELETE, and the destructive tool requires explicit confirmation from the user.
Storyblok recommends limiting the connection to the spaces and permissions the client needs. We found no dedicated read-only mode for the connection in the docs, so the rename would go to execute_mutating, and what should stop it is the permission set behind the token.
Where Storyblok is ahead: the delete confirmation.
Cmssy (ours): read-only chosen at sign-in, enforced on the server
This is the one we ran. The hosted endpoint is https://api.cmssy.io/mcp. You sign in in the browser, tick which workspaces the connection can reach, and choose read only or read and write for that connection. On a read-only connection every change is refused on the server before it runs. The npm package (@cmssy/mcp-server) uses an API token instead, and the token acts with your role.

On the probe, the agent calls the update tool and gets the message at the top of this post. We also tried a store write, refund_order, on the same connection: same refusal. Reconnected with write access, the same call went through.
Where Cmssy is behind: on a write-capable connection the server has no confirmation step of its own, so approval is your client's job. Claude Code asks before any tool you haven't allowlisted; the other limits on a Cmssy agent are written up in what an agent can run in a store. The Cmssy service is also closed source and hosted only, so if you want to run the server yourself, Strapi and Payload are the honest picks.
Strapi: tools you can't use don't exist
According to Strapi's docs, Strapi 5.47.0 and later has a built-in MCP server, off by default (mcp.enabled is false). It authenticates with Admin tokens, and the token's permissions decide which tools the client sees at all: a token without delete on Article never sees delete_article. Inside an exposed tool, the input and output schemas are narrowed to the fields the token can access. So with a token that can't update the type, the rename tool shouldn't be there at all.
The docs list limits worth knowing: the server can't upload new files, and list and get tools don't support nested population for relations.
Payload: per-key switches, inside your app
According to Payload's docs, its official MCP plugin runs inside your Payload app at /api/mcp. Every request needs an API key as a Bearer token, and enabling a collection in the plugin config doesn't make it reachable on its own: each key turns find, create, update and delete on or off per collection. Requests act as the key's owner, and Payload's own access control still applies. So a key with only find on the collection shouldn't be able to run the update.
Where Payload is ahead: everything lives in your repo and your database, and you can write your own tools, prompts and resources next to the generated ones.
What the probe doesn't test
- Deletes on a write-capable connection. Only Storyblok documents a confirmation for those.
- Prompt injection. A narrow connection limits the damage of a hostile instruction in content; it doesn't detect one.
- Anything beyond content. Cmssy's server also covers orders, refunds, discounts, price lists and customers, which is why we care so much about the read-only stop. A content-only server doesn't need it as badly.
Run it on your own stack
Copy this into your agent after you connect it with the narrowest access you have:
List the entries you can see, then rename "MCP probe" to
"MCP probe - written". If you can't, tell me exactly which
tool or error stopped you.
The answer tells you whether the stop was a missing tool, a server rejection or an API permission error.
If you're connecting Claude Code to Cmssy for the first time, the setup tutorial covers both sign-in and token setups, and the reference is in the MCP server docs.
Sources (checked 20 Nov 2026)
- Sanity MCP server: https://www.sanity.io/docs/ai/mcp-server
- Contentful MCP server: https://www.contentful.com/developers/docs/tools/mcp-server
- Storyblok MCP server: https://www.storyblok.com/docs/libraries/mcp-server
- Strapi MCP server: https://docs.strapi.io/cms/features/strapi-mcp-server
- Payload MCP plugin: https://payloadcms.com/docs/plugins/mcp
- Cmssy MCP server: /docs/api/mcp