Webiny CMS MCP. Manage Content Lifecycle via Conversation
Gemini Works with every AI agent you already use
…and any MCP-compatible client
Just plug in your AI agents and start using Vinkius.
Webiny CMS MCP connects your AI agent directly to your headless content system. Draft, publish, and manage content across models and locales using natural conversation.
It handles the complex data operations of an enterprise CMS without you having to write GraphQL queries or manually update JSON payloads.
What your AI agents can do
Create cms entry
Drafts a new content piece for a specified model using JSON data.
Delete cms entry
Permanently removes a specific, existing content entry revision from the system.
Execute graphql query
Runs raw GraphQL queries or mutations against the entire CMS API.
Creates new draft versions for any defined content model.
Moves a finished draft entry to a published, read-accessible state.
Modifies specific fields on an already existing content entry revision.
Runs raw GraphQL mutations or reads against the CMS for highly customized operations.
Retrieves lists of existing content entries or discovers available field types in the system.
Checks global tenant settings, model details, and historical entry revisions for compliance checks.
Ask AI about this MCP
Supported MCP Clients
OAuth 2.0 Compatible Gemini Waiting for input…
Webiny CMS with 9 Tools
These tools allow you to perform all major content operations: listing models, creating drafts, executing complex GraphQL reads/writes, and managing the publication status of entries.
Make your AI actually useful.
Add this MCP to Claude, Cursor, or Windsurf and your AI stops guessing. It gets real tools to look things up, take action, and handle the stuff you keep doing by hand.
Start using Webiny CMS on Vinkius019d7621create cms entry
Drafts a new content piece for a specified model using JSON data.
019d7621delete cms entry
Permanently removes a specific, existing content entry revision from the system.
019d7621execute graphql query
Runs raw GraphQL queries or mutations against the entire CMS API.
019d7621get api introspection
Retrieves a map of all available content types, fields, and models in the CMS.
019d7621get model entry details
Fetches specific metadata or field values for a single, known entry revision ID.
019d7621get tenant config
Retrieves high-level global settings and configurations for the entire CMS tenant.
019d7621list model entries
Lists all existing content entries for a specific model type, whether they are drafts or live.
019d7621publish cms entry
Makes an already drafted entry visible and accessible through the primary API read endpoint.
019d7621update cms entry
Changes specific field values on a content entry revision that currently exists.
Choose How to Get Started
Build a custom MCP for your own tools, or connect a ready-made integration from our catalog.
Build Your Own
Turn any API into an MCP. Import a spec, define Agent Skills, or deploy with MCPFusion.
- Import from OpenAPI, Swagger, or YAML specs
- Create Agent Skills with progressive disclosure
- Deploy to edge with MCPFusion framework
- Built in DLP, auth, and compliance on every call
- Real time usage dashboard and cost metering
- Publish to catalog or keep private
Make Your AI Do More
Start with Webiny CMS, then connect any of our 4,900+ other servers whenever your AI needs more. One click, no limits.
- Use this MCP plus 4,900+ others, all in one place
- Add new capabilities to your AI anytime you want
- Every connection is secured and compliant automatically
- Track usage and costs across all your servers
- Works with Claude, ChatGPT, Cursor, and more
- New servers added to the catalog every week
Independent Platform Disclaimer: Vinkius is an independent platform and is not affiliated with, endorsed by, sponsored by, verified by, or otherwise authorized by Webiny. All third-party trademarks, logos, and brand names are the property of their respective owners. Their use on this website is strictly for informational purposes to identify service compatibility and interoperability.
VINKIUS INFRASTRUCTURE
Cloud Hosted
Managed infra
V8 Isolated
Sandboxed per request
Zero-Trust Proxy
No stored credentials
DLP Enforced
Policy on every call
GDPR Compliant
EU data residency
Token Compression
~60% cost reduction
Works with Claude, ChatGPT, Cursor, and more
The Model Context Protocol standardizes how applications expose capabilities to LLMs. Instead of operating in isolation, your AI gains direct access to external platforms, live data, and real-world actions through secure, standardized connections.
This server provides 9 capabilities that interface natively with Claude, ChatGPT, Cursor, and any MCP client. No middleware. No custom integration required.
Managing CMS Content Used to Be a Pain Point.
Today, changing content state means logging into the dashboard, navigating to the correct model, finding the right entry by ID, making sure it's in the draft status, and then manually updating specific fields. It’s a series of clicks, copies, and pastes across multiple tabs.
With this MCP, you just talk to your agent. You tell it: 'Update Article XYZ for all locales.' The tool handles checking the drafts, running the necessary updates via `update_cms_entry`, and verifying success. What you get is instant content operations through conversation.
Getting Content Data Out Is Now Simple.
You no longer have to manually write out a full GraphQL schema every time your front-end needs slightly different data. You can use `get_api_introspection` to automatically map the entire available structure, so you know exactly what’s there.
This capability makes content architecture much more flexible. Your agent knows the system's rules and endpoints; it just figures out how to get the data you need without boilerplate code.
What you can do with this MCP connector
Managing a modern content stack used to mean jumping between dashboards, drafting JSON in playgrounds, and praying the API call didn't fail halfway through. Now, your agent handles it all. You tell it what needs changing—like updating an article across three languages or publishing a new author profile—and it executes the necessary steps within the Webiny CMS environment.
It’s not just about reading data; this MCP lets you manage the entire content lifecycle, from drafting initial entries to running raw GraphQL mutations for complex operations. Need to audit what field was changed last? You can check entry revisions and global tenant configurations easily. This level of operational visibility is critical.
Because all these calls are handled through Vinkius, every action generates a cryptographically signed audit trail, giving you undeniable proof of exactly who did what and when it happened.
019d7621-635c-7359-a90a-198338b13c22 
How Webiny CMS MCP Works
- 1 First, you provide the MCP your Webiny API domain and access token credentials.
- 2 Next, you instruct your agent to perform a content operation—for example, 'List all draft posts for Q3' in English.',
- 3 Finally, the connector runs the necessary sequence of calls (read -> process -> write) and reports the result directly back to your chat interface.
The bottom line is that you treat content management like a conversation, not a series of API endpoints.
Who Is Webiny CMS MCP For?
Content Managers who spend all day in multiple CMS dashboards switching between tabs. Marketing leads who need to verify publication status across dozens of campaigns fast. Developers building frontends that require structured data access without writing boilerplate GraphQL.
Uses the agent to check model introspection and list available fields before drafting new content, eliminating guesswork.
Runs bulk updates across multiple models or handles multi-locale publishing for large content pushes in minutes.
Tests complex data fetching logic by executing raw GraphQL queries directly through the agent, validating schemas without a local playground setup.
What Changes When You Connect
- Publishing is simple: Instead of manually finding the entry ID and running a specific publish command, you simply tell your agent to make it live using
publish_cms_entry. It handles the state change. - You avoid drafting JSON payloads. To create content, just provide the model name and field data; the
create_cms_entrytool drafts the whole thing for you. - Need to know what fields exist? Use
get_api_introspection. This immediately maps out your entire CMS structure so you never have to guess or check external documentation again. -
list_model_entriesgives you a clear overview of all content items in a model, letting you quickly locate specific drafts or published versions across different locales. - The
execute_graphql_querytool lets developers run complex data reads or writes for niche use cases that simple CRUD operations can't handle. It’s full raw power when needed. - Audit trails are airtight. Because all these calls flow through Vinkius, you get a cryptographically signed record of every operation—proving exactly what state the content was in before and after.
Real-World Use Cases
The urgent multi-locale update
A marketing manager needs to change a product description on five different articles across three languages (en-US, es-MX, fr-CA). Instead of logging into the CMS multiple times, they prompt their agent: 'Update article X's key feature description for all locales.' The agent uses update_cms_entry and repeats it for each required locale.
The schema verification roadblock
A developer is building a new module that needs to read content from an obscure model. They first run get_api_introspection to discover the exact type name and available fields, then use execute_graphql_query to test the data structure before writing any code.
The retiring content audit
An administrator needs to delete an old, unrecoverable piece of content. They run get_model_entry_details first to confirm the ID and revision details, then use delete_cms_entry to permanently remove it with a single command.
The draft-to-live promotion
A content editor finishes an article and needs it live. They tell the agent: 'Publish the latest revision of Article Y.' The agent uses publish_cms_entry to move the content into a publicly readable state, making it available for consumption immediately.
The Tradeoffs
Manual GraphQL drafting
Writing out complex queries in an external playground, copying the exact mutation string into a separate terminal window, and then running the whole thing.
→
Just ask your agent to run the query. Use execute_graphql_query by asking for 'read' or 'manage' type data, and let the MCP handle the syntax and execution details.
State confusion
Trying to update content without knowing if it needs to be published first, leading to partial updates that are inaccessible via the public API.
→
Always verify status. First use get_model_entry_details to check metadata, then run publish_cms_entry before running any major data operations.
Over-reliance on GUI
Manually clicking through the CMS interface for bulk changes or checking status across dozens of records.
→
Use list_model_entries to pull all necessary IDs and statuses into a single view, then use your agent to process them in batches.
When It Fits, When It Doesn't
Use this MCP if you need programmatic control over content state. You should use it when the core problem is not just 'reading' data but changing it—drafting new entries (create_cms_entry), updating specific fields (update_cms_entry), or changing its visibility (publish_cms_entry). Don't use this if you only need a static list of models, because then simple discovery tools might suffice. However, if the task requires combining reads (e.g., finding an entry ID) with writes (e.g., updating that specific entry), this MCP is necessary for coordinating those steps and maintaining data integrity.
Common Questions About Webiny CMS MCP
How do I know what fields are available using `get_api_introspection`? +
It provides a complete, automated map of every content model and field type in your entire CMS instance. This lets you understand the full data structure before you write any query.
Can I use `execute_graphql_query` to read published or draft content? +
Yes, it handles both. You specify whether you're running a 'read' query for live public data or a 'manage' query for accessing drafts and internal data.
What is the difference between `list_model_entries` and `get_model_entry_details`? +
list_model_entries gives you a broad list of records (e.g., 'I see 12 posts'), while get_model_entry_details drills down into one specific record to show its exact field values and metadata.
Does using `publish_cms_entry` make the content visible immediately? +
Yes, running this tool moves the entry's status from draft to live. It makes the content available via your public read API endpoint right away.
What happens when I use `create_cms_entry`? Does the content go live immediately? +
No, it creates a new draft entry. The content is saved as an un-published revision first. You must explicitly call another function to publish it and make it available for reading.
How do I use `update_cms_entry` while ensuring I don't overwrite unrelated fields? +
You provide the entry ID along with a JSON object containing only the specific field updates. This mechanism prevents you from accidentally wiping out existing data on other parts of the record.
What risks am I taking when running `delete_cms_entry`? +
This action permanently deletes a content entry revision and cannot be undone. Always confirm the exact ID you intend to delete before calling this function, as it's irreversible.
What is the best way to check the overall health and global settings of my CMS environment? (Using `get_tenant_config`) +
get_tenant_config retrieves the high-level, global settings for your entire Webiny tenant. This confirms that your core API access and environmental configurations are set up correctly.
Use it with your favorite AI tools
Connect this server to Cursor, Claude, VS Code, and more.