Contentstack MCP Server

A Model Context Protocol (MCP) server for Contentstack. It exposes tools for content management, content delivery, analytics, Launch, Automations, BrandKit, Personalize, Developer Hub, and Lytics.

Features

• Content Management: Entries, assets, content types, taxonomies, terms, branches, releases, publishing, variants, environments, global fields, and entry references.
• Content Management Extended: Audit logs, entry and asset version history, global field writes, asset folder management, and workflow and publish rule inspection.
• Content Delivery: Published entries and assets through Contentstack's CDN.
• Launch: Projects, environments, deploy hooks, deployments, logs, uploads, and CDN cache revalidation.
• Automations: Automation Hub projects, automation inspection, activation controls, and HTTP-triggered workflow runs.
• Analytics: API, CDN, cache, status-code, SDK, device, and URL usage.
• BrandKit AI: Voice profiles, knowledge vault content, and AI generation.
• Personalize: Attributes, audiences, experiences, events, analytics, and geolocation helpers.
• Developer Hub: Marketplace app lifecycle, OAuth settings, and app installations.
• Lytics: Audiences, profiles, content topics, classification, accounts, fields, and tables.
• Flexible query options: Pagination, filtering, sorting, counts, metadata, publish details, and reference inclusion where the underlying API supports them.

API Groups

The MCP server supports multiple API groups that can be used independently or together:

• CMA (Content Management API): Core content management — entries, assets, content types, global fields, branches, releases, publishing, and environments (77 tools)
• CMA Extended: Auditing, version history, asset folder management, global field writes, and workflow inspection — load alongside cma when agents need contextual or administrative capabilities (22 tools)
• CDA (Content Delivery API): Published content delivery via CDN
• Analytics: Usage analytics, performance monitoring, and operational insights
• BrandKit: AI-powered brand management and content generation
• Launch: Deployment platform for hosting and managing Contentstack-powered websites
• Automations: Automation Hub project management, automation discovery, and HTTP-triggered workflow execution
• DeveloperHub: Marketplace app lifecycle management and installations
• Lytics: Advanced analytics and audience insights
• Personalize: Advanced personalization and A/B testing capabilities
• All: Enable all API groups

Context tip: Loading cma alone gives agents the tools they need for everyday content operations. Add cma-extended only when the session requires audit trails, version inspection, or workflow context. Keeping the two separate reduces the tool-definition context sent to the LLM on every turn.

Configuration

Prerequisites

1. Create a Contentstack account at Contentstack

OAuth Setup (Required for CMA, CMA Extended, Analytics, Automations, BrandKit, Launch, DeveloperHub, and Personalize)

Important: Before using Content Management API (CMA or CMA Extended), Analytics, Automations, BrandKit, Launch, DeveloperHub, or Personalize tools, you must authenticate using OAuth:

npx @contentstack/mcp --auth

This command opens the OAuth flow and stores the resulting tokens locally. The selected data center (region) is saved with the session and used for all requests.

Management token instead of OAuth (CMA / CMA Extended / CDA only)

If you cannot use OAuth and only need content tooling, you can authenticate CMA and CMA Extended with a management token instead. Provide the token plus the region your stack lives in (there is no saved OAuth session to infer it from):

npx @contentstack/mcp --groups cma \
  --stack-api-key <STACK_API_KEY> \
  --management-token <MANAGEMENT_TOKEN> \
  --region NA

CDA likewise needs no OAuth — it uses the delivery token. A management token cannot authenticate Analytics, Automations, BrandKit, Launch, DeveloperHub, or Personalize; those still require --auth.

Additional Requirements

1. For CDA access, generate a delivery token for the target environment.
2. For BrandKit, provide your Brand Kit ID.
3. For Launch, provide your Launch Project ID.
4. For Lytics, generate a Lytics access token.
5. For Personalize, provide your Personalize Project ID.

Environment Variables

These variables can also be provided as CLI arguments.

