TYPO3 CMS MCP for AI. Programmatically manage every piece of content on your site.
Gemini Works with every AI agent you already use
…and any MCP-compatible client
Connect to your AI in seconds.
TYPO3 CMS MCP Server gives your AI client direct API access to the TYPO3 backend. You can programmatically read site structure, list global configurations, create new content entities (Extbase), update record fields by ID, and delete records—all without writing boilerplate PHP or clicking through admin menus.
What your AI can do
Create cms entity
Creates a new TYPO3 content record or Extbase entity using provided data and an entity name.
Delete cms entity
Permanently removes a specific TYPO3 record. This action cannot be undone.
Get initial boot
Retrieves the system's global configuration details and the root page schema from TYPO3.
Checks global system constants and the core initial boot state using list_typoscript_globals or get_initial_boot.
Retrieves the full hierarchical navigation structure of a site starting from any given page using get_navigation_tree.
Performs granular data manipulation, allowing you to list records (list_backend_records), fetch single entities (get_single_record), create new ones (create_cms_entity), or update existing fields (update_cms_entity).
Gets a structured data dump of what a specific page looks like to the end user via get_rendered_page.
Deletes content records permanently using delete_cms_entity, or checks system connectivity with ping_rest_api.
Ask an AI about this
Waiting for input…
TYPO3 CMS: 10 Tools for Content Entity Management
Use these tools to programmatically create, delete, retrieve, and update every type of record within your TYPO3 content management system.
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 TYPO3 CMS on VinkiusCreate Cms Entity
Creates a new TYPO3 content record or Extbase entity using provided data and an entity name.
Delete Cms Entity
Permanently removes a specific TYPO3 record. This action cannot be undone.
Get Initial Boot
Retrieves the system's global configuration details and the root page schema from...
Get Navigation Tree
Maps out the complete, hierarchical list of navigation menu items starting from a...
Get Rendered Page
Fetches a structured representation of what a specific TYPO3 page looks like to an...
Get Single Record
Retrieves the full data payload for one specific TYPO3 record when you know its unique ID number.
List Backend Records
Lists multiple records from a named entity, optionally filtering by parameters or routes.
List Typoscript Globals
Outputs all global settings and constants defined within the TYPO3 system context...
Ping Rest Api
Checks if the connection to the TYPO3 REST API is active and responding correctly.
Update Cms Entity
Modifies specific fields of an existing content record by providing its entity name...
Security and governance baked right in.
Pick your AI client below to get set up. Just create a Vinkius account, subscribe, and you're instantly up and running. We handle the entire backend infrastructure, delivering out-of-the-box support for HTTPS Streamable, SSE, and OAuth2—zero messy routing required.
Claude AI
Open Claude Settings
Go to claude.ai, click your profile icon, then navigate to Customize → Connectors.
Add Custom Connector
Click the "+" button and select Add custom connector. Paste your Vinkius endpoint URL:
https://edge.vinkius.com/[YOUR_TOKEN_HERE]/mcp
Replace [YOUR_TOKEN_HERE] with your token
from cloud.vinkius.com. For OAuth-protected servers, expand
Advanced settings to add credentials.
Start a conversation
Open a new chat. The TYPO3 CMS integration is available immediately — no restart needed.
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 TYPO3 CMS, then connect any of our 5,000+ other servers whenever your AI needs more. One click, no limits.
- Use this MCP plus 5,000+ 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 TYPO3 CMS. 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 connection provides 10 powerful capabilities that interface natively with Claude, ChatGPT, Cursor, and other compatible AI platforms. No middleware. No custom integration required.
Manually debugging content requires jumping between the admin panel and your code editor.
Today, finding a single record's status means opening the CMS dashboard, navigating through menus (sometimes 5 levels deep), searching by title, clicking into the entity view, and finally copying the ID. If you need to check fifty records, you do that fifty times.
With this MCP server, your agent handles all of it. You tell it which list of IDs you care about, and it uses `list_backend_records` or `get_single_record`. You get a clean JSON array back in seconds. No clicking, no copy/paste, just data.
TYPO3 CMS MCP Server: Programmatically control every content entity.
Instead of writing complex code to handle the initial setup—retrieving basic system variables and mapping core routing definitions—you just call `get_initial_boot`. It pulls everything you need in one go.
It's a massive time saver. You stop debugging boilerplate PHP code for simple data checks, and start focusing on the business logic that actually matters.
What your AI can actually do with this
You connect your AI client straight into the TYPO3 backend. You get API access to everything—the core content operations, the global settings, the site structure—and you treat all of it like clean data payloads for your agent. You're done writing boilerplate PHP or clicking through a dozen admin menus just to change one field.
Checking System Health and Auditing Configuration
The first thing you gotta do is make sure everything's talking. Run ping_rest_api to confirm the connection to the TYPO3 REST API is live and responding correctly; if it fails, don't waste time on anything else.
If you need a full system audit, you start by checking global constants. The list_typoscript_globals tool outputs every single global setting and constant defined in your TYPO3 context—it’s perfect for auditing initial setup without needing admin access to every corner of the backend. You can also run get_initial_boot to get a clean dump of the system's root page schema, which gives you a foundational view of how the site boots up.
Mapping and Inspecting Content Structure
Need to know what pages exist? The get_navigation_tree tool maps out the whole thing. It pulls a complete, hierarchical list of every navigation item starting from any specific page ID you hand it. This lets your agent isolate content deep within sub-folders using pure API calls.
Want to see how a page looks on the live site? Use get_rendered_page. You give it a path or a numeric ID, and it sends back a structured data dump of what an end user actually sees. It’s way better than guessing based on source code.
Performing Granular Data Manipulation (The CRUD Cycle)
Your AI client can now manage content like a pro. When you need to read records, the get_single_record tool fetches all data for one specific TYPO3 record when you already know its unique ID number. If you gotta see multiple pieces of content from the same type—say, every product listing—you'll run list_backend_records.
You can even filter that list by parameters or routes to narrow down what you need.
If you’re building something new, use create_cms_entity. Just give it an entity name and a data payload, and it spins up a brand-new TYPO3 content record or Extbase entity for you.
Need to adjust something that's already there? The update_cms_entity tool lets your agent modify specific fields of an existing content record. You just gotta provide the entity name, the ID number, and the new data payload with what you want changed.
Finally, if a piece of content is dead, you can wipe it out permanently using delete_cms_entity. This removes a specific TYPO3 record entirely; remember, this action isn't reversible.
019d7617-7146-7253-b364-faf10659af84 
Here's how it actually works
The bottom line is you describe the change or data retrieval in natural language; the agent handles the secure, structured API calls.
Manually subscribe to this core server context on Vinkius.
Provide your REST API's external TYPO_BASE_URL along with a valid TYPO3 Authorization Bearer token to the agent.
Engage your preferred AI client (Claude, Cursor, etc.) and instruct it: 'Use the available tools to X.' The agent then executes the necessary protocol payload over REST.
Who is this actually for?
This is for platform engineers and backend developers who are sick of manually navigating admin interfaces just to pull a piece of configuration data. If your job involves writing scripts that interact with content models—not just consuming them—you need this. It gives you programmatic control over the entire CMS lifecycle without leaving your IDE.
Uses update_cms_entity to patch fields in a record or uses list_backend_records to pull lists of objects for batch processing.
Runs get_initial_boot and list_typoscript_globals to audit the entire system's foundational settings before deployment.
Uses get_navigation_tree on multiple pages to confirm site structure integrity and find broken links programmatically.
What Changes When You Connect
Audit global settings without clicking: Use list_typoscript_globals to instantly pull all system constants. You skip the headache of navigating multiple admin sections just to check a single variable.
Full Content Control: Need to fix a broken element? Instead of manually editing, use update_cms_entity. Just tell your agent the record ID and which fields need changing; it handles the API payload.
Site Map Generation: Use get_navigation_tree to map out the entire site's structure. This is fast and reliable—you get a clean JSON mesh, not a messy screenshot of the admin tree.
Previewing Output: Don't trust cached data. Run get_rendered_page on any ID you want to check. You see the structured payload of what the user actually sees at runtime.
Bulk Content Management: Use list_backend_records when you need a list of 50 items from a custom table. It avoids writing complex database queries and keeps everything inside the CMS logic.
See it in action
Updating hundreds of product descriptions.
The marketing team updated pricing data, but you need to update the associated content description fields across 300 records. Instead of writing a massive script that handles IDs and JSON mapping, you tell your agent: 'Update the 'product_desc' field on entity X for these 300 IDs.' The agent coordinates the high-volume update_cms_entity calls.
Debugging an unknown site layout issue.
A client reports that a specific page element looks wrong. You use get_rendered_page with the page's canonical path. This returns a structured payload, letting you pinpoint if the problem is in the content (data) or the template (structure).
Checking system compliance post-deploy.
A mandatory audit requires checking all global variables for deprecated settings. You run list_typoscript_globals. This single tool call dumps every setting, letting you compare it against a known list of required constants.
Building an internal site sitemap.
You need to programmatically generate a full map of all reachable pages. You start by running get_navigation_tree from the root node, which provides the full ID list needed for your build process.
The honest tradeoffs
Assuming data completeness
You try to read a record using only its slug or title. The system fails because it needs an explicit, numeric ID.
Always start by running list_backend_records with the entity name and optional query parameters first. This validates that the content exists and gives you the required IDs before calling get_single_record.
Overwriting critical settings
You use update_cms_entity on a global constant without confirming its current value, potentially breaking site routing.
Before any write operation, run get_initial_boot or list_typoscript_globals. This lets you read the existing configuration state and confirm what values are currently set.
Treating data as a black box
You just try to send random JSON data via create_cms_entity without knowing the required schema or parent node ID.
First, use get_navigation_tree to understand the hierarchy. Then, consult the entity documentation before attempting creation to ensure your payload structure is correct.
When It Fits, When It Doesn't
Use this server if your task involves programmatic interaction with content records or global CMS settings. If you need to read data for an audit, always start by calling get_initial_boot or get_navigation_tree first; this establishes the current state and prevents unexpected errors. Only move to writing (using create_cms_entity, update_cms_entity) after your agent has used a read tool to confirm the exact ID, entity name, and data structure you intend to modify. Don't use it if you just need simple external API calls—this is for internal CMS backend logic only. If you are unsure whether a setting is global or local, run list_typoscript_globals to check its scope.
Questions you might have
How do I check if the TYPO3 CMS backend is online before running updates? +
Use ping_rest_api. This tool confirms connectivity to the REST API, ensuring your subsequent write operations won't fail because of a simple network or service outage.
Which tool do I use if I only know the page URL? +
Use get_rendered_page. You provide the canonical path or ID, and it returns the structured data payload for that specific view. It's faster than manually viewing the live site.
Is there a way to check all global CMS settings? +
Yes, run list_typoscript_globals. This tool dumps every system constant and configuration setting available in the context. You don't have to click into dozens of separate admin modules.
Can I list records from a custom Extbase table? +
Yes, use list_backend_records. Just provide the entity name and any necessary query parameters. It handles listing content for specific routes or tables across your CMS.
When using `delete_cms_entity`, what precautions should I take before running a permanent deletion? +
The action is irreversible. You must confirm both the entity name and the record ID multiple times in your prompt. The agent will require explicit confirmation before sending the mutation payload.
How does `create_cms_entity` handle schema validation for complex custom records? +
You provide a raw JSON object, but the tool validates it against the target entity's defined structure. If any field is missing or typed incorrectly, the process fails before writing to the database.
If I use `get_navigation_tree`, does it handle very deep site architectures efficiently? +
The tool retrieves the full hierarchical menu starting from a page. For extremely deep sites, keep an eye on potential rate limits or pagination requirements to ensure you get every node.
What credentials are required for `update_cms_entity` to successfully modify a record? +
You need the TYPO3 Authorization Bearer token and the specific entity name. The agent uses these details to authenticate and target the correct endpoint for updating fields.
Can it retrieve both the navigation tree and single rendered pages autonomously? +
Yes. Command the LLM to 'get_navigation_tree' from ID 1, revealing the layout. Finding a curious page, you can instruct it to 'get_rendered_page' supplying its new ID to dissect content instantly.
How does the assistant handle adding complex backend module data like Extbase records? +
Using the 'create_cms_entity' endpoint tool, you just tell the AI the physical target database component and pass your JSON. TYPO3 resolves it server-side identically as if inserted from the admin view.
Is there a fast way to verify if my TYPO3 API authentication block is working? +
Run a request with the 'ping_rest_api' capability. It triggers a lightweight, zero-payload call directly returning successful metadata from your host validating you have unbridled authorization natively.
We've already built the connector for TYPO3 CMS. Just plug in your AI agents and start using Vinkius.
No hosting. No infrastructure. No complex setup.
All 10 tools are live and waiting.
You're up and running in seconds.
Gemini 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.
Built, hosted, and secured by Vinkius. You just connect and go.