4,500+ servers built on MCP Fusion
Vinkius

Plasmic MCP. Manage projects, pages & components via AI.

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

Plasmic (Visual Headless Page Builder) MCP on Cursor AI Code Editor MCP Client Plasmic (Visual Headless Page Builder) MCP on Claude Desktop App MCP Integration Plasmic (Visual Headless Page Builder) MCP on OpenAI Agents SDK MCP Compatible Plasmic (Visual Headless Page Builder) MCP on Visual Studio Code MCP Extension Client Plasmic (Visual Headless Page Builder) MCP on GitHub Copilot AI Agent MCP Integration Plasmic (Visual Headless Page Builder) MCP on Google Gemini AI MCP Integration Plasmic (Visual Headless Page Builder) MCP on Lovable AI Development MCP Client Plasmic (Visual Headless Page Builder) MCP on Mistral AI Agents MCP Compatible Plasmic (Visual Headless Page Builder) MCP on Amazon AWS Bedrock MCP Support

Just plug in your AI agents and start using Vinkius.

Plasmic offers AI control over your visual headless page builder. List projects, query CMS data, check component structures, and trigger publishes—all via natural conversation.

Use your AI agent to manage web content drafts and deploy changes without leaving your code editor.

What your AI agents can do

Count cms items

Counts the total number of records in a specified Plasmic CMS database table.

Create cms item

Adds a brand-new item or draft record to any designated Plasmic CMS table.

Delete cms item

Permanently removes an existing item from a specific Plasmic CMS database table.

+ 6 more capabilities included
Project Lifecycle Control

Change project metadata, trigger global updates, or list all available projects using update_project.

Content Drafting and Publishing

Create new CMS records, update existing drafts (update_cms_item), and move them to a live state with publish_cms_item.

Data Retrieval and Inspection

Query specific content tables using filters, or get a structural JSON model of any component via query_cms_items or get_model.

Component Output Generation

Get the final HTML code for a component (render_html) or simply count records in a data table using count_cms_items.

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

Plasmic (Visual Headless Page Builder) MCP Server: 9 Tools

Use these nine dedicated tools to manage the entire lifecycle of your visual web projects—from querying raw CMS data to triggering live publishes.

count019e5d47

count cms items

Counts the total number of records in a specified Plasmic CMS database table.

create019e5d47

create cms item

Adds a brand-new item or draft record to any designated Plasmic CMS table.

delete019e5d47

delete cms item

Permanently removes an existing item from a specific Plasmic CMS database table.

get019e5d47

get model

Returns the full JSON structure (SDUI) of a project element, detailing its internal components and properties.

publish019e5d47

publish cms item

Takes a draft content item and publishes it to make it visible on the live site.

query019e5d47

query cms items

Fetches filtered lists of items from a Plasmic CMS database table based on criteria you provide.

render019e5d47

render html

Generates and returns the final, clean HTML output for a specific component instance.

update019e5d47

update cms item

Modifies the content details of an existing CMS item (e.g., changing text or images in a draft).

update019e5d47

update project

Programmatically changes project settings or overall metadata for the entire Plasmic site.

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 Plasmic (Visual Headless Page Builder), 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

You're gonna run your whole headless content flow straight from your chat window, no browser context switching required. This server gives your AI agent direct access to Plasmic’s backend functions, letting you manage entire site drafts and deploy changes right from your code editor or terminal. You get full control over the project lifecycle using simple commands.

Project Configuration and Global Control

You can change overall project settings or metadata for the whole site with update_project. This tool lets you trigger global updates that affect how Plasmic renders content across multiple pages. For listing available work, your agent pulls all defined projects when you reference the capability to list them.

Data Retrieval and Structure Inspection

Need to know what data's sitting in a CMS collection? You use query_cms_items to fetch filtered lists of records from any designated Plasmic database table based on criteria you specify. If you just need a rough count, count_cms_items tells you the total number of entries in a table. To understand how a component is built, your agent calls get_model, which returns the full JSON structure (SDUI) detailing all internal components and their properties for any project element.

Content Management: Drafting and Modification

When you're working on drafts, you manage content records using standard CRUD operations. To start fresh, your agent adds a brand-new item or draft record to the CMS via create_cms_item. If existing content needs tweaking—say, changing some body copy or swapping out an image in a draft—you call update_cms_item to modify specific details of an existing entry.