• CONTENTSTACK_API_KEY / --stack-api-key: Your Stack API Key
• CONTENTSTACK_DELIVERY_TOKEN / --delivery-token: Your Stack Delivery token (required only if using CDN/Delivery API tools)
• CONTENTSTACK_MANAGEMENT_TOKEN / --management-token: A Stack management token. An alternative to OAuth for CMA / CMA Extended (see above)
• CONTENTSTACK_REGION / --region: Data center to target — NA, EU, AU, AZURE_NA, AZURE_EU, GCP_NA, GCP_EU (documented aliases such as us, aws-eu also work). Default: NA. With OAuth, the region is taken from the saved session unless overridden here
• CONTENTSTACK_BRAND_KIT_ID / --brand-kit-id: Your Brand Kit ID (required for BrandKit tools)
• CONTENTSTACK_LAUNCH_PROJECT_ID / --launch-project-id: Your Launch Project ID (required for Launch tools)
• LYTICS_ACCESS_TOKEN / --lytics-access-token: Your Lytics access token (required for Lytics tools)
• CONTENTSTACK_PERSONALIZE_PROJECT_ID / --personalize-project-id: Your Personalize Project ID (required for Personalize tools)
• GROUPS / --groups: Comma-separated list of API groups to enable (options: cma, cma-extended, cda, analytics, automations, brandkit, launch, developerhub, lytics, personalize, all. Default: cma)

Dedicated infrastructure (custom endpoints)

