How to Set Up a Cursor MCP Server With Strapi

Strapi 5 is an open-source headless content management system (CMS) with a built-in MCP server for Cursor IDE.

A Cursor MCP server removes a common source of context switching: every trip to the Strapi Admin Panel to inspect or change content breaks the flow you were in. With Cursor MCP support and Strapi’s built-in Model Context Protocol server, you can create, list, update, and publish content from the same chat window where you write code. Strapi 5.47.0 shipped this as a native feature, so there’s no third-party wrapper to install or maintain.

In brief:

• Strapi 5.47.0 or later includes a built-in MCP server, free on all plans, turned on with one config key and reachable at /mcp.
• Authentication uses Admin tokens. Content API tokens are rejected at /mcp, and token permissions decide exactly which tools Cursor sees.
• Cursor connects through a small .cursor/mcp.json block using the streamable-http transport and a Bearer header.
• Collection Types expose up to eight content tools, Single Types up to six, and you drive them all with plain-language prompts.

What Is a Cursor MCP Server?

The Model Context Protocol (MCP) is an open-source standard for connecting AI applications to external systems such as data sources and tools. It also connects them to workflows. The official MCP docs describe it as “a USB-C port for AI applications”: a standard MCP interface for plugging an AI client into outside systems, supported across Claude, ChatGPT, Visual Studio Code, and Cursor.

According to the MCP tool specification, an MCP server sits on the other end of that port. It exposes tools, which are functions the AI model can execute against your systems, each identified by name with a schema describing its inputs.

In a Cursor MCP setup, the server tells Cursor’s agent what it can do, and the agent decides when to call those tools based on your prompts. Strapi’s implementation exposes your content operations this way, so the agent in Cursor can read and write entries in a running Strapi instance. The Strapi MCP server docs are the primary reference for everything that follows.

How Cursor Uses MCP Servers

Cursor reads MCP server definitions from a JSON config file under a top-level "mcpServers" key, either project-specific (.cursor/mcp.json) or global (~/.cursor/mcp.json). At request time, the tool discovery protocol lets the client discover available tools with a tools/list request (JSON-RPC 2.0). The client invokes them with tools/call; each request includes the tool name and arguments.

You stay in the loop. According to the Cursor MCP documentation, Cursor asks for approval before using MCP tools by default, and you can click the arrow next to a tool name to inspect its arguments before approving. Tools listed under Available Tools are used automatically when relevant, including in Plan Mode, and tool responses appear in chat with expandable views of arguments and results.

Why Use Strapi’s Built-In MCP Server

Strapi ships a first-party MCP server built directly into the CMS. There is no separate package to install and no community wrapper to vet or keep patched. The feature arrived as a Beta in 5.47.0 (2026-05-28), reached General Availability in 5.49.0, and costs nothing: no paid plan required.

The security model is the same one your editors already work under. Every MCP session authenticates with an Admin token, and the server exposes only the tools that token’s permissions allow. A read-only token surfaces only listing and reading tools. A full-access token surfaces the complete CRUD and publish surface. Marketplace plugins can also register additional tools through the strapi.ai.mcp service during the register() phase, so the tool surface can grow with your project.

Why Connect Strapi to Cursor IDE

As Strapi’s GA announcement explains, AI coding agents such as Cursor, Copilot, and Claude previously had no way to read or write content in a running Strapi instance. The MCP server closes that gap natively.

For a full-stack developer, the payoff is that schema work and content work happen in one window. You scaffold a Content-Type in code, then seed test data and verify the results through prompts in the same chat, without opening the Admin Panel or writing a one-off seed script. Strapi’s AI content workflow guide covers scaffolding Content-Types and seeding test data. It also covers refactoring schemas from plain-language prompts without leaving the editor.

Multi-step workflows chain naturally too. Strapi’s MCP explainer walks through an agent querying available Content-Types and schemas, invoking create with parameters matching the schema, receiving the documentId, then invoking update or publish, with MCP maintaining context about which content item it’s manipulating throughout. And because access is token-scoped, you can run parallel workstreams: one agent reads all content while another can publish only entries it authored.

