Skip to main content
Glama

Strapi MCP Server

AI-powered content management for Strapi CMS via Model Context Protocol.

PyPI version License: MIT Python 3.11+

Features

Connect any MCP-compatible AI assistant (Claude, Cursor, etc.) to your Strapi CMS. Manage content, media, locales, and more through natural language.

20 Tools across 8 categories

Category

Tools

Description

Schema (3)

list_content_types, get_content_type_schema, get_components

Discover and inspect content models

Content (5)

list_entries, get_entry, create_entry, update_entry, delete_entry

Full CRUD for any content type

Media (3)

upload_media, list_media, delete_media

Upload, browse, and manage media library

Publish (3)

publish_entry, unpublish_entry, discard_draft

Control publication lifecycle

i18n (2)

list_locales, get_localized_entry

Internationalization support

Search (2)

search_entries, count_entries

Full-text search and counting

Bulk (1)

bulk_action

Batch create, update, or delete

System (1)

get_strapi_info

Server info and version detection

Additional MCP capabilities

  • 3 Prompts: manage_content, content_migration, setup_guide -- guided workflows for common tasks

  • 1 Resource: strapi://help -- comprehensive usage guide with examples

Related MCP server: Strapi MCP Server

Quick Start

  1. Install the server:

    pip install strapi-mcp
  2. Configure your Strapi connection:

    export STRAPI_BASE_URL="http://localhost:1337"
    export STRAPI_API_TOKEN="your-strapi-api-token"
  3. Connect from your MCP client (see Client Configuration below).

Installation

Using pip

pip install strapi-mcp

Using uvx (no install required)

uvx strapi-mcp

From source

git clone https://github.com/alexzimmermann/strapi-mcp.git
cd strapi-mcp
pip install -e .

Configuration

All settings are configured via environment variables with the STRAPI_ prefix:

Variable

Default

Description

STRAPI_BASE_URL

http://localhost:1337

URL of your Strapi instance

STRAPI_API_TOKEN

(empty)

API token for authentication. Create in Strapi Admin > Settings > API Tokens.

STRAPI_API_VERSION

auto

Strapi version: auto, v4, or v5

STRAPI_TIMEOUT

30

HTTP request timeout in seconds

STRAPI_MAX_PAGE_SIZE

100

Maximum entries per page (1-100)

You can also place these in a .env file in your working directory.

