4,500+ servers built on MCP Fusion
Vinkius

Zesty.io MCP. Manage CMS models and items from natural language.

Claude Claude
ChatGPT ChatGPT
Cursor Cursor
Gemini Gemini
Windsurf Windsurf
VS Code VS Code
JetBrains JetBrains
Vercel Vercel
See Vinkius in Action

Works with every AI agent you already use

…and any MCP-compatible client

Zesty.io MCP on Cursor AI Code Editor MCP Client Zesty.io MCP on Claude Desktop App MCP Integration Zesty.io MCP on OpenAI Agents SDK MCP Compatible Zesty.io MCP on Visual Studio Code MCP Extension Client Zesty.io MCP on GitHub Copilot AI Agent MCP Integration Zesty.io MCP on Google Gemini AI MCP Integration Zesty.io MCP on Lovable AI Development MCP Client Zesty.io MCP on Mistral AI Agents MCP Compatible Zesty.io MCP on Amazon AWS Bedrock MCP Support

Just plug in your AI agents and start using Vinkius.

Zesty.io connects your AI client to manage content models, data entries, and instances directly through the Zesty.io API. This MCP server lets your agent read, write, and update structured content—like blog posts or product specs—as if it were logged into the CMS.

You can list all available sites (`list_zesty_instances`), understand your content structure by listing models (`list_content_models`), and perform full CRUD operations on specific items using tools like `create_content_item` and `get_content_item`.

It’s a developer-grade API wrapper for headless CMS management.

What your AI agents can do

Create content item

Creates a brand new content item after you provide all necessary field values in a JSON object.

Delete content item

Removes an existing content item from the CMS based on its unique ID.

Get content item

Retrieves and displays all current data fields for one specific content entry.

+ 5 more capabilities included
Find all connected sites

The agent lists every Zesty.io instance associated with your API account using list_zesty_instances.

Map content structure

You can retrieve a list of all defined content models, identifying their unique Model ZUIDs via list_content_models.

Read specific content data

The agent fetches the full details for any single item using its unique ID with get_content_item.

Bulk list content items

You query all content entries for a specific model and instance using list_content_items, returning a list of records.

Write new content pieces

The agent creates entirely new content items by requiring you to pass in the necessary field values via create_content_item.

Modify existing entries

You update an item's data—like changing a date or correcting text—using update_content_item.

Supported MCP Clients

Claude Claude
ChatGPT ChatGPT
Cursor Cursor
Gemini Gemini
Windsurf Windsurf
VS Code VS Code
JetBrains JetBrains
Vercel Vercel
+ other MCP clients
Free for Subscribers

Waiting for input…

AI Agent

Zesty.io MCP Server: 8 Tools for Content Management

These tools allow your agent to perform all core CRUD operations against your Zesty.io CMS—from listing sites to updating individual content items.

create019d7628

create content item

Creates a brand new content item after you provide all necessary field values in a JSON object.

delete019d7628

delete content item

Removes an existing content item from the CMS based on its unique ID.

get019d7628

get content item

Retrieves and displays all current data fields for one specific content entry.

get019d7628

get instance settings

Pulls the technical configuration details and settings for your entire website instance.

list019d7628

list content items

Generates a list of all existing content entries that belong to a specific model.

list019d7628

list content models

Lists every available content structure (model) in your CMS and their unique identifiers.

list019d7628

list zesty instances

Retrieves a list of all connected websites or properties managed under this Zesty.io account.

update019d7628

update content item

Modifies the data in an already existing content item, allowing you to change fields like title or body text.

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
Start building

Make Your AI Do More

Start with Zesty.io, then connect any of our 4,700+ other servers whenever your AI needs more. One click, no limits.

  • Use this MCP plus 4,700+ 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

What you can do with this MCP connector

This MCP server connects your AI client directly to Zesty.io's API, giving your agent full control over content models, data entries, and site instances. You treat it like you're logged into the CMS yourself; your agent reads, writes, and updates structured content—think product specs or blog posts—using natural language commands without ever touching a web interface.

If you're building anything that needs to interact with enterprise-level digital assets, this is what you use. It’s developer-grade API wrapper designed for managing headless CMS data.

When your agent starts up, it first checks which sites are connected. You can list every Zesty.io instance associated with your account using list_zesty_instances. After that, if you need to know what kind of content you're dealing with, you run list_content_models to get a rundown of all available content structures and their unique Model ZUIDs.

For site-specific technical details, the agent can pull the full configuration settings for your entire website instance via get_instance_settings. This tells you exactly how that specific property is set up.

Reading data is straightforward. You don't have to guess what content exists; you first query all entries for a specific model and site using list_content_items, which returns a full list of records. If you know the exact ID, you can get every single field detail for that one item directly with get_content_item.

Writing new stuff is just as easy. When you need to create an entirely new content piece, you pass in all the necessary field values inside a JSON object, and the agent builds it out using create_content_item. If something changes—say, you correct text or update a date on an existing post—you modify that data using update_content_item.