Prerequisites

• A running Strapi 5 project on 5.47.0 or later. The MCP server is built into Strapi from 5.47.0 onward; earlier versions have no /mcp endpoint at all.
• A Strapi-supported LTS version of Node.js. Strapi 5 targets active Node LTS releases; the MCP docs don’t pin a version for this feature, so Node 20 is a practical baseline.
• A recent version of Cursor installed, since the connection relies on Cursor’s streamable-http MCP transport.
• Admin access to your Strapi project, or a super admin who can grant you permission to create Admin tokens.

How to Set Up Strapi’s MCP Server

Until Strapi is configured to serve MCP and you hold a valid Admin token, nothing you do in Cursor will connect.

Turn On the MCP Server in Server Configuration

The MCP activation setting defaults to false, so the endpoint is off until you turn it on. Add the mcp object to your server configuration:

// config/server.js
module.exports = ({ env }) => ({
  host: env("HOST", "0.0.0.0"),
  port: env.int("PORT", 1337),
  app: {
    keys: env.array("APP_KEYS"),
  },
  mcp: {
    enabled: true,
  },
});

The TypeScript equivalent:

// config/server.ts
import type { Core } from "@strapi/strapi";

const config = ({
  env,
}: Core.Config.Shared.ConfigParams): Core.Config.Server => ({
  host: env("HOST", "0.0.0.0"),
  port: env.int("PORT", 1337),
  app: {
    keys: env.array("APP_KEYS"),
  },
  mcp: {
    enabled: true,
  },
});

export default config;

Restart Strapi and the endpoint comes up at /mcp. For a default local install, that means http://localhost:1337/mcp. Failing to restart Strapi is a common setup issue; the endpoint does not exist until Strapi reloads its config.

Create an Admin Token in the Admin Panel

The MCP server authenticates with Admin tokens. Content API tokens are rejected at /mcp. The two are strictly separated in Strapi 5, and each is rejected on the other’s routes, so a Content API token, whatever its permissions, gets a 401 at /mcp. Head to Settings → Administration Panel → Admin Tokens.

To create the token:

1. Click Create new Admin Token.
2. Fill in the required Name and optional Description. Choose a Token duration of 7 days, 30 days, 90 days, or Unlimited.
3. Define permissions by clicking through the tabs and using the checkboxes. Whatever you check here is exactly what Cursor will be able to see and do. Permissions you don’t hold yourself appear disabled, and conditions applied to your role carry over to the token automatically.
4. Click Save, then copy the token immediately. The plaintext key is shown only once and is never persistently viewable afterward.

The permissions you pick gate the MCP surface at two levels right at connection time. First, tool visibility: if the token doesn’t grant delete on Article, Cursor never sees a delete tool for articles. Second, field filtering: if the token grants read on Article but excludes the body field, the AI client will not see or receive body content, and write schemas only include fields permitted for the corresponding action.

Non-super-admin users need two explicit permissions from a super admin: access to the Admin tokens settings page and the ability to create Admin tokens. Both are configured under Roles → Settings - Admin tokens.

Set Advanced MCP Options (Optional)

Two optional keys in the mcp object tune timeouts: connectTimeoutMs (default 5000) caps how long the internal MCP transport can take to connect before the request is aborted, and requestTimeoutMs (default 60000) caps how long a single MCP request can run.

// config/server.js
module.exports = ({ env }) => ({
  host: env("HOST", "0.0.0.0"),
  port: env.int("PORT", 1337),
  app: {
    keys: env.array("APP_KEYS"),
  },
  mcp: {
    enabled: true,
    connectTimeoutMs: 10000, // 10 seconds
    requestTimeoutMs: 120000, // 2 minutes
  },
});

The defaults work fine for most local setups. Raise requestTimeoutMs for long operations against large collections.