Creating a Strapi API Token

  1. Open your Strapi Admin panel (e.g., http://localhost:1337/admin)

  2. Navigate to Settings > API Tokens

  3. Click Create new API Token

  4. Set Token type to Full Access (or customize permissions)

  5. Copy the generated token and set it as STRAPI_API_TOKEN

Client Configuration

Claude Desktop

Add to your Claude Desktop config file (claude_desktop_config.json):

{
  "mcpServers": {
    "strapi": {
      "command": "uvx",
      "args": ["strapi-mcp"],
      "env": {
        "STRAPI_BASE_URL": "http://localhost:1337",
        "STRAPI_API_TOKEN": "your-strapi-api-token"
      }
    }
  }
}

Cursor

Add to your Cursor MCP config:

{
  "mcpServers": {
    "strapi": {
      "command": "uvx",
      "args": ["strapi-mcp"],
      "env": {
        "STRAPI_BASE_URL": "http://localhost:1337",
        "STRAPI_API_TOKEN": "your-strapi-api-token"
      }
    }
  }
}

Smithery

This server is available on Smithery. Install directly from the Smithery registry or configure manually using the smithery.yaml included in this repository.

Available Tools

Tool

Description

list_content_types

List all available content types in the Strapi instance

get_content_type_schema

Get the full field schema for a specific content type

get_components

List all reusable components and their schemas

list_entries

List entries with filtering, sorting, pagination, and population

get_entry

Get a single entry by ID (or documentId in v5)

create_entry

Create a new content entry with field data

update_entry

Update an existing entry by ID

delete_entry

Delete an entry by ID

upload_media

Upload a file to the media library (URL or base64)

list_media

Browse the media library with pagination

delete_media

Delete a file from the media library

publish_entry

Publish a draft entry to make it publicly available

unpublish_entry

Revert a published entry to draft status

discard_draft

Discard unsaved draft changes (Strapi v5 only)

list_locales

List all configured locales for i18n

get_localized_entry

Get an entry in a specific locale

search_entries

Full-text search across entries of a content type

count_entries

Count entries matching optional filter criteria

bulk_action

Perform bulk create, update, or delete operations

get_strapi_info

Get Strapi server info, version, and connection status

Strapi Version Support

This server supports both Strapi v4 and Strapi v5 with automatic version detection.

Auto-detection

When STRAPI_API_VERSION is set to auto (the default), the server detects your Strapi version at startup by:

  1. Fetching a content type entry and inspecting its response format

  2. Checking the admin information endpoint for a version string

  3. Defaulting to v5 if detection is inconclusive

Key differences handled automatically

Feature

Strapi v4

Strapi v5

Entry format

Nested data.attributes

Flat with documentId

Entry identifier

Numeric id

String documentId

Publication status

publicationState=live|preview

status=published|draft

Draft discard

Not available

discard_draft tool

You can force a specific version by setting STRAPI_API_VERSION=v4 or STRAPI_API_VERSION=v5.

Development

Setup

git clone https://github.com/alexzimmermann/strapi-mcp.git
cd strapi-mcp
python -m venv .venv
source .venv/bin/activate  # or .venv\Scripts\activate on Windows
pip install -e ".[dev]"

Running tests

pytest

Running with coverage

pytest --cov=strapi_mcp --cov-report=term-missing

Code style

ruff check .
ruff format .

License

MIT License. See LICENSE for details.

Available Tools

20 tools
bulk_actionA

Execute a bulk operation (create, update, delete, publish, or unpublish) on multiple content entries. Processes each entry sequentially with per-entry error handling so individual failures do not abort the entire batch. Returns a detailed summary showing successes, failures, and error messages for each entry. Use this for batch imports, migrations, or mass status changes.

Inputs: action (required), entries (required), content_type (required). Returns: result

count_entriesA
Read-only

Count the total number of entries in a content type, optionally filtered by criteria. Makes a lightweight API call that only requests pagination metadata to get the total count efficiently. Use this to understand dataset sizes before bulk operations or to verify migration completeness.

Inputs: content_type (required), locale, status, filters. Returns: result

create_entryA

Create a new content entry in the specified Strapi content type. Accepts a JSON string with field values that match the content type schema. Use get_content_type_schema first to understand which fields are required and their expected types before calling this tool.

Inputs: data (required), content_type (required), locale, status. Returns: result

delete_entryA
Destructive

Permanently delete a content entry by its ID from the specified content type. This action is irreversible and will remove the entry and its associated data. Use get_entry first to verify you are deleting the correct entry. If a locale is specified, only that localization is removed.

Inputs: entry_id (required), content_type (required), locale. Returns: result

delete_mediaA
Destructive

Permanently delete a file from the Strapi media library by its ID. This removes the file from storage and breaks any references to it in content entries. Use list_media first to find the correct file ID before deleting. This action cannot be undone.

Inputs: file_id (required). Returns: result

discard_draftA
Destructive

Discard unsaved draft changes on a content entry, reverting to the last published version. This is only available on Strapi v5 which has a separate draft layer. On Strapi v4, this operation is not supported and will return an error. Use this when you want to abandon draft edits without affecting the currently published version.

Inputs: entry_id (required), content_type (required), locale. Returns: result

get_componentsA
Read-only

List all reusable components defined in the Strapi instance. Components are shared field groups that can be embedded in multiple content types (e.g., SEO metadata, address blocks). Use this to understand available components before referencing them in content type schemas or entry data.

Inputs: no named parameters. Returns: result

get_content_type_schemaA
Read-only

Retrieve the detailed field schema for a specific Strapi content type. Returns all field definitions including types, required status, and relations, formatted as a readable list. Use this before creating or updating entries to understand the expected data structure and required fields.

Inputs: content_type (required). Returns: result

get_entryA
Read-only

Retrieve a single content entry by its ID with full field and relation data. Returns the complete entry including all populated relations and metadata fields. Use this when you need the full details of a specific entry after finding it via list_entries or search_entries.

Inputs: entry_id (required), content_type (required), locale, populate. Returns: result

get_localized_entryA
Read-only

Retrieve a specific localized version of a content entry by its ID and locale code. Returns the full entry data in the requested language, including all populated relations. Use list_locales first to see available locale codes, then use this to fetch content in a specific language for comparison or translation workflows.

Inputs: locale (required), entry_id (required), content_type (required), populate. Returns: result

get_strapi_infoA
Read-only

Retrieve comprehensive information about the connected Strapi instance including version, plugins, and content types. Performs multiple API calls to detect the Strapi version (v4 or v5), count available content types, list installed plugins, and check configured locales. Use this as the first tool call when connecting to a new Strapi instance to understand its configuration and capabilities.

Inputs: no named parameters. Returns: result

list_content_typesA
Read-only

List all user-defined content types registered in the Strapi instance. Fetches content types from the Content-Type Builder API and filters to only include those in the 'api::' namespace (i.e., user-created types). Use this as a first step to discover what content is available before querying entries.

Inputs: no named parameters. Returns: result

list_entriesA
Read-only

List content entries from a Strapi content type with full pagination, sorting, and filtering support. Returns entries formatted as a readable markdown list with metadata and pagination info. Use this to browse and explore content, applying filters and sort orders as needed. Call list_content_types first if you are unsure which content types are available.

Inputs: content_type (required), page, sort, fields, +5 more. Returns: result

list_localesA
Read-only

List all locales configured in the Strapi i18n plugin with their codes and display names. Returns each locale's code, display name, and whether it is the default locale. Use this to discover available languages before creating or querying localized content entries.

Inputs: no named parameters. Returns: result

list_mediaA
Read-only

List files in the Strapi media library with pagination support. Returns file details including name, URL, type, dimensions, and metadata for each media asset. Use this to browse available files before linking them to content entries or to find files for deletion.

Inputs: page, page_size. Returns: result

publish_entryA

Publish a draft content entry to make it publicly visible via the Strapi API. On Strapi v5, uses the dedicated publish action endpoint; on v4, sets the publishedAt timestamp. Use list_entries with status='draft' to find unpublished entries that need publishing.

Inputs: entry_id (required), content_type (required), locale. Returns: result

search_entriesA
Read-only

Search for content entries matching a text query within a specific content type. Uses case-insensitive containment filters ($containsi) on string fields to find matching entries. Specify search_fields to narrow the search to specific fields, or leave it empty to search common text fields like title, name, and description.

Inputs: query (required), content_type (required), page, page_size, +1 more. Returns: result

unpublish_entryA

Unpublish a live content entry, reverting it to draft status so it is no longer publicly visible. On Strapi v5, uses the dedicated unpublish action endpoint; on v4, sets publishedAt to null. The entry data is preserved and can be re-published later with publish_entry.

Inputs: entry_id (required), content_type (required), locale. Returns: result

update_entryA

Update an existing content entry by its ID with partial or full field data. Only the fields included in the data JSON will be modified; other fields remain unchanged. Use get_entry first to see the current values, then provide only the fields you want to change.

Inputs: data (required), entry_id (required), content_type (required), locale. Returns: result

upload_mediaA

Upload a file to the Strapi media library from a URL or base64-encoded data. Supports images, documents, videos, and any file type allowed by Strapi. Provide either a public file_url or base64 content along with a descriptive file name. The uploaded file can then be linked to content entries via relation fields.

Inputs: caption, alt_text, file_url, file_name, +1 more. Returns: result

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

Loading tool schema changelog…

    TDQS

    A4.4/5.0

    Scored across 20 tools

    Disambiguation5/5

    Every tool targets a distinct aspect of Strapi CMS: content entries, media, locales, schemas, bulk operations, etc. No two tools have overlapping purposes; even similar ones like get_entry and get_localized_entry are clearly differentiated by locale.

    Naming Consistency5/5

    All tool names follow a consistent verb_noun pattern using lowercase snake_case (e.g., create_entry, delete_media, list_content_types). This predictability makes it easy for an agent to infer functionality from names.

    Tool Count5/5

    With 20 tools, the server covers the full spectrum of Strapi operations—CRUD, media management, localization, schema inspection, bulk actions—without being overly numerous or sparse. Each tool serves a clear purpose.

    Completeness5/5

    The tool surface is comprehensive: full lifecycle for entries (create, read, update, delete, publish, unpublish, draft discard), media (upload, list, delete), locale support, schema discovery, and even bulk operations. No obvious gaps for typical CMS workflows.

    Maintenance

    ActivityInactive
    ResponsivenessNo recent community issues

    Related MCP Connectors

    Related MCP Servers