Customers on dedicated or private infrastructure can override individual service base URLs. When set, an override fully replaces the region-derived URL for that service (include any path suffix the service expects, e.g. Launch's /manage):

• CONTENTSTACK_CMA_BASE_URL — CMA and CMA Extended
• CONTENTSTACK_CDA_BASE_URL — CDA
• CONTENTSTACK_DEVELOPERHUB_BASE_URL — Developer Hub
• CONTENTSTACK_PERSONALIZE_BASE_URL — Personalize
• CONTENTSTACK_ANALYTICS_BASE_URL — Analytics
• CONTENTSTACK_AUTOMATIONS_BASE_URL — Automations
• CONTENTSTACK_LAUNCH_BASE_URL — Launch
• CONTENTSTACK_BRANDKIT_AI_BASE_URL / CONTENTSTACK_BRANDKIT_API_BASE_URL — BrandKit (AI and brand-kits-api hosts)
• CONTENTSTACK_LYTICS_BASE_URL — Lytics

Regional endpoints are derived from Contentstack's official regions.json, refreshed into src/utils/regions.generated.ts at build time. Run npm run fetch-regions to update it on demand.

Group Requirements Summary

| Group | Authentication | Required Tokens/Configuration | | ---------------- | ------------------------- | ------------------------------------ | | CMA | OAuth or Management Token | Stack API Key | | CMA Extended | OAuth or Management Token | Stack API Key | | CDA | Token-based | Stack API Key + Delivery Token | | Analytics | OAuth | — | | Automations | OAuth | — | | BrandKit | OAuth | Brand Kit ID | | Launch | OAuth | Launch Project ID + Organization UID | | DeveloperHub | OAuth | Stack API Key | | Lytics | Token-based | Lytics Access Token | | Personalize | OAuth | Personalize Project ID |

Usage with Claude Desktop

You can use this MCP server without cloning the repository. Edit ~/Library/Application Support/Claude/claude_desktop_config.json and add a server entry:

{
  "mcpServers": {
    "contentstack": {
      "command": "npx",
      "args": ["-y", "@contentstack/mcp"],
      "env": {
        "CONTENTSTACK_API_KEY": "<YOUR_STACK_API_KEY>",
        "CONTENTSTACK_DELIVERY_TOKEN": "<YOUR_DELIVERY_TOKEN>",
        "CONTENTSTACK_BRAND_KIT_ID": "<YOUR_BRAND_KIT_ID>",
        "CONTENTSTACK_LAUNCH_PROJECT_ID": "<YOUR_LAUNCH_PROJECT_ID>",
        "CONTENTSTACK_PERSONALIZE_PROJECT_ID": "<YOUR_PERSONALIZE_PROJECT_ID>",
        "LYTICS_ACCESS_TOKEN": "<YOUR_LYTICS_TOKEN>",
        "GROUPS": "<COMMA_SEPARATED_GROUPS>"
      }
    }
  }
}

Notes:

• The CONTENTSTACK_DELIVERY_TOKEN is optional and only required if you plan to use the Content Delivery API (CDA) tools.
• The CONTENTSTACK_BRAND_KIT_ID is required only for BrandKit tools.
• The CONTENTSTACK_LAUNCH_PROJECT_ID is required only for Launch tools.
• The CONTENTSTACK_PERSONALIZE_PROJECT_ID is required only for Personalize tools.
• The LYTICS_ACCESS_TOKEN is required only for Lytics tools.
• Before using CMA, CMA Extended, Analytics, Automations, BrandKit, Launch, DeveloperHub, or Personalize groups, you must first run OAuth authentication: npx @contentstack/mcp --auth

If your MCP client does not support environment variables, pass the same values as command-line arguments:

{
  "mcpServers": {
    "contentstack": {
      "command": "npx",
      "args": [
        "-y",
        "@contentstack/mcp",
        "--stack-api-key",
        "<YOUR_STACK_API_KEY>",
        "--delivery-token",
        "<YOUR_DELIVERY_TOKEN>",
        "--brand-kit-id",
        "<YOUR_BRAND_KIT_ID>",
        "--launch-project-id",
        "<YOUR_LAUNCH_PROJECT_ID>",
        "--lytics-access-token",
        "<YOUR_LYTICS_TOKEN>",
        "--personalize-project-id",
        "<YOUR_PERSONALIZE_PROJECT_ID>",
        "--groups",
        "<COMMA_SEPARATED_GROUPS>"
      ]
    }
  }
}

Build Your Own MCP (Tool Definitions API)

Contentstack publishes the same tool definitions this server uses at public, unauthenticated HTTPS endpoints. If you are building your own MCP server, agent framework, or API client, you can fetch these definitions directly and translate a tool call into a Contentstack REST/GraphQL request yourself — no need to vendor this package.

These endpoints serve tool metadata only (names, descriptions, input schemas, and request mappings). They contain no credentials. You bring your own tokens when you execute the resulting request.

Tool definition endpoints

Each API group is published at https://mcp.contentstack.com/<group>/tools:

| Group | Endpoint | | -------------- | ------------------------------------------------- | | cma | https://mcp.contentstack.com/cma/tools | | cma-extended | https://mcp.contentstack.com/cma-extended/tools | | cda | https://mcp.contentstack.com/cda/tools | | brandkit | https://mcp.contentstack.com/brandkit/tools | | lytics | https://mcp.contentstack.com/lytics/tools | | personalize | https://mcp.contentstack.com/personalize/tools | | analytics | https://mcp.contentstack.com/analytics/tools | | automations | https://mcp.contentstack.com/automations/tools | | launch | https://mcp.contentstack.com/launch/tools | | developerhub | https://mcp.contentstack.com/developerhub/tools |

curl -s https://mcp.contentstack.com/cda/tools | jq 'keys'

Each endpoint returns a JSON object keyed by tool name.

Tool definition format

{
  "<tool_name>": {
    "name": "get_all_assets_cdn",
    "description": "Human/LLM-facing description of what the tool does.",
    "group": "cda",
    "subGroup": "ai", // optional; only some groups (e.g. brandkit) use it
    "mapper": {
      /* how to build the HTTP request — see below */
    },
    "inputSchema": {
      /* JSON Schema for the tool's arguments */
    },
  },
}

• inputSchema is standard JSON Schema — expose it directly to your LLM / tool runner as the tool's parameters.
• mapper tells you how to translate the validated arguments into an HTTP request:

| Field | Meaning | | ------------- | ------------------------------------------------------------------------------------------ | | apiUrl | Path appended to the group's base URL. May contain path-parameter placeholders. | | method | GET / POST / PUT / PATCH / DELETE. | | type | "complex" (schema-shaped body) or "graphql". Absent / "object" = simple. | | params | Maps a placeholder in apiUrl → the argument name that fills it. | | queryParams | Maps a query string key → the argument name that provides its value. | | headers | Maps an HTTP header name → the argument name that provides its value. | | body | For simple tools: the argument name holding the request body. For complex: a sub-schema. |

GraphQL tools (type: "graphql") additionally carry query (the query string) and variables (maps each GraphQL variable → { "type": ..., "x-mapFrom": "<argName>" }).

Building a request

Given a tool definition and a map of validated args:

1. URL / path params — start from mapper.apiUrl; for each mapper.params entry (placeholder → argName), replace placeholder with encodeURIComponent(args[argName]).
2. Query params — for each mapper.queryParams entry, if args[argName] is defined, add it. Keys ending in [] serialize as repeated array params (key[]=a&key[]=b); object values are JSON-stringified.
3. Headers — for each mapper.headers entry, set the header from args[argName], then add the authentication headers for the group (below).
4. Body —
   • Simple (body is a string): if args[body] exists it is the body verbatim; otherwise all arguments not consumed by params/queryParams are wrapped under the body key.
   • Complex (type: "complex"): walk the schema; each leaf with x-mapFrom pulls from args[x-mapFrom].
   • GraphQL (type: "graphql"): POST { query, variables }, filling each variable from args[variables[var]["x-mapFrom"]].
5. Assemble — <base URL for group + region> + <resolved apiUrl> + ?<query>, with the method, headers, and body above.

Base URLs

The base URL is <region endpoint for the service> + <optional path suffix>. Region endpoints come from the official region document at https://artifacts.contentstack.com/regions.json.

| Group | regions.json field | Path suffix | | -------------------------------------- | ------------------------------------------- | ------------ | | cma, cma-extended | contentManagement | — | | cda | contentDelivery | — | | developerhub | developerHub | — | | personalize | personalizeManagement | — | | analytics | application | /analytics | | automations | automate | — | | launch | launch | /manage | | brandkit (subGroup brand-kits-api) | brandKit | — | | brandkit (subGroup ai) | genAI with trailing /brand-kits removed | — |

For example, for region NA, cma resolves to https://api.contentstack.io and cda to https://cdn.contentstack.io. Lytics is not regional: https://api.lytics.io.

Authentication headers

You supply the token values; the definitions never include them.

| Group | Required headers | | -------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------ | | cda | api_key: <stack api key>, access_token: <delivery token> | | cma, cma-extended (token auth) | api_key: <stack api key>, authorization: <mgmt token> | | cma, cma-extended, developerhub, brandkit, analytics, automations, launch, personalize (OAuth) | api_key (where applicable) + OAuth bearer headers | | lytics | Authorization: <lytics access token> |

Group-specific extras: BrandKit brand_kit_uid; Personalize x-project-uid; Launch x-project-uid, x-organization-uid (+ Apollo client headers); Analytics an orgUid query param from the OAuth org. Automations uses the OAuth bearer token plus organization_uid; Automation project UIDs are path parameters.

Example — CDA: list assets

{
  "name": "get_all_assets_cdn",
  "group": "cda",
  "mapper": {
    "apiUrl": "/v3/assets",
    "method": "GET",
    "queryParams": { "limit": "limit", "include_count": "include_count" },
    "headers": { "branch": "branch" },
  },
}

With args = { limit: 10, include_count: true, branch: "main" }, region EU:

GET https://eu-cdn.contentstack.com/v3/assets?limit=10&include_count=true
api_key: <stack api key>
access_token: <delivery token>
branch: main

This repository is itself a reference implementation. The request-building logic lives in src/utils/index.ts and the region/endpoint maps in src/utils/constants.ts — see the source on GitHub.

Tools Catalog

Content Management API (CMA)

Entries, assets, content types, taxonomies, terms, branches, releases, environments, publishing, variants, global fields, and entry references.

| Tool | Description | | ---------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | | publish_an_entry | Publishes a specified entry of a content type to one or more environments and locales within a branch of the stack. Optionally schedule the publish for a future time. | | unpublish_an_entry | Unpublishes a specified entry from selected environments and locales within a branch, removing it from the CDN so it is no longer served by the delivery APIs. Optionally schedule the unpublish for a future time. | | publish_variants_of_an_entry | Publishes one or more variants of an entry to selected environments and locales within a branch. Use the get_all_variants_of_a_content_type tool to resolve variant UIDs. | | create_an_entry | Creates a new entry in the specified Contentstack stack, targeting a defined content type and branch, with support for locale selection and structured entry data. | | delete_an_entry | Deletes a specified entry from a Contentstack stack, targeting the provided content type and entry UID, with optional parameters for branch, locale, and deletion of all localized variants. | | get_all_entries | Retrieves entry details for a specified content type within a Contentstack stack, supporting branch selection, pagination, versioning, locale filtering, advanced query parameters, optional draft overlay (apply_draft), and optional inclusion of metadata, workflow, branch, and publish details. | | get_single_entry | Retrieves metadata and field values for a specified entry within a given content type, supporting branch, version, and locale selection, with optional inclusion of workflow, branch, and publish details. | | update_an_entry | Updates an existing entry in the given content type, branch, and locale by replacing its field data. | | get_all_content_types | Retrieves all content types in the stack, with pagination, query filtering, and optional inclusion of the global field schema. | | get_a_single_content_type | Retrieves the schema and configuration details of a specified content type within a stack, supporting optional inclusion of global field definitions and branch metadata for developer reference. | | create_a_content_type | Creates a new content type in the specified Contentstack stack, supporting branch selection and optional branch metadata inclusion. | | update_content_type | Updates an existing content type in the specified Contentstack stack, supporting branch selection and optional branch metadata inclusion. | | delete_content_type | Deletes an existing content type and all the entries within it. | | get_all_references_of_ct | Retrieves the content types that reference the specified content type, including direct and nested references. | | export_content_type | Exports a specific content type and its schema. The data is exported in JSON format. | | get_all_taxonomies | Retrieves metadata for all taxonomies in the stack, with pagination and typeahead search by UID or name. | | get_a_single_taxonomy | Retrieves metadata and configuration details for a specified taxonomy, with optional inclusion of term, referenced term, and referenced entry counts for advanced content modeling and reporting. | | export_a_taxonomy | Exports a taxonomy and all its associated terms from the specified stack in the selected format, supporting structured data extraction for taxonomy management. | | get_all_languages | Retrieves metadata for all languages configured within a specified stack branch, supporting pagination via limit and skip parameters. | | get_all_assets | Retrieves metadata for all assets in the stack, with environment and folder filters, query filtering, ascending/descending sorting, and pagination. | | get_all_branches | Retrieves metadata for all branches within a specified stack, supporting pagination via limit and skip parameters. | | create_a_branch | Creates a new branch in the specified Contentstack stack. | | get_a_single_branch | Retrieves metadata and configuration details for a specified branch within a Contentstack stack, enabling branch-level inspection and management. | | delete_a_branch | Deletes a branch in the specified Contentstack stack. | | compare_branches | Retrieves a list of all the differences between two branches. | | compare_content_types_between_branches | Retrieves a list of all the differences in content types between the two specified branches. | | compare_global_fields_between_branches | Retrieves a list of all the differences in global fields between the two specified branches. | | compare_specific_ct_between_branches | Retrieves all the differences of the specified content type between the two specified branches. | | compare_specific_gf_between_branches | Retrieves all the differences of the specified global field between the two specified branches. | | get_all_merge_jobs | Retrieves a list of all the recent merge jobs within a specific period. | | merge_branch | Merges content types and global fields from a compare branch into a base branch, with optional per item strategy overrides. | | get_a_single_merge_job | Retrieves detailed information for a specified merge job within a stack, using the provided merge_job_uid parameter. | | get_a_single_branch_alias | Retrieves metadata and configuration details for a specified branch alias within a Contentstack stack, enabling branch management and validation operations. | | get_all_branch_aliases | Retrieves metadata for all branch aliases within a specified stack, supporting pagination via limit and skip parameters. | | assign_a_branch_alias | Assigns (creates or updates) a branch alias so it points to a target branch in the stack. | | delete_a_branch_alias | Permanently deletes the specified branch alias from the selected stack. | | get_all_global_fields | Retrieves metadata for all global fields configured within the specified stack, supporting optional branch selection and branch metadata inclusion. | | get_all_items_in_a_release | Retrieves metadata and content details for all items associated with the specified release_uid, optionally including branch information if include_branch is true. | | get_all_releases | Retrieves metadata for all releases in the stack, with pagination and optional inclusion of total and item counts. | | get_all_terms | Retrieves all term details for a specified taxonomy from the stack, supporting pagination via limit and skip parameters. | | get_all_terms_across_all_taxonomies | Retrieves term details from all taxonomies within the stack, supporting typeahead search, pagination via limit and skip, and optional total count inclusion. | | get_all_variants_of_an_entry | Retrieves all variants (personalization variants) of a specified entry within the selected content type. | | get_all_ancestors_of_a_term | Retrieves the complete ancestor hierarchy for a specified term within a taxonomy, supporting pagination via limit and skip parameters. | | get_a_single_asset | Retrieves metadata and properties for a specified asset within a Contentstack stack, supporting branch, environment, and version parameters for precise asset identification and retrieval. | | get_asset_reference | Retrieves all entries referencing the specified asset within the selected branch, enabling asset dependency analysis and content relationship management. | | get_all_descendants_of_a_term | Retrieves all descendant terms of a specified taxonomy term, supporting pagination via limit and skip parameters. Suitable for hierarchical taxonomy traversal and term management. | | get_a_single_release | Retrieves metadata and configuration details for a specified release within a given branch, supporting optional inclusion of branch information for developer reference and audit purposes. | | get_single_entry_variant | Retrieves a specific variant of a content entry from a designated content type, branch, and locale, using the provided entry and variant identifiers. Suitable for variant management and localization workflows. | | get_a_single_global_field | Retrieves metadata and configuration details for a specified global field within a Contentstack stack, supporting branch selection and optional inclusion of branch context. | | get_a_single_variant | Retrieves details of a single variant within a variant group. | | get_a_single_term | Retrieves detailed metadata for a specified taxonomy term, supporting optional inclusion of child term and referenced entry counts. | | get_all_variants_of_a_content_type | Retrieves all variant definitions (variant groups) linked to the specified content type. | | get_publish_queue | Retrieves the publish queue for the branch — the log of publish, unpublish, and delete activities on entries and assets — with pagination and optional filtering by bulk job, action, status, environment, or locale. | | get_references_of_an_entry | Retrieves all entries that reference the specified entry via reference fields. Use this before modifying or unpublishing an entry to understand the downstream impact on other content. | | add_items_to_a_release | Programmatically adds specified content items to a designated release within a Contentstack stack branch by accepting structured item data in JSON format, enabling automated release management and deployment workflows. | | clone_a_release | Creates a duplicate of an existing release in the specified branch, assigning a new name and optional description to the cloned release. | | localize_an_entry | Localizes a specified entry within a stack by creating or updating its content for the target locale, ensuring the entry becomes independent from the fallback locale. Supports branch selection, content type, entry identification, and locale specification. | | create_a_release | Creates a new empty release object within the specified stack branch, initializing it with a required name and optional description; supports branch selection and inclusion parameters for release management. | | create_a_taxonomy | Creates a new taxonomy object within the specified stack, assigning the provided UID, name, and optional description for structured content classification. | | create_a_term | Creates a new term within a specified taxonomy by assigning a unique identifier, name, order, and optional parent term. | | delete_an_asset | Permanently deletes the specified asset from the selected branch within the stack. | | delete_a_taxonomy | Deletes the specified taxonomy and all associated terms from the stack. | | delete_a_term | Deletes a specified term from a taxonomy using the provided taxonomy_uid and term_uid parameters; supports forced deletion via the force flag. | | get_all_environments | Fetches the list of environments in the stack, with optional total-count reporting and ascending/descending sorting by any environment field. | | create_an_environment | Creates a new environment in the stack by specifying its name and one or more locale-specific base URLs. | | get_an_environment | Retrieves full details for a single environment, identified by its name. | | update_an_environment | Updates an existing environment, identified by its name in the URL path. You can change the environment’s name and/or its locale-to-URL mappings. | | delete_an_environment | Permanently deletes an environment, identified by its name. | | deploy_a_release | Deploys a release to one or more target environments, publishing or unpublishing all of its items. Supports optional scheduling for a future time. | | update_a_taxonomy | Updates the name and description fields of a specified taxonomy entity using its unique identifier. | | update_a_term | Updates the name property of a specified term within a taxonomy using the provided taxonomy_uid and term_uid identifiers. | | delete_items_from_a_release | Programmatically removes specified content items from a designated release within a Contentstack stack branch, requiring the release identifier and item data in JSON format for precise targeting and execution. | | publish_an_asset | Publishes a specified asset to one or more environments and locales within a stack, with optional scheduling for a future time. | | unpublish_an_asset | Unpublishes a specified asset from selected environments and locales within a stack, with optional scheduling for a future time. | | unlocalize_an_entry | Unlocalizes a specified entry in a given locale, restoring it to its original non-localized (fallback) state within the selected branch and content type. | | create_an_entry_variant | Creates an entry variant for an existing base entry. | | delete_an_entry_variant | Deletes a specified entry variant from a base entry. |

Content Management API Extended (CMA Extended)

Audit logs, entry and asset version history, global field writes, asset folder management, and workflow and publish rule inspection. Load with --groups cma,cma-extended. Requires the same OAuth authentication as cma.

| Tool | Description | | ---------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | get_audit_log | Retrieves a paginated list of audit log entries for the stack. Every create, update, delete, publish, and unpublish action is recorded. Use this to explain recent changes or reconstruct the timeline of an incident. | | get_audit_log_item | Retrieves the full detail of a single audit log entry, including before and after field values, the user who made the change, and the timestamp. Use after get_audit_log to drill into a specific change. | | get_all_versions_of_an_entry | Retrieves the full version history of a specific entry. Use this to audit how content evolved over time, identify the version that introduced a problem, or determine which version number to publish. | | set_entry_version_name | Assigns a human-readable label to a specific version of an entry, e.g. 'Approved by legal' or 'Pre-launch draft'. Named versions are visible in the Contentstack UI. | | delete_entry_version_name | Removes the label previously assigned to a specific entry version. The version itself is not deleted. | | create_a_global_field | Creates a new global field in the stack. Global fields are reusable field groups that can be embedded in multiple content types. Changes to a global field propagate to every content type that uses it. | | update_a_global_field | Updates the schema or title of an existing global field. Changes propagate to every content type that embeds this global field. | | delete_a_global_field | Permanently deletes a global field and removes its embedded occurrence from every content type that references it. This action cannot be undone. | | export_global_field | Exports a global field definition as a JSON object. Use this to back up a schema or inspect the full field definition before updating or deleting it. | | update_asset_details | Updates the metadata of an existing asset — title, description, or tags — without replacing the underlying file. | | get_assets_of_a_specific_folder | Retrieves assets contained in a specific folder by its UID, with optional sub-folder inclusion and publish detail filters. | | get_assets_and_subfolders_of_a_parent_folder | Retrieves both asset files and sub-folder entries within a parent folder. Useful for traversing the asset hierarchy or confirming folder contents before deletion. | | create_asset_folder | Creates a new folder in the asset library, optionally nested under a parent folder. | | update_asset_folder | Renames an existing asset folder. The folder UID and its contents remain unchanged. | | delete_asset_folder | Permanently deletes an asset folder and all assets and sub-folders it contains. This action cannot be undone. | | get_all_versions_of_an_asset | Retrieves the full version history of a specific asset. Use this to identify which version is currently published or review the upload history. | | set_asset_version_name | Assigns a human-readable label to a specific version of an asset, e.g. 'Hero image — final approved'. | | delete_asset_version_name | Removes the label previously assigned to a specific asset version. The version itself is not deleted. | | get_all_workflows | Retrieves all workflows defined in the stack. Use this to understand the approval process and identify which workflow applies to a given content type before moving an entry through stages. | | get_a_single_workflow | Retrieves the complete definition of a single workflow, including all stages, transition rules, and role-based permissions. | | get_publish_rules | Retrieves publish rules for workflows in the stack, defining which workflow stages allow or block publishing and which content types they apply to. | | get_publish_queue_activity | Retrieves a recent activity summary for the publish queue across the entire stack. Use for monitoring overall publishing health. For item-level filtering, use get_publish_queue in the cma group instead. |

Content Delivery API (CDA)

Published entries and assets served through Contentstack's CDN.

| Tool | Description | | ------------------------ | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | get_all_assets_cdn | Retrieves published assets from the Content Delivery Network. Returns CDN metadata including URLs, file types, dimensions, and publish status. Supports pagination (limit/skip), branch and locale selection, specific versions, and optional inclusion of image dimensions, publish details, and metadata. Ideal for building media galleries, asset pickers, or bulk asset operations. | | get_all_entries_cdn | Retrieves published entries of a content type from the CDN for fast, global delivery. Returns paginated entries with full field values, and supports filtering (query), sorting (asc/desc), reference resolution (include/include_all), locale selection, and fallback. Essential for listing pages, search interfaces, or data synchronization. Maximum 100 entries per request. | | get_a_single_asset_cdn | Retrieves a specific published asset from the CDN by its unique identifier. Returns complete asset metadata including CDN URL, file details, dimensions, and version information. Use this for direct asset access in your applications, ensuring fast, cached delivery through Contentstack's global CDN infrastructure. | | get_a_single_entry_cdn | Retrieves a specific published entry from the CDN by its unique identifier and content type. Returns complete entry data with all field values, optimized for fast global delivery. Supports environment and locale selection with automatic fallback to default locale when specified locale is unavailable. Perfect for detail pages, single resource views, or real-time content display. |

Analytics API

Usage, status-code, cache, URL, device, and SDK analytics.

| Tool | Description | | ------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | | get_subscription_usage | Retrieves a comprehensive summary of Launch resource consumption within your organization for a specified date range. Returns total counts for Launch projects, environments, and configured domains. This asynchronous operation returns a jobId that must be passed to get_job_data to retrieve the actual results. Essential for tracking Launch resource utilization, license compliance, and capacity planning. | | get_device_usage | Analyzes device and SDK usage patterns across your Contentstack services over a specified period. Returns detailed statistics including device types, SDK versions, platforms, operating systems, access counts, and temporal patterns. This asynchronous operation returns a jobId for get_job_data. Supports filtering by service type (CMA, UI, CDN, GraphQL, Images, Assets, Automations, Launch), ordering, pagination, and date ranges. Critical for understanding client distribution, SDK adoption, and optimizing compatibility testing. | | get_usage_analytics | Retrieves comprehensive API and CDN usage analytics for your organization over a specified time period. Returns bandwidth consumption and request counts broken down by service type (CMA, UI, CDN, GraphQL, Images, Assets, Automations, Launch). This asynchronous operation returns a jobId for get_job_data. Supports filtering by stack (apiKey), Launch project, and environment. Note: apiKey cannot be used with automations/launch services simultaneously; apiKey and environmentUid apply only to Launch service. Essential for monitoring traffic patterns, billing analysis, and capacity planning. | | get_top_urls | Analyzes URL-level traffic patterns across your Contentstack services over a specified time period. Returns request counts for each accessed URL, broken down by service type (CMA, UI, CDN, GraphQL, Images, Assets, Automations, Launch). This asynchronous operation returns a jobId for get_job_data. Supports filtering by stack, sorting by request count, and pagination. Essential for identifying high-traffic endpoints, detecting hot spots, optimizing caching strategies, and analyzing content popularity. | | get_status_code | Retrieves comprehensive HTTP status code distribution across your Contentstack services for a specified time period. Returns request counts grouped by status code (200, 404, 500, etc.), service type, and date. This asynchronous operation returns a jobId for get_job_data. Supports filtering by specific status code, stack, date range, and service types. Critical for monitoring API health, identifying error patterns, tracking success rates, detecting outages, and ensuring service reliability and SLA compliance. | | get_cache_usage | Analyzes cache performance by tracking HIT and MISS rates across your Contentstack services over a specified period. Returns cache efficiency metrics broken down by service type (CDN, Images, Assets, etc.), showing HIT (cached content served) vs MISS (origin fetch required) counts over time. This asynchronous operation returns a jobId for get_job_data. Supports filtering by cache status, stack, and date range. Essential for optimizing cache configurations, improving response times, reducing origin load, and lowering bandwidth costs. | | get_sdk_usage | Tracks SDK adoption and usage patterns across your Contentstack services for a specified time period. Returns request counts for each SDK version used, broken down by service type and date. This asynchronous operation returns a jobId for get_job_data. Identifies which SDK versions (JavaScript, iOS, Android, REST, etc.) are making requests, helping track migration progress, identify deprecated SDK usage, plan sunset timelines, and ensure clients are on supported versions. Critical for SDK lifecycle management and developer support. | | get_job_data | Retrieves the completed results for an asynchronous analytics job using its jobId. All analytics tools (get_subscription_usage, get_device_usage, get_usage_analytics, get_top_urls, get_status_code, get_cache_usage, get_sdk_usage) return a jobId that must be passed to get_job_data to fetch the actual data. Jobs are processed asynchronously to handle large datasets efficiently. If the job is still processing, it returns 200 Job active; retry after a short delay. Supports pagination via page parameter for large result sets. Essential for completing any analytics data retrieval workflow. |

Automations API

Automation Hub project management, automation discovery, activation controls, and deterministic HTTP-triggered workflow execution.

| Tool | Description | | --------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------- | | list_automation_projects | Lists Automation Hub projects in the organization with pagination, sorting, and optional count support. | | get_automation_project | Fetches a single Automation Hub project by project UID. | | create_automation_project | Creates an Automation Hub project with title, description, and tags. | | update_automation_project | Updates an Automation Hub project's title, description, or tags. | | delete_automation_project | Deletes an Automation Hub project. This action is permanent. | | list_automations | Lists automations in a project. Use show_steps: true to inspect triggers and steps, including HTTP-triggered automations. | | get_automation | Fetches a single automation by automation UID, optionally including trigger and step details. | | trigger_automation | Runs an automation configured with an HTTP Request trigger by calling /run/{trigger_id}. Pass the automation trigger's id and an optional JSON payload. | | set_automation_active | Activates or deactivates an automation. The automation must already have a trigger and action configured before it can be activated. |

BrandKit AI

Brand voice, knowledge vault, and AI content generation.

| Tool | Description | | ----------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | create_an_content_in_knowledge_vault | Creates new content in the Brand Kit Knowledge Vault to provide contextual information for AI-powered content generation. The Knowledge Vault stores brand guidelines, tone of voice examples, and reference materials that inform AI responses to maintain brand consistency. | | get_all_contents_in_knowledge_vault | Retrieves all content entries stored in the Knowledge Vault for a specific Brand Kit. Returns comprehensive metadata and content details for review, audit, or bulk management of brand reference materials used in AI content generation. | | get_a_single_content_in_knowledge_vault | Retrieves detailed infor