How to Add MCP Server to Cursor

The client-side configuration is a single JSON file that points Cursor at the endpoint you turned on.

Configure Your .cursor/mcp.json File

Create .cursor/mcp.json in your project folder (or ~/.cursor/mcp.json in your home directory if you want the server available across projects) with this block:

{
  "mcpServers": {
    "strapi-mcp": {
      "type": "streamable-http",
      "url": "http://localhost:1337/mcp",
      "headers": {
        "Authorization": "Bearer YOUR_ADMIN_TOKEN"
      }
    }
  }
}

Replace YOUR_ADMIN_TOKEN with the Admin token you copied at creation time. For a non-local Strapi deployment, swap in the full URL while keeping the /mcp path. Cursor’s config also supports interpolation like ${env:NAME}; use it to keep the raw token out of the file. If you commit .cursor/mcp.json so teammates get the same tools, each developer should authenticate with their own least-privilege token rather than a shared secret in version control.

Verify the MCP Server Connection in Cursor

Open Cursor’s MCP settings, where servers can be turned on or off from the Customize sidebar. Confirm that strapi-mcp is active and its tools appear under Available Tools. For that deeper check, open the Output panel (Cmd+Shift+U / Ctrl+Shift+U) and select “MCP Logs” from the dropdown.

Using Strapi’s MCP Tools in Cursor

Once Cursor is connected to your MCP server, your Content-Types appear to the agent as callable tools. The Strapi docs contain the full tool reference.

Available Content Management Tools

Each Collection Type exposes up to eight tools: five for create, read, update, and delete (CRUD) plus three for Draft and Publish actions.

Tool	Permission required	What it does
list	read	List entries with pagination, sorting, and filtering
get	read	Get a single entry by document ID
create	create	Create a new entry (as draft if Draft and Publish is active)
update	update	Update an existing entry by document ID
delete	delete	Delete an entry by document ID
publish	publish	Publish a draft entry
unpublish	publish	Unpublish a published entry
discard_draft	publish	Discard draft changes and revert to the published version

The publish, unpublish, and discard_draft tools are only generated when Draft and Publish is active on the Content-Type.

Single Types expose up to six tools. Each Single Type has one document, so the list tool is unavailable. A single write tool combines create and update; it creates the document if none exists or updates the existing draft otherwise. The set also includes get, delete, publish, unpublish, and discard_draft. In development mode, a built-in log utility tool can also write messages to the Strapi server console at levels like info and warn. It also supports error and requires no specific admin permissions.

In every case, the token filters the list. Cursor only ever sees the subset your Admin token permits.

Managing Content With Natural Language Prompts

You don’t call these tools by name. You describe what you want and the agent maps it. The official prompt examples show the pattern:

Prompt	Tool invoked	Outcome
“Create a new article titled ‘Hello World’ with body ‘First post’.”	create	Creates a draft article (draft because Draft and Publish is active)
“List the five most recent articles.”	list	Returns a paginated list, newest first
“Publish article abc123.”	publish	Changes that entry’s status to published
“Create an article in French with the title ‘Bonjour le monde’.”	create with locale: "fr"	Creates a draft article in the French locale

Updates are surgical: “Update article abc123, change the title to ‘Hello Strapi’.” touches only the title field and leaves everything else untouched. Prompts can also chain with custom tools; Strapi’s plugin extension guide shows a prompt that first calls a custom get_article_authoring_guide tool for format rules, then saves the generated post as a draft, because built-in tools cover Content-Type CRUD only, not custom controllers or workflows.

Configuring Permissions and Security

The MCP server enforces the same permission model as the Strapi Admin Panel, checked at four levels:

