by ivo-toby
Provides full integration with the Contentful Management API via the Model Context Protocol, enabling CRUD operations on entries, assets, spaces, comments, and bulk actions while handling pagination and supporting both stdio and StreamableHTTP transports.
The server acts as a bridge between LLM agents and Contentful's Management API, exposing a rich set of tools for creating, reading, updating, deleting, publishing, and managing content, assets, spaces, environments, and comments. It also includes bulk operations and smart pagination to keep LLM context windows efficient.
npx
:
npx -y @ivotoby/contentful-management-mcp-server --management-token <YOUR_TOKEN>
Add --http
and --port <PORT>
if you need the StreamableHTTP transport.CONTENTFUL_MANAGEMENT_ACCESS_TOKEN
, optionally SPACE_ID
and ENVIRONMENT_ID
).search_entries
, create_comment
, bulk_publish
, etc., following the tool signatures described in the README.Q: Do I need to clone the repository to use the server?
A: No. You can run it directly with npx
or install via Smithery for Claude Desktop.
Q: Which transport should I choose?
A: Use stdio for most LLM clients (default). Choose StreamableHTTP (--http
) when you need a persistent HTTP endpoint.
Q: How does pagination work?
A: List calls return up to three items along with total count, remaining items, and a skip
value for the next page. The LLM can request the next page as needed.
Q: Can I limit the server to a specific space/environment?
A: Yes. Set SPACE_ID
and ENVIRONMENT_ID
via environment variables or command‑line arguments; the server will enforce those scopes.
Q: What authentication methods are supported?
A: A Content Management API token or App Identity (using --app-id
, --private-key
, --space-id
, and --environment-id
).
Q: Is this officially supported by Contentful? A: It is community‑driven and not officially supported by Contentful at the time of writing.
This is a community driven server! Contentful has released an official server which you can find here
An MCP server implementation that integrates with Contentful's Content Management API, providing comprehensive content management capabilities.
To prevent context window overflow in LLMs, list operations (like search_entries and list_assets) are limited to 3 items per request. Each response includes:
This pagination system allows the LLM to efficiently handle large datasets while maintaining context window limits.
The bulk operations feature provides efficient management of multiple content items simultaneously:
These bulk operation tools are ideal for content migrations, mass updates, or batch publishing workflows.
Comments support threading functionality to enable structured conversations and work around the 512-character limit:
parent
parameter in create_comment
to reply to an existing commentExample usage:
create_comment
with entryId
, body
, and status
create_comment
with entryId
, body
, status
, and parent
(the ID of the comment you're replying to)parent
The project includes an MCP Inspector tool that helps with development and debugging:
npm run inspect
to start the inspector, you can open the inspector by going to http://localhost:5173npm run inspect:watch
to automatically restart the inspector when files changeThe project also contains a npm run dev
command which rebuilds and reloads the MCP server on every change.
These variables can also be set as arguments
CONTENTFUL_HOST
/ --host
: Contentful Management API Endpoint (defaults to https://api.contentful.com)CONTENTFUL_MANAGEMENT_ACCESS_TOKEN
/ --management-token
: Your Content Management API tokenENABLE_HTTP_SERVER
/ --http
: Set to "true" to enable HTTP/SSE modeHTTP_PORT
/ --port
: Port for HTTP server (default: 3000)HTTP_HOST
/ --http-host
: Host for HTTP server (default: localhost)You can scope the spaceId and EnvironmentId to ensure the LLM will only do operations on the defined space/env ID's.
This is mainly to support agents that are to operate within specific spaces. If both SPACE_ID
and ENVIRONMENT_ID
env-vars are set
the tools will not report needing these values and the handlers will use the environment vars to do CMA operations.
You will also loose access to the tools in the space-handler, since these tools are across spaces.
You can also add the SPACE_ID
and ENVIRONMENT_ID
by using arguments --space-id
and --environment-id
Instead of providing a Management token you can also leverage App Identity for handling authentication. You would have to setup and install a Contentful App and set the following parameters when calling the MCP-server:
--app-id
= the app Id which is providing the Apptoken--private-key
= the private key you created in the user-interface with your app, tied to app_id
--space-id
= the spaceId in which the app is installed--environment-id
= the environmentId (within the space) in which the app is installed.With these values the MCP server will request a temporary AppToken to do content operation in the defined space/environment-id. This especially useful when using this MCP server in backend systems that act as MCP-client (like chat-agents)
You do not need to clone this repo to use this MCP, you can simply add it to
your claude_desktop_config.json
:
Add or edit ~/Library/Application Support/Claude/claude_desktop_config.json
and add the following lines:
{
"mcpServers": {
"contentful": {
"command": "npx",
"args": ["-y", "@ivotoby/contentful-management-mcp-server"],
"env": {
"CONTENTFUL_MANAGEMENT_ACCESS_TOKEN": "<Your CMA token>"
}
}
}
}
If your MCPClient does not support setting environment variables you can also set the management token using an argument like this:
{
"mcpServers": {
"contentful": {
"command": "npx",
"args": [
"-y",
"@ivotoby/contentful-management-mcp-server",
"--management-token",
"<your token>",
"--host",
"http://api.contentful.com"
]
}
}
}
To install Contentful Management Server for Claude Desktop automatically via Smithery:
npx -y @smithery/cli install @ivotoby/contentful-management-mcp-server --client claude
If you want to contribute and test what Claude does with your contributions;
npm run dev
, this will start the watcher that rebuilds the MCP server on every changeclaude_desktop_config.json
to reference the project directly, ie;{
"mcpServers": {
"contentful": {
"command": "node",
"args": ["/Users/ivo/workspace/contentful-mcp/bin/mcp-server.js"],
"env": {
"CONTENTFUL_MANAGEMENT_ACCESS_TOKEN": "<Your CMA Token>"
}
}
}
}
This will allow you to test any modification in the MCP server with Claude directly, however; if you add new tools/resources you will need to restart Claude Desktop
The MCP server supports two transport modes:
The default transport mode uses standard input/output streams for communication. This is ideal for integration with MCP clients that support stdio transport, like Claude Desktop.
To use stdio mode, simply run the server without the --http
flag:
npx -y contentful-mcp --management-token YOUR_TOKEN
# or alternatively
npx -y @ivotoby/contentful-management-mcp-server --management-token YOUR_TOKEN
The server also supports the StreamableHTTP transport as defined in the MCP protocol. This mode is useful for web-based integrations or when running the server as a standalone service.
To use StreamableHTTP mode, run with the --http
flag:
npx -y contentful-mcp --management-token YOUR_TOKEN --http --port 3000
# or alternatively
npx -y @ivotoby/contentful-management-mcp-server --management-token YOUR_TOKEN --http --port 3000
The implementation follows the standard MCP protocol specification, allowing any MCP client to connect to the server without special handling.
The server implements comprehensive error handling for:
MIT License
This MCP Server enables Claude (or other agents that can consume MCP resources) to update, delete content, spaces and content-models. So be sure what you allow Claude to do with your Contentful spaces!
This MCP-server is not officially supported by Contentful (yet)
Please log in to share your review and rating for this MCP.
{ "mcpServers": { "contentful": { "command": "npx", "args": [ "-y", "@ivotoby/contentful-management-mcp-server" ], "env": { "CONTENTFUL_MANAGEMENT_ACCESS_TOKEN": "<YOUR_MANAGEMENT_TOKEN>" } } } }
Discover more MCP servers with similar functionality and use cases
by MFYDev
Ghost-MCP is a Model Context Protocol (MCP) server that enables interaction with Ghost CMS through Large Language Model (LLM) interfaces like Claude. It allows users to manage their Ghost blog by simply using natural language commands via an LLM.
by devhub
Enables LLMs to manage businesses, locations, blog posts, and media within DevHub CMS through the Model Context Protocol.
by universal-mcp
Hashnode Universal MCP Server provides a standardized interface for interacting with Hashnode's tools and services through a unified API. It enables programmatic content management, automated publishing, and seamless third-party integrations with Hashnode.
by netdata
Real-time, per‑second infrastructure monitoring platform that provides instant insights, auto‑discovery, edge‑based machine‑learning anomaly detection, and lightweight visualizations without requiring complex configuration.
by zed-industries
Provides real-time collaborative editing powered by Rust, enabling developers to edit code instantly across machines with a responsive, GPU-accelerated UI.
by github
Enables AI agents, assistants, and chatbots to interact with GitHub via natural‑language commands, providing read‑write access to repositories, issues, pull requests, workflows, security data and team activity.
by daytonaio
Provides a secure, elastic sandbox environment for executing AI‑generated code with isolated runtimes and sub‑90 ms provisioning.
by RooCodeInc
An autonomous coding agent that lives inside VS Code, capable of generating, refactoring, debugging code, managing files, running terminal commands, controlling a browser, and adapting its behavior through custom modes and instructions.
by chaitin
Provides a self‑hosted web application firewall and reverse‑proxy that filters, monitors, and blocks malicious HTTP/S traffic, protecting web applications from attacks such as SQL injection, XSS, brute‑force, bot abuse, and various code injections.