# TYPO3 CMS MCP

> 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.

## Overview
- **Category:** content-management
- **Price:** Free
- **Tags:** cms, content-operations, crud-operations, site-architecture, extbase

## Description

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.

## Tools

### 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.

### get_navigation_tree
Maps out the complete, hierarchical list of navigation menu items starting from a specified page ID.

### get_rendered_page
Fetches a structured representation of what a specific TYPO3 page looks like to an end user using its path or numeric ID.

### 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 for auditing purposes.

### 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, ID, and new data payload.

## Prompt Examples

**Prompt:** 
```
Can you check the current initial boot configuration of our TYPO3 project?
```

**Response:** 
```
Initial boot grabbed: System sits at version v12.4 LTS. Found core default routing mappings in context alongside basic site language configurations spanning EN and DE arrays.
```

**Prompt:** 
```
List standard backend records available on the custom entity table 'tx_myext_domain_model_item'.
```

**Response:** 
```
Under 'tx_myext_domain_model_item', 8 distinct entries were listed. Records IDs #23 and #40 seem recently added. Would you like me to deeply inspect the payload geometry of element #23?
```

**Prompt:** 
```
Permanently delete the CMS entity under ID 644 on 'pages'.
```

**Response:** 
```
Action confirmed. Record ID 644 inside the 'pages' entity has been wiped through a deletion mutation payload. It has been successfully removed from visibility.
```

## Capabilities

### Audit Site Configuration
Checks global system constants and the core initial boot state using `list_typoscript_globals` or `get_initial_boot`.

### Map Content Hierarchy
Retrieves the full hierarchical navigation structure of a site starting from any given page using `get_navigation_tree`.

### Read and Write Records
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`).

### Inspect Page Output
Gets a structured data dump of what a specific page looks like to the end user via `get_rendered_page`.

### Manage Content Lifecycle
Deletes content records permanently using `delete_cms_entity`, or checks system connectivity with `ping_rest_api`.

## Use Cases

### 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.

## Benefits

- 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.

## How It Works

The bottom line is you describe the change or data retrieval in natural language; the agent handles the secure, structured API calls.

1. Manually subscribe to this core server context on Vinkius.
2. Provide your REST API's external TYPO_BASE_URL along with a valid TYPO3 Authorization Bearer token to the agent.
3. 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.

## Frequently Asked Questions

**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.