1. Tool visibility. At connection time, Strapi exposes only the tools the Admin token’s permissions cover. No publish permission means no publish tool in Cursor’s list.
2. Field filtering. Input and output schemas are narrowed to the fields the token can access, per action, as covered in the token setup above.
3. Locale filtering. With Internationalization (i18n) active and locale-level permissions configured, the locale parameter narrows per action. The docs give the example of a token that might allow reading content in en and fr but only creating content in en. If the default locale is permitted, it applies as the schema default.
4. Runtime enforcement. Each handler calls Strapi’s permission checker at runtime against the specific document being read, written, or published. Condition-based permissions, such as “only update entries you own,” are enforced here.

Create a dedicated Admin token for each AI client or use case and grant only the permissions required for the agent’s job. Useful scopes include read-only tokens, tokens limited to specific Content-Types, tokens restricted to particular fields or locales, and condition-based tokens. Ownership adds a backstop, too. Per the GA announcement, each token’s permissions are automatically re-clamped when its owner’s roles change and revoked the moment the owner is deactivated, so an offboarded teammate’s Cursor setup stops working on its own.

Troubleshooting Common Cursor MCP Server Issues

Most connection failures trace back to a handful of causes:

• Server won’t connect after configuring .cursor/mcp.json. Check, in order: the type field is "streamable-http" (older transport formats won’t work here); the token is an Admin token, since a Content API token returns 401; the placeholder YOUR_ADMIN_TOKEN was actually replaced; Strapi was restarted after adding mcp: { enabled: true }; and Strapi is running at the URL in your config (npm run develop for local development).
• GET or DELETE returns 405. The /mcp endpoint only accepts POST; other HTTP methods return a 405 Method Not Allowed JSON-RPC error. Seeing a 405 usually points at the transport type in your config. The streamable-http type sends POST requests, which is why it’s required.
• Token stopped working out of nowhere. Admin tokens are tied to their owner’s account. If the owner was blocked or deleted, requests authenticated with that token are rejected. Recreate the token under an active account.

Permission changes take effect without a restart. The architecture is stateless: each POST to /mcp creates a fresh, ephemeral MCP server instance scoped to the authenticated token. With no session state to invalidate, revoking a token or editing its permissions takes effect on the very next request.

Known Limitations to Be Aware Of

Strapi 5.50.0 documents these known limitations:

• No media upload through MCP. Media fields accept existing media asset references, but the MCP server cannot upload new files. Use Strapi’s Media Library or upload API to add files first, then reference them in MCP tool calls.
• Dynamic Zones are untyped. Dynamic Zone fields arrive as untyped arrays in tool schemas, with no description of each component’s internal structure. Expect the agent to need more guidance when writing into them.
• No nested population. The list and get tools don’t accept nested population parameters for relations.
• Custom fields can degrade. Plugin-registered custom fields map to their underlying Strapi type, and if the custom field registry isn’t populated when MCP tools are registered, the field falls back to an unknown type.

Sorting is limited to scalar attributes (strings, numbers, booleans, dates, enumerations), so relation, component, Dynamic Zone, media, and JSON fields can’t be sort keys. And an open GitHub issue (#27395), filed against 5.52.0, reports that MCP tools/list advertises draft-07 JSON Schema, which makes tools uncallable from strict 2020-12 clients.

If tool calls never register in a strict client, check issue #27395 before you assume the config is wrong. The feature was Beta in 5.47.0 and reached GA in 5.49.0. Enterprise Audit Logs integration arrived in 5.52.0, so check the release notes before you build anything load-bearing on a current limitation.

Evaluate the Cursor Workflow on a Real Project

Turn on MCP in Strapi and add an authenticated Cursor configuration. Your Content-Types become tools the agent in Cursor can list, create, update, and publish against, all bounded by the exact permissions you granted. For a full-stack developer, that’s the Admin Panel round trip gone from the schema-and-seed loop, with the same permission model your editors rely on still enforcing every call.

Evaluate it on a real project with a read-only token. Spin up a Strapi 5 instance or upgrade an existing one past 5.47.0, turn on the MCP server, and wire it to Cursor, then widen the token’s permissions as you find operations the agent should own. The MCP server documentation covers the full tool and permission reference.