And if an old piece of content is garbage, you wipe it clean from the system with delete_content_item by referencing its unique ID.

Your agent handles this whole process natively. For example, to update a title, your client first gets the existing data using get_content_item, then passes the new text into update_content_item. It's a clean loop that keeps all your structured content accurate and current across all connected sites.

This setup means you don't need manual logins or clicking through menus. You just tell your agent what to do—like, 'Change the main image on the Q3 report page to this new file,'—and it executes the sequence of API calls required to make it happen. It handles all that messy backend work for you.

It's built around specific actions: getting a list of sites (list_zesty_instances), mapping models (list_content_models), reading single items (get_content_item), listing batches (list_content_items), creating new content (create_content_item), modifying old entries (update_content_item), and finally, deleting records (delete_content_item). This combination gives you total control over your CMS data structure.

How Zesty.io MCP Works

  1. 1 First, subscribe to the server and provide your Zesty API Token along with a target Instance ZUID (the unique identifier for your website property).
  2. 2 Your AI client sends a natural language request (e.g., 'What are my available sites?'). The agent maps this intent to the appropriate tool, like list_zesty_instances.
  3. 3 The server executes the function call and returns structured JSON data describing the content models or items directly back to your agent for processing.

The bottom line is that you use this setup so your AI client can talk to your CMS backend without needing any manual credentials or UI interaction.

Who Is Zesty.io MCP For?

This server is built for the developer who hates manually querying APIs. It's also perfect for content managers dealing with massive sites where repetitive data entry or auditing takes up hours each week. If your job involves knowing what fields exist in a CMS, or pushing bulk updates, you need this.

Content Manager

Uses the agent to update hundreds of product descriptions across multiple site instances without logging into Zesty's web panel.

Front-End Developer

Quickly tests API data structures or checks if a specific content model (e.g., 'Hero Banner') exists by calling list_content_models from their IDE.

DevOps Engineer

Runs technical audits on instance settings and metadata using get_instance_settings to validate deployment configurations across environments.

What Changes When You Connect

  • Stop logging into the CMS UI just to check content. Use list_zesty_instances to see every property you manage at a glance, telling your agent exactly which site needs attention.
  • Understand your entire data structure instantly. Calling list_content_models gives you all the Model ZUIDs and names so your agent knows what fields are even available before attempting a write operation.
  • Audit content status quickly. Instead of manually clicking through properties, use get_instance_settings to pull technical metadata for any site—useful for pre-deployment checks.
  • Process batch updates without effort. Need to change the headline on 50 blog posts? Use list_content_items followed by a bulk update via update_content_item. The agent handles the loop.
  • Write content programmatically. Never manually create an entry again. Pass field values and use create_content_item to instantly populate new marketing or product pages.
  • Keep your data clean. When old, outdated entries pile up, use delete_content_item through the agent to maintain a strict CMS hierarchy.

Real-World Use Cases

01

The Quarterly Audit

A developer needs to verify that all 12 product lines have been set up with the required 'SKU' field. Instead of checking documentation, they tell their agent: 'List content models and find the Product Catalog model.' The agent uses list_content_models, gets the ZUID, and then runs targeted checks using list_content_items to confirm all 12 instances are present.

02

Emergency Content Fix

A marketing manager notices a typo on an old landing page that is critical. They ask their agent: 'Update the main headline for item X-456.' The agent immediately uses get_content_item to verify the target, and then executes update_content_item, fixing the mistake in seconds.

03

New Site Rollout Prep

A growth engineer is setting up a brand-new subsidiary site. They first ask their agent: 'List all my available sites.' The agent uses list_zesty_instances to confirm the new property ID, and then they use that ZUID in conjunction with tools like list_content_models to build out the necessary content structure.

04

Bulk Cleanup

An ops engineer needs to clean up outdated draft articles. They ask their agent: 'Find all published blog posts from Q1 that are marked as drafts.' The agent uses list_content_items on the Blog Model, filters the results, and then runs a series of delete_content_item calls.

The Tradeoffs

Trying to list everything at once

The user asks the agent, 'Give me all content data for every site and model.' This is vague; the API doesn't know where to start or what format you want.

Don’t ask for ‘all.’ First, use list_zesty_instances to narrow down the scope. Then, specify: 'For instance [ZUID], list content models,' which uses list_content_models, giving you a precise starting point.

Guessing Model ZUIDs

The user assumes they know the unique identifier for the Product Model and tries to use an outdated or wrong ID in list_content_items.

Always run list_content_models first. This returns all active models and their correct Model ZUIDs, ensuring your subsequent calls to list or manipulate items are accurate.

Overwriting data by accident

The user tells the agent: 'Update content item X with this JSON payload.' They forget to run get_content_item first, so they don't know what fields already exist.

Always use get_content_item before calling update_content_item. This shows you the existing schema and data, preventing accidental overwrites or missing required fields.

When It Fits, When It Doesn't