You can permanently remove records using delete_cms_item, which takes an item from any specified CMS table.

Publishing and Rendering Output

Drafting is only half the battle; you gotta get it live. To move a draft content item into a visible state, your agent executes publish_cms_item. This function makes sure that piece of content shows up on the actual site. For final output, if you need to test exactly what a component looks like before deployment, render_html generates and returns the clean HTML code for any specific component instance.

The entire process operates by having your AI client treat these tools like native functions; it calls them when you ask it to perform an action—like 'Give me the latest copy for the pricing page' or 'Check if the contact form is ready.' When the agent executes a tool call, it returns the raw data or confirmation back to you in plain language.

You’re essentially running core CMS operations without leaving your IDE. This gives your AI client power over Plasmic's backend functions, letting you manage content and project states entirely through natural conversation.

How Plasmic MCP Works

  1. 1 First, you subscribe to this server and input your Plasmic Project ID and API Token.
  2. 2 Next, you ask your AI client for a specific task—for example, 'List all pages in my Marketing Site project.'
  3. 3 The agent runs the appropriate tool (like one of the listing tools), gets the data back, and reports the result to you.

The bottom line is: You never have to switch windows or copy IDs; your AI handles the API calls for you.

Who Is Plasmic MCP For?

This server targets developers and content managers who are sick of context switching. It's for the front-end engineer who needs to check a component structure without opening the Plasmic Studio, or the marketing lead who just wants to verify if their latest copy has gone live—all without leaving their chat window.

Front-End Developer

Using get_model, they inspect component structures on the fly while coding, verifying that a parent component accepts the right props.

Content Manager

They use query_cms_items and update_cms_item to check content lists or fix typos in draft articles without touching the visual editor.

DevOps Engineer

The engineer triggers project deployments using publish_cms_item directly from an agent workflow, bypassing manual CI/CD steps for quick hotfixes.

What Changes When You Connect

  • Instant Site Updates: You don't manually trigger builds. Calling publish_cms_item pushes content drafts live instantly, giving you immediate proof that your changes are visible to users.
  • Deep Component Inspection: Need to know how a component is built? Use get_model. It returns the JSON structure of any element, letting you inspect its internal logic without opening the visual builder.
  • Efficient Content Auditing: Forget clicking through pages. Run query_cms_items to fetch all articles tagged 'Q3 Marketing' and check their status in one single API call.
  • Reliable Content Modification: When a copy needs fixing, you don't rewrite the whole thing. Use update_cms_item to target specific fields (like headline or date) across thousands of records efficiently.
  • Full Project Control: Want to change site-wide settings? The update_project tool lets your agent modify core project metadata directly, which is critical for staging environment switches.

Real-World Use Cases

01

The Quick Hotfix

A client reports a typo on the homepage. Instead of logging into Plasmic Studio and navigating deep into component settings, you ask your agent to run query_cms_items for the 'Homepage Banner' content. You use update_cms_item to fix the word, then immediately call publish_cms_item. Problem solved in three tool calls.

02

SEO Content Audit

You need to confirm every product page has a unique H1 tag. You ask your agent to run query_cms_items across the 'Product' table, filtering by metadata fields for the H1 count and content status. This quickly identifies all missing or incorrect titles before launch.

03

Component Debugging

The e-commerce checkout page looks broken in staging. You ask your agent to run get_model on the 'Product Card' component. The returned JSON model shows that a necessary prop (is_discountable) is missing, allowing you to fix the code without guessing.

04

Initial Project Setup

You just started a new client site and need to verify all existing data tables are populated. You ask your agent to run count_cms_items for every core collection (e.g., 'Testimonials', 'Team Members'). The agent reports the total count for each, confirming you have enough starting content.

The Tradeoffs

Relying on visual inspection

Assuming a page is updated just because it was saved in Plasmic Studio. You might think 'It's done!' but the changes aren't live.

Always confirm your workflow by running publish_cms_item after making any updates. This forces the content into the production state, confirming visibility.

Updating without context

Calling update_cms_item with only partial data and forgetting which specific item ID you targeted.

Before updating, always use query_cms_items first. Get a list of IDs and confirm the exact record you need to modify before sending the update payload.

Skipping structure checks

Trying to render HTML (render_html) for a complex component without checking its underlying definition.