Use this Zesty.io MCP Server if your core pain point is interacting with structured content (CMS) via API calls—specifically, when you need to read, write, update, or audit model schemas and instances without a graphical interface. You must have a headless CMS setup that uses the Zesty.io platform.

Don't use this if: 1) Your data lives in a non-CMS database (e.g., pure Postgres tables); you’d need a different server type. 2) You only need to read simple, unstructured text files; a file storage tool would be better. 3) The content structure changes daily and unpredictably; while the tools handle schema listing (list_content_models), maintaining data integrity requires developer discipline.

If your task is: 'I need to know what fields are available for Product X,' use list_content_models. If your task is: 'I need to change the text of product Y,' use get_content_item followed by update_content_item. This server handles the full content lifecycle, from discovery (list_zesty_instances) to deletion (delete_content_item).

Independent Platform Disclaimer: Vinkius is an independent platform and is not affiliated with, endorsed by, sponsored by, verified by, or otherwise authorized by Zesty.io. 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

How we secure it →

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 8 capabilities that interface natively with Claude, ChatGPT, Cursor, and any MCP client. No middleware. No custom integration required.

Available Capabilities

create_content_item delete_content_item get_content_item get_instance_settings list_content_items list_content_models list_zesty_instances update_content_item

Managing site content usually means logging into 5 different dashboards.

Right now, if you need to check a single article's status, you open the CMS dashboard. If you need to audit all connected sites, you jump to the main account page. To update it? You navigate deep into the specific site's content tree, find the right model, and finally click 'Save.' It’s slow, high-friction work that involves dozens of clicks just to answer simple questions.

With this MCP server, you skip all those steps. Your agent connects directly via API. You simply say: 'List all my sites and tell me which ones need content updates.' The system runs `list_zesty_instances` and gives you a clean list. No dashboards, no clicks—just data.

Zesty.io MCP Server lets you manage models and items directly.

Before this tool, updating content meant remembering the exact Model ZUID for 'Press Releases' and then manually creating a new item record with all required fields—a process prone to human error and manual data entry failures. You had to verify the schema first.

Now, you just tell your agent: 'Create a press release about the Q4 earnings.' The server handles validating the model structure via `list_content_models`, populating the correct JSON payload for the required fields, and executing `create_content_item` in one shot. It’s precise.

Common Questions About Zesty.io MCP

How do I find out what models are available with list_content_models? +

Run the list_content_models tool. It returns a JSON array listing every content model in your CMS, along with their unique Model ZUIDs. This is essential because you need these IDs for all subsequent operations.

Is get_content_item used to read the whole site? +

No. get_content_item only pulls data for one specific content entry using its unique ID. If you want a list of many items, use list_content_items. It's about granularity.

Can I delete all old items at once? +

You can delete them in batches, but you must first run list_content_items to get the IDs of the entries you want gone. Then, pass those IDs one by one to delete_content_item.

What if I don't know my instance ZUID? +

You can find all associated properties using list_zesty_instances. This tool provides a list of all connected sites and their corresponding ZUIDs, which you then pass to other tools.

If I use `create_content_item` and get a validation error, what does that mean? +

It means the data you provided doesn't match the required structure for that model. You need to check the specific field names and data types against the content model schema before running the command.

Does `list_content_items` handle pagination if I have thousands of entries in a single model? +

Yes, the tool supports pagination. If you request more results than the default page size, your agent needs to pass the next cursor token to continue pulling items until all records are retrieved.

When I run `get_instance_settings`, what should I check if the connection fails? +

First, verify that your Zesty API Token hasn't expired. If the credentials look fine, ensure the instance ZUID you provided is active and matches the region of the data.

If my content structure changes, how do I use `list_content_models` to track it? +

The output from list_content_models shows your current schema. If you add a new field type or rename an existing one, you'll need to update the model definition before creating new items.

How do I find my Instance ZUID? +

You can list all your accessible instances using the list_zesty_instances tool, or find it in your Zesty.io URL (it starts with 8-).

Can I see all content items for a particular model? +

Yes, use the list_content_items tool with the unique ZUID of the model (starts with 6-) to retrieve all associated entries.

Is it possible to update content via the agent? +

Absolutely. Use the update_content_item tool by providing the Model ZUID, the Item ZUID, and a JSON object containing the fields you wish to modify.

More in this category

You might also like

Built & Managed by Vinkius 30s setup 8 tools

We've already built the connector for Zesty.io. Just plug in your AI agents and start using Vinkius.

No hosting. No infrastructure. No complex setup.
All 8 tools are live and waiting. You're up and running in seconds.

Claude Claude
ChatGPT ChatGPT
Cursor Cursor
Gemini Gemini
Windsurf Windsurf
VS Code VS Code
JetBrains JetBrains
Vercel Vercel
+ other MCP clients

Vinkius gives your AI agents access to the full catalog of app connectors, all fully managed, secure, and enterprise-ready. One subscription, every tool you need.

Zero hosting required Full MCP catalog included Enterprise-grade security Auto-updated by Vinkius

Built, hosted, and secured by Vinkius. You just connect and go.