Run get_model first. This gives you the complete JSON schema, ensuring that when you try to render or update content, you use valid data types and required props.

When It Fits, When It Doesn't

Use this MCP Server if your primary bottleneck is moving data between Plasmic Studio and your code editor. If you need to check project structure (get_model), query a specific list of records (query_cms_items), or move content from draft status to live production, these tools are essential.

Don't use this server if all you need is simple text editing on one page. For minor changes like that, the native Plasmic Studio might be faster. But when your task involves multi-step operations—like 'Find the 5 oldest blog posts, update their featured image, and then publish them'—you absolutely need the granular control provided by query_cms_items, update_cms_item, and publish_cms_item working together.

Independent Platform Disclaimer: Vinkius is an independent platform and is not affiliated with, endorsed by, sponsored by, verified by, or otherwise authorized by Plasmic. 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 9 capabilities that interface natively with Claude, ChatGPT, Cursor, and any MCP client. No middleware. No custom integration required.

Available Capabilities

count_cms_items create_cms_item delete_cms_item get_model publish_cms_item query_cms_items render_html update_cms_item update_project

Checking content status used to mean jumping between 5 different tabs.

Today, if you need to check a site’s structure or confirm an article's status, you have to open the Plasmic Studio. Then you click 'Projects,' then navigate into 'Pages,' and finally try to find the component settings for that specific item ID. It takes three clicks, two context switches, and half your afternoon.

With this MCP server, you simply ask your agent: 'List all pages in Project X.' You get a clean list of IDs and structures back instantly. You control project discovery and page inventory without ever leaving your chat window.

Plasmic MCP Server: Manage content drafts with `update_cms_item`.

Previously, changing a single paragraph required opening the CMS editor for that specific item, finding the right field (is it 'Body Text' or 'Main Copy'? Nobody knows), and manually pasting the new text. If you forgot to save, or if the content was locked, you wasted time.

Now, your agent handles it. You tell it: 'Change the pricing paragraph on the About Us page.' The tool calls `update_cms_item` directly with the correct ID and field name, guaranteeing the change gets applied instantly.

Common Questions About Plasmic MCP

How do I use `get_model` to debug a component? +

get_model returns the full JSON representation (SDUI) of any element. You pass it the element ID, and you get back a schema that shows exactly how all its nested components are structured.

What's the difference between `query_cms_items` and listing pages? +

query_cms_items is for content records stored in CMS tables; it lets you filter by specific fields like 'Author' or 'Date.' Listing pages handles the site structure (routes) itself.

Do I have to manually run a build after using `publish_cms_item`? +

No. The tool manages the publish state. Calling publish_cms_item triggers the necessary deployment action, making the content live immediately without manual CI/CD steps.

`update_project` is for what kind of changes? +

update_project handles overarching site configuration metadata—things like changing the primary domain or updating global style tokens that affect every page in the project.

When I use `query_cms_items`, can I filter the results based on specific criteria? +

Yes, you specify filters in your query parameters. You don't just pull everything; you define exact criteria—like only records tagged 'Draft' or created after a certain date. This keeps your data set small and focused.

If I need to create many new entries, how does `create_cms_item` handle bulk operations? +

The tool processes items one by one per call. For large batches, you'll want your agent to loop through the records and execute multiple calls sequentially. This ensures every item gets created without hitting limits.

What security checks are in place when I use `delete_cms_item`? +

The server verifies your permissions before running the delete command. It won't let you remove sensitive data unless your connected agent has explicit write access rights for that specific collection.

How does `render_html` handle large or complex components to maintain performance? +

It optimizes the output by fetching only the necessary generated HTML. It treats the component's structure as a single unit, preventing excessive data transfer and keeping the resulting code efficient.

Can I list all my Plasmic projects to find a specific Project ID? +

Yes! Use the list_projects tool. Your agent will return a list of all projects associated with your credentials, including their names and unique IDs.

How do I see which pages are currently built inside a project? +

Simply ask the agent to run get_project_pages with the target Project ID. It will list all pages, their paths, and basic metadata.

Is it possible to publish my changes to production using the AI? +

Yes. By using the publish_project tool, you can trigger a new publish for a specific project ID, making your visual changes live immediately.

More in this category

You might also like

Built & Managed by Vinkius 30s setup 9 tools

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

No hosting. No infrastructure. No complex setup.
All 9 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.