mcp-cinema4d
Summary: mcp-cinema4d exposes a typed, undo-safe bridge that lets an MCP-compatible LLM inspect and modify a running Cinema 4D 2026 session — reading scenes, authoring objects/materials/takes, driving rigs, and rendering — through ~72 tools without pasting arbitrary Python.
Connectivity & escape hatches —
pingthe bridge;call_commandfor any C4D command id; opt-inexec_python;undoto pop the undo stack;batchfor single-undo-group multi-op workflows.Scene inspection —
list_entitiesfor objects/render data/takes/materials/tags/video posts/shaders;describefor parameter dumps;get_params/get_container/dump_shaderfor values, raw containers, and shader trees;list_layers,list_markers,list_documents,list_tracks,get_keyframes,get_document_state.Entity authoring —
create_entity,remove_entity,clone_entity,move_entity(reparent/reorder), plusset_params,set_transform,set_mesh/set_mesh_selection,assign_material,assign_to_layer.Shot & take setup —
create_render_data,create_take,take_override,set_document(fps/frame range/camera/take), timeline marker CRUD (create_marker/set_marker/remove_marker),import_scenefor merging files.Materials & node graphs — classic shader chains plus Maxon node graphs (standard/Redshift/scene-nodes):
list_graph_nodes,list_graph_node_assets,get_graph_info,apply_graph_description,set_graph_port,remove_graph_node.Xpresso rigging —
list_xpresso_nodes,apply_xpresso_graph,set_xpresso_port,remove_xpresso_nodefor building and editing classic GvNodeGraphs.Animation —
set_keyframe,get_keyframes,delete_keyframe,delete_track,sample_transformto evaluate object transforms across frames.Modeling & mesh —
modeling_command(CSO, Make Editable, Subdivide, Connect, etc.),get_mesh,set_mesh,set_mesh_selection.Selection & user data —
get_selection/set_selection;add_user_data/list_user_data/remove_user_datafor rigging control exposure.MoGraph —
list_mograph_clonesto sample cloner/effector output transforms.Document I/O —
save_document(c4d/abc/fbx/obj/stl/ply/usd/gltf),open_document,new_document,list_documents,set_active_document,close_document(force-gated).Rendering —
render(active RenderData, 180s timeout) andpreview_render(fast Viewport/Constant-Lines sketch render returning inline base64 PNG, optional disk save).Layers —
create_layer,list_layers,assign_to_layer,get_object_layer,set_layer_flags(solo/view/render/locked/etc.).Plugins & multi-instance (opt-in) —
list_plugins, and withC4D_MCP_ENABLE_MULTIINSTANCE=1,list_instances/set_active_instance/launch_instance/stop_instanceto drive several Cinema 4D processes.Housekeeping —
reset_scenefor prefix-scoped or full scene cleanup.
Provides tools for controlling Cinema 4D scenes, including scene audits, shot setup, material work, procedural edits, and Xpresso rigs.
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@mcp-cinema4d Build a node material with noise driving roughness"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.

mcp-cinema4d
Let an LLM drive Cinema 4D. mcp-cinema4d bridges MCP-compatible clients (Claude Desktop, Claude Code, or any other stdio-capable MCP client) to a running Cinema 4D 2026 session so the model can inspect scene hierarchy, author shots, build node materials, and rig animation through a typed, undo-safe tool layer — not arbitrary Python pasted into a Script Manager.
Cinema 4D now ships an official MCP server. From Cinema 4D 2026.4, Maxon builds an MCP server into Cinema 4D itself: nothing to install, set up from Preferences → MCP, and supported by Maxon. If you run 2026.4 or later and simply want an AI assistant in Cinema 4D, start there — see Maxon's MCP Server page and documentation.
mcp-cinema4d is an independent community project. It remains an option where the built-in server does not fit:
Cinema 4D 2026.0–2026.3, which have no built-in server.
Several Cinema 4D processes from one session (multi-instance mode), which the built-in server's documentation does not cover.
Open source — read, audit, or extend the tools and the bridge yourself.
Do not register both servers in the same client. Their tool sets overlap (both expose exec_python, for example), so the model is offered two competing sets of Cinema 4D tools. Maxon's FAQ likewise asks you to switch third-party servers off while you use the built-in one.
Good for:
Scene audits — "List every object on the
herolayer; flag any with non-uniform scale or missing Texture tags."Shot setup — "Create a 1920×1080 RenderData, a camera at (0, 150, -400), and a Take that uses both."
Material work — "Build a Redshift node material with a noise texture driving roughness at 0.4 gain."
Procedural edits — "On every Subdivision Surface in the scene, reduce editor/render levels by 1."
Xpresso rigs — "Build a 3-gear meshing rig where the master gear's pitch radius dynamically drives the others' size and counter-rotation via an Xpresso graph."
Do not proceed unless you understand what this does. An LLM with a live connection to Cinema 4D can read your scene, write to it, and (if you opt in) execute arbitrary code on your machine. In concrete terms:
Your scene data leaves your machine. Object names, hierarchy paths, material/parameter values, imported file paths — whatever the LLM reads via
list_entities/describe/get_container/dump_shader/get_mesh— is forwarded to your chosen LLM provider and may be logged by your MCP client. Under NDA or on unreleased IP? Confirm with your studio/legal team first that the provider's retention policy and your client's logs are acceptable.The LLM gets write access. It can create, mutate, and delete objects, tags, materials, takes, render data, and layers; import / merge / open / save files; and render. Ctrl/Cmd-Z covers most edits —
save_document,open_document,render, and somecall_commandinvocations do not.Arbitrary Python is off by default.
exec_pythonruns unrestricted code with the full authority of the Cinema 4D process (file I/O, subprocess, network). Enabled only whenC4D_MCP_ENABLE_EXEC_PYTHON=1is set on both sides; turn it back off when you no longer need it. The same applies to plugin types that store Python source in their container — Python tag, Python generator, MoGraph Python effector, Python field, and the Xpresso Python operator. Creating or editing them is gated behind a separateC4D_MCP_ENABLE_PYTHON_OPS=1opt-in, since their code parameter is RCE-equivalent toexec_python.
Before first use: back up (or commit) your scene, start on a throwaway project, and leave your MCP client's per-call approval prompts enabled. See Security before exposing the bridge beyond loopback.
Architecture
MCP client
↓ stdio
MCP server (this repo, Node.js)
↓ TCP, JSON Lines (default 127.0.0.1:18710)
cinema4d_mcp_bridge (Python plugin inside C4D)
↓
Cinema 4DTwo pieces to install: the MCP server (this npm package, runs as an MCP stdio process) and the bridge plugin (Python, lives inside Cinema 4D). C4D must be running for the bridge to respond.
Related MCP server: Cinema4D MCP
Quickstart
Assuming you already have Cinema 4D 2026.0.0+ and Node.js 24+.
Install the bridge plugin into Cinema 4D (one-off). Download the latest
cinema4d_mcp_bridge-<version>.zipfrom the Releases page and extract thecinema4d_mcp_bridge/folder into your Cinema 4D plugins directory (see Installing the bridge plugin for platform-specific paths).Launch (or restart) Cinema 4D. The C4D console should print
[cinema4d_mcp_bridge] listening on 127.0.0.1:18710.Smoke-test the MCP server from the CLI:
echo '{"jsonrpc":"2.0","id":1,"method":"tools/call","params":{"name":"ping","arguments":{}}}' \ | npx -y @kumoproductions/mcp-cinema4d # → {"jsonrpc":"2.0","id":1,"result":{"content":[{"type":"text","text":"{\"pong\": true, ...}"}]}}
Then wire it into your MCP client (see Client configuration) and try:
"List every object in the scene, then add a cube named
hero200 units above the origin."
The LLM will call list_entities → create_entity in sequence; you should see a new cube appear in the viewport.
Prefer running from a local checkout? See CONTRIBUTING.md for the source-install flow.
Client configuration
Generate a random token and set it on both the MCP server process (via the client's env map, below) and the Cinema 4D launch environment. The bridge rejects mismatched requests (constant-time compare); the Node client forwards the value automatically. Strongly recommended — localhost is not a trust boundary on a shared workstation.
openssl rand -hex 16Register the MCP server in your client with the token in the env map:
{
"mcpServers": {
"cinema4d": {
"command": "npx",
"args": ["-y", "@kumoproductions/mcp-cinema4d"],
"env": {
"C4D_MCP_TOKEN": "paste-your-random-hex-here"
}
}
}
}Client | Config file |
Claude Desktop / Claude Code |
|
Other MCP clients | see the client's docs for registering a stdio server |
The same C4D_MCP_* variables must also be set in the Cinema 4D launch environment — the bridge plugin reads them at C4D startup. macOS: open -a "Cinema 4D" --env C4D_MCP_TOKEN=... (or export in your shell profile before launch). Windows: set as User environment variables and restart C4D.
To change the bridge socket, set C4D_MCP_PORT (and optionally C4D_MCP_HOST — see Security) alongside C4D_MCP_TOKEN in the same env map, plus the C4D launch env.
Tools
72 tools across 17 groups. The LLM picks tools itself based on the prompt — you rarely invoke them directly. See docs/TOOLS.md for the full table with per-tool descriptions.
Group | Count | What's in it |
Basics | 4 |
|
Script-style | 5 |
|
Generic CRUD | 9 |
|
Shot setup | 11 | Document state, fps / frame range / camera, |
Selection · Hierarchy | 4 | Active selection read / write; reparent, reorder, clone. |
Modeling · Mesh | 4 |
|
Document I/O | 6 |
|
Node graphs | 10 | Node-material graphs (walk / asset enum / |
Tag helpers · Animation | 5 |
|
Transforms · User data · MoGraph | 5 |
|
Layers | 5 | Enumerate, create, assign, query, flag toggles (solo / view / render / locked / …). |
Instances (opt-in) | 4 |
|
Entity handles
Every CRUD tool identifies entities by a typed handle object. The resolver raises on ambiguous names — prefer path when a scene contains duplicates.
Kind | Shape |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
name lookups are strict: if several entities share the name, the bridge returns an error listing up to five candidate paths so you can switch to a path-based handle. create_entity always returns the freshly-resolved handle (objects include path; shaders include both name and index) so chained edits stay stable.
Installing the bridge plugin
Grab the latest cinema4d_mcp_bridge-<version>.zip from
Releases
and extract the inner cinema4d_mcp_bridge/ folder into your Cinema 4D plugins
directory:
OS | Typical plugins directory |
Windows |
|
macOS |
|
You can also register a custom search path via Cinema 4D's Preferences → Plugins → Add and extract the zip there instead.
Launch (or restart) Cinema 4D after extracting. The plugin only reloads when C4D restarts.
Keep the plugin version pinned to the npm package version you run — a version mismatch surfaces as unknown command: <tool> in the bridge log. See CONTRIBUTING.md if you want to run a development checkout instead.
Official releases only come from two places: the npm package @kumoproductions/mcp-cinema4d and the GitHub Releases page under kumoproductions/mcp-cinema4d. If you obtained a zip or a scoped npm package from anywhere else claiming to be this plugin, treat it as untrusted.
Configuration
Var | Side | Default | Notes |
| both |
| Host for the TCP bridge. Legacy aliases: |
| both |
| Port for the TCP bridge. Legacy aliases: |
| both | unset | Opt-in. Set to |
| C4D plugin | unset | Opt-in. Set to |
| both | unset | Shared secret. When set on the C4D side, the Node client must send the same value. Strongly recommended. |
| C4D plugin | unset | Required to bind |
| MCP server | unset | Opt-in. Set to |
| MCP server | auto-detect | Cinema 4D executable for |
| MCP server |
| Instance slots including the primary; instance |
Multiple Cinema 4D instances
Off by default. Set C4D_MCP_ENABLE_MULTIINSTANCE=1 on the MCP server to drive several Cinema 4D processes from one server — e.g. a scratch instance for a heavy test render while the primary scene stays untouched.
list_instancesshows every reachable instance. Instance0is the primary (C4D_MCP_PORT); the others live onC4D_MCP_PORT + id, so ids stay stable across server restarts and instances a previous session launched are picked up again.launch_instancestarts another Cinema 4D withg_allowParallelInstance=true(Cinema 4D's own switch that lifts its one-instance-per-installation rule), its own bridge port, and the server's environment — token and opt-ins included. A cold start takes 1–2 minutes and several GB of RAM per instance;C4D_MCP_MAX_INSTANCEScaps the total (default 3, primary included).Every other tool gains an optional
instanceargument. Calls without it go to the active instance (set_active_instance). When issuing calls in parallel against different instances, passinstanceexplicitly — the active instance is shared session state.stop_instancequits a secondary instance, discarding its unsaved documents. It never targets instance0, and the bridge only honoursquitwhenC4D_MCP_ENABLE_MULTIINSTANCEis set in its own environment — true for launched instances, not for a Cinema 4D you started yourself.Instances launched by the server keep running when the server exits. All instances share one preferences folder, and the last one to quit writes the preferences — avoid changing settings in scratch instances.
Security
Even without exec_python, many tools mutate state: call_command, set_params, import_scene, render, remove_entity, save_document, open_document, new_document. Treat the bridge like a local shell, not a sandbox.
exec_pythonis opt-in. It runs unrestricted Python on Cinema 4D's main thread (file I/O, subprocess, network). Hidden and rejected by the bridge unlessC4D_MCP_ENABLE_EXEC_PYTHON=1is set on both the MCP server process and the Cinema 4D process. Turn it back off when you no longer need it — set-and-forget is how accidents happen.Python-bearing plugin types are opt-in too. Python tag (
Tpython), Python generator (Opython), MoGraph Python effector, Python field (Fpython), and the Xpresso Python operator all store caller-supplied source code in their container and run it on scene evaluation — i.e. they are RCE-equivalent toexec_python. The bridge refusescreate_entity,set_params,apply_xpresso_graph, andtake_overrideoperations targeting these types unlessC4D_MCP_ENABLE_PYTHON_OPS=1is set on the Cinema 4D side. Listing / reading / removing existing instances is unaffected.Set a shared-secret token (
C4D_MCP_TOKEN). Localhost is not a trust boundary — any local process running as your user can otherwise connect. See Client configuration for the JSON snippet.Loopback default + remote opt-in. The bridge binds to
127.0.0.1by default. BindingC4D_MCP_HOSTto a non-loopback interface refuses to start unlessC4D_MCP_ALLOW_REMOTE=1is also set — guarding against a one-character typo (0.0.0.0) exposing C4D to the LAN.Multi-instance mode spawns processes. With
C4D_MCP_ENABLE_MULTIINSTANCE=1,launch_instancestarts Cinema 4D executables. The binary comes only fromC4D_MCP_EXEor the default install location — never from tool arguments — and the new process inherits the server's environment, so the token and everyC4D_MCP_ENABLE_*opt-in apply to it as well. Off by default.Only connect MCP clients you trust. Review their tool-use permissions so mutating tools (especially
exec_pythonif opted in) are not auto-approved.Indirect prompt injection via scene content. Scene data (object names, parameter strings, imported file paths) flows back to the LLM through
list_entities/describe/get_container/dump_shader/get_mesh. Whenexec_pythonis enabled, a malicious string in a scene can steer the model into running arbitrary Python. Don't runimport_sceneagainst untrusted.c4d/.fbx/.abcfiles whileexec_pythonis on, and rely on your MCP client's per-call approval forexec_python/call_command/save_document/import_scenerather than blanket-approving them.Audit log. Every
exec_pythoncall records the code body to the local bridge log (%TEMP%/cinema4d_mcp_bridge.logon Windows,$TMPDIR/cinema4d_mcp_bridge.logon macOS) for after-the-fact review. The log is append-only with no rotation — prune it manually if it grows.
export C4D_MCP_TOKEN="$(openssl rand -hex 16)" # set in C4D launch env too
npx -y @kumoproductions/mcp-cinema4dTroubleshooting
Symptom | Likely cause / fix |
| C4D isn't running, plugin didn't load, or a firewall is blocking localhost. Check the C4D console for the |
Plugin loads but the | Usually a Python import error in |
| Another process already owns that port. Either quit it, or set both |
| Bridge plugin is older than the npm package. Download the matching release zip, re-extract it into your plugins folder, and restart C4D. |
| Two or more scene objects share the name. Use a path-based handle: |
|
|
| You tried to create or edit a Python-bearing entity (Python tag, Python generator, MoGraph Python effector, Python field, Xpresso Python operator). Off by default. Set |
Still stuck? Open an issue with the bridge log, your OS, Cinema 4D version, and the tool call that failed.
Known limitations
modeling_command make_editableis unreliable on Cinema 4D 2026. The SDK'sSendModelingCommandhandling ofMCOMMAND_MAKEEDITABLEshifts across builds — sometimes it returns the new polygon object, sometimes it removes the source without inserting a replacement. Usecurrent_state_to_objectinstead when you need a guaranteed polygon copy (the bridge inserts the result for you and returns its handle).list_graph_node_assetscan return an empty list on builds where the Maxon asset repository doesn't expose node-template assets through the usual query path. The tool still returnssupported: truewith shape-correct output; treat an emptyassetsarray as "discovery unavailable on this C4D build" and pass$typeasset ids you already know (e.g. fromlist_graph_nodeson an existing material).Node material friendly names vary.
apply_graph_descriptionaccepts the declarative$typestrings documented by Maxon (e.g."Standard Material"), but the resolver varies between 2024 / 2025 / 2026 builds — when in doubt, pass the fully-qualified asset id returned bylist_graph_node_assets/list_graph_nodesinstead.exec_pythonis the only way to seed classical-shader fixtures. A handful of E2E tests (fordump_shader) need to build a shader tree before asserting on it, so they skip cleanly whenC4D_MCP_ENABLE_EXEC_PYTHONisn't set on both sides. The tools themselves don't requireexec_python.Older Cinema 4D versions are not tested. The CI + E2E suite targets C4D 2026. The bridge guards optional SDK constants with
getattrfallbacks, so most tools likely work on 2024 / 2025 as well — but we don't verify that and won't accept bug reports that don't reproduce on 2026.
Contributing
See CONTRIBUTING.md for setup, the development loop, how to add a new tool, coding style, and the PR flow.
License
MIT © 2026 kumo.productions, Inc.
Trademarks
Cinema 4D® and Maxon® are trademarks of Maxon Computer GmbH. This project is an independent, unofficial tool, not affiliated with or endorsed by Maxon.
Available Tools
67 toolsadd_user_dataAdd User Data SlotA
Add a new User Data slot to any BaseList2D (common rigging / control-exposure pattern). Returns the slot's DescID (as a nested list) which can be piped into get_params / set_params as a path. dtype aliases: real, long, bool, vector, string, color, filename, time, link.
Inputs: name (required), dtype (required), handle (required), max, +4 more.
apply_graph_descriptionApply Node Graph DescriptionA
Build or mutate a node graph using maxon.GraphDescription's declarative dict syntax. Supports creating nodes ($type), assigning stable ids ($id), wiring connections via 'thisPort -> childPort' keys (the value is the nested upstream node), and setting port values inline. Example: {"$type":"Output","Surface -> outColor":{"$type":"Standard Material","$id":"mat","Base/Color":[1,0,0]}}. Works for material graphs (standard/redshift) and the scene-nodes (neutron) document graph via scope:"document". For scene-nodes, $type must be a node-template asset id from list_graph_node_assets (node_space:"scenenodes"), e.g. "net.maxon.node.invert" — NOT the net.maxon.corenode:* ids; the scene-nodes path supports creation + connections + port values (graph queries/labels are material-only). Creates the graph on demand by default.
Inputs: description (required), scope, handle, node_space, +1 more.
apply_xpresso_graphApply Xpresso Graph DescriptionA
Declarative builder for an Xpresso (classic GvNodeMaster) graph — mirror of apply_graph_description but for Xpresso rather than Maxon node materials. Creates nodes (CreateNode) and wires connections (GvPort.Connect) in one call. Accepts an operator_id as an int (e.g. c4d.ID_OPERATOR_CONST=1001150) or short alias ('object'|'const'|'result'|'math'|'range_mapper'|'condition'|'compare'|'memory'|'iterate'|'bool'|'freeze'|'formula'|'realtovect'|'vecttoreal'|'matrix2vect'|'vect2matrix'|'link'|'spy'|'python'). Optionally creates the Texpresso tag when given an object handle and create_tag_if_missing:true. Example: build a Object.Global Position -> Result graph in three calls (create Cube → apply_xpresso_graph → EventAdd).
Inputs: nodes (required), handle (required), connect, create_tag_if_missing.
assign_materialAssign Material (Texture Tag)B
Link a material to an object by creating a Texture tag (or updating an existing one when update_if_exists:true). Avoids wrangling TEXTURETAG_* param ids by hand. Projection aliases: spherical, cylindrical, flat, cubic, frontal, spatial, uvw, shrinkwrap, camera.
Inputs: object (required), material (required), name, uv_tiles, +4 more.
assign_to_layerAssign To LayerA
Place a target (object / tag / material) on a named layer. Pass layer:null to clear the assignment. The layer must exist — call create_layer first if needed.
Inputs: layer (required), target (required).
batchBatch ExecuteA
Run many generic ops in one RPC. Each op is applied in order; by default failures are recorded per op and the batch continues. The whole batch is wrapped in a single undo group. Useful for 'apply X to all matching entities' workflows (pair with list_entities + name_pattern to get handles).
Inputs: ops (required), stop_on_error.
call_commandCall C4D CommandB
Invoke a Cinema 4D command by plugin id via c4d.CallCommand(). Works for built-in commands (render, save, make editable, ...) and any registered command plugin.
Inputs: command_id (required), subid, timeout_ms.
clone_entityClone EntityA
Duplicate an entity. Supports object / tag / material / shader (via GetClone + parent insert), render_data (doc.InsertRenderData — copies VideoPosts too), video_post (rd.InsertVideoPost), and take (TakeData.AddTake, copying existing overrides). Objects default to dropping next to the source; pass parent to place the clone elsewhere. Returns a handle to the new entity.
Inputs: handle (required), name, parent.
close_documentClose DocumentADestructive
Close an open document, identified by its list index (from list_documents) or name. Pass exactly one of the two. A document with unsaved changes is refused unless force:true — closing discards unsaved work without a prompt (unlike the GUI close). C4D always keeps at least one document, so closing the last one leaves a fresh empty document active.
Inputs: name, force, index.
create_entityCreate C4D EntityA
Unified constructor for object / tag / material / shader / video_post. Handles parent linking, optional params, positions, and container slot assignment in one call. Returns the handle of the created entity (object handles include path for stable re-resolution) so you can chain set_params / set_keyframe. Note: kind:"shader" targets classical shader chains (Fusion, Colorizer, Xbitmap, …). For node-material edits (Standard node space / Redshift), use apply_graph_description instead. kind:"video_post" attaches a renderer effect (Octane 1029525, Redshift 1036219, Magic Bullet Looks 1054755, …) to a RenderData parent.
Inputs: kind (required), type_id (required), name, slots, +3 more.
create_layerCreate LayerB
Create a LayerObject at the document's layer root. With update_if_exists:true the existing layer with the same name is updated in place (idempotent). Pass color:[r,g,b] (0..1) and/or flags:{solo,view,render,manager,locked,...} to configure it.
Inputs: name (required), color, flags, update_if_exists.
create_markerCreate Timeline MarkerA
Create a named timeline marker at a frame (or time in seconds), with optional colour and length, in one call (c4d.documents.AddMarker). Replaces the old workaround of seeking the playhead and firing the 'Create Marker at Current Frame' command, which could only drop unnamed markers. Returns the marker's info including its index handle for set_marker / remove_marker.
Inputs: name, color, frame, time_seconds, +1 more.
create_render_dataCreate Render DataA
Create (or update-if-exists) a RenderData with resolution / renderer / fps / frame range in one call. Returns the render_data handle for subsequent create_take / set_params chaining.
Inputs: name (required), fps, width, height, +8 more.
create_takeCreate / Update TakeA
Create or update a Take (AddTake + SetCamera + SetRenderData + SetChecked) in one call. New takes are checked by default so they participate in batch renders; pass checked:false to override. Returns the take handle — ideal for building per-shot take stacks programmatically.
Inputs: name (required), camera, parent, checked, +5 more.
delete_keyframeDelete KeyframeADestructive
Remove keys from a CTrack. Pass frame for a single-frame delete, or start_frame / end_frame (inclusive) for a range. Returns {removed, track}. Symmetric with set_keyframe.
Inputs: handle (required), param_id (required), fps, frame, +3 more.
delete_trackDelete Animation TrackBDestructive
Remove an entire CTrack (identified by param_id + optional component) from the target. Returns {removed: bool}.
Inputs: handle (required), param_id (required), component.
describeDescribe C4D EntityARead-only
Dump all description parameters (id, name, cycle enum, current value) of a C4D entity resolved by handle. Use this to discover parameter IDs before reading/writing.
Inputs: handle (required).
dump_shaderDump Shader TreeARead-only
Recursively dump a shader (resolved from a handle) into JSON. Classical materials only — node materials (Standard node space / Redshift / etc.) expose their shading as a maxon node graph; use list_graph_nodes / apply_graph_description for those instead. Captures type_id / type_name / name per node; promotes c4d.Xbitmap paths to a "file" field; heuristically surfaces image-like strings hiding in other shader BaseContainers as "file_candidates"; and expands shader links stored inside the container as "linked_shaders" (the shape used by Fusion / Colorizer whose internals don't appear via GetDown). Pair with list_entities kind=shader to discover shader handles.
Inputs: handle (required), max_depth.
get_containerDump Raw BaseContainerARead-only
Dump the raw BaseContainer of a C4D entity (including hidden keys that don't show up in describe, e.g. Octane AOV shader slots at 3740/3741). Filter by key range to narrow output.
Inputs: handle (required), id_to, id_from.
get_document_stateGet Document StateARead-only
One-shot reader for the active document's key fields: fps, min/max and loop frame range, current frame, document name/path, canonical handles for the active camera / take / render data, and marker_count (how many timeline markers exist — list them with list_markers). Pairs with set_document for the writer side.
Inputs: no named parameters.
get_graph_infoGet Node Material Graph InfoARead-only
Report which node spaces a material exposes a graph in, which one is currently active, and the alias table the bridge understands. Use this before apply_graph_description to confirm the right node_space is addressable on this build / material.
Inputs: handle (required).
get_keyframesGet KeyframesARead-only
Read the keys on a specific animation track. Combine with list_tracks to discover which (param_id, component) pairs are animated. Returns [{frame, value, interp}]. Optional start_frame / end_frame clip the range inclusively.
Inputs: handle (required), param_id (required), fps, component, +2 more.
get_meshGet MeshARead-only
Read points and polygons (or spline segments) from an editable PointObject / PolygonObject / SplineObject. Primitives (Cube, Sphere, …) must be converted first via modeling_command make_editable. Triangles are returned as [a,b,c] (c==d in C4D storage), quads as [a,b,c,d]. Point and polygon counts are capped to 50,000 by default to protect JSON payload size — override via max_points / max_polys.
Inputs: handle (required), include, max_polys, max_points.
get_object_layerGet Object's LayerARead-only
Return the layer currently assigned to a target entity (object / tag / material), or null if unassigned.
Inputs: target (required).
get_paramsGet Parameter ValuesARead-only
Read parameter values on a C4D entity by id or DescID path. Each id may be: an int (top-level), a list [a, b, …] (chained DescID; dtypes inferred from the description), or contain 'x'/'y'/'z' for vector sub-components (e.g. [903, 'x'] = position.x). For explicit dtypes use [[id, 'real|long|bool|vector'], …]. Returns {values: [{path, value}]} in request order. Discover ids via describe.
Inputs: ids (required), handle (required).
get_selectionGet Active SelectionARead-only
Read the active document's current selection: the active object (primary), all selected objects, and the active tag / material. Useful for reacting to the user's current focus without asking them to re-pick entities. Returns canonical handles so results can be piped directly into describe / set_params / etc.
Inputs: no named parameters.
import_sceneImport / Merge Scene FileA
Merge an external file (abc/fbx/obj/c4d/etc.) into the active document via MergeDocument. Returns the newly-imported top-level objects so they can be chained with set_params / create_entity / create_take. Optionally re-parents them under an existing object and renames the first root.
Inputs: path (required), filter, parent, rename.
list_documentsList DocumentsARead-only
Enumerate the documents currently open in Cinema 4D. Each entry has its list index (the handle accepted by set_active_document), name, path and whether it is the active document. get_document_state only reports the active document; this is how you discover the others before switching.
Inputs: no named parameters.
list_entitiesList C4D EntitiesARead-only
Enumerate scene entities of a given kind. Returns compact summaries (name, type_id, type_name, plus kind-specific fields — is_active for take / material / render_data). For kind=object also supports type_ids / tag_types / max_depth filters and include_tags / include_params to read data inline — so you can find 'all cubes with a Ttexture tag and their position in one call' without falling back to exec_python. Use this first to find what exists before describe/set_params. Note: kind=shader walks classical shader chains; for node-material graphs use list_graph_nodes.
Inputs: kind (required), owner, object, type_ids, +7 more.
list_graph_node_assetsList Node Graph Asset TypesARead-only
Enumerate registered node-template asset ids for a node space — the ids you pass to apply_graph_description as $type. For the scene-nodes (neutron) space, results are filtered to the templates actually addable there (e.g. 'net.maxon.node.invert', 'net.maxon.node.access.composecolor64'); note these differ from the net.maxon.corenode:* ids that list_graph_nodes reports for existing nodes. supported:false comes back when the C4D build lacks the maxon framework.
Inputs: node_space.
list_graph_nodesList Node Material Graph NodesARead-only
Walk a node graph and return a flat list of nodes. Target either a node-based material (via handle) or the active document's scene-nodes graph (via scope:'document'). supported:false comes back when the maxon framework is unavailable or no graph exists in the requested space.
Inputs: scope, handle, node_space.
list_layersList LayersARead-only
Enumerate every LayerObject in the active document. Each entry returns the layer's name, optional color [r,g,b], and its flag dict (solo / view / render / manager / locked / generators / deformers / expressions / animation / xref).
Inputs: no named parameters.
list_markersList Timeline MarkersARead-only
Enumerate every timeline marker in the active document with its frame, time_seconds, name, colour and length_frames (c4d.documents.GetFirstMarker + GetNext). Each entry carries an index handle accepted by set_marker / remove_marker. Use this to verify marker placement — get_document_state only reports marker_count.
Inputs: no named parameters.
list_mograph_clonesList MoGraph ClonesARead-only
Read the per-clone transforms from a MoGraph generator (Cloner / Matrix / Tracer / …). The bridge forces a scene pass so the MoData array is populated before sampling. Returns {count, returned, clones: [{index, pos, matrix?}]}. supported:false when the build lacks c4d.modules.mograph or when the handle isn't a MoGraph generator.
Inputs: handle (required), max_count, include_matrix.
list_pluginsList C4D Plugins (Any Type)ARead-only
Generalized plugin enumerator. Pass plugin_type (e.g. "material", "shader", "video_post", "command") or a raw int to FilterPluginList. Each entry includes "plugin" (parent folder of the binary, e.g. "OctaneRender 1.7.1") and "plugin_file" (binary basename) for host-plugin attribution. Filter results by name_pattern and/or plugin_pattern regex.
Inputs: plugin_type, name_pattern, plugin_pattern.
list_tracksList Animation TracksARead-only
Enumerate CTracks on the resolved entity. Returns {name, param_id, component, dtype, key_count} per track so callers can pipe the results straight into get_keyframes / set_keyframe. Vector tracks (Position, Rotation, Scale) surface as separate entries per component.
Inputs: handle (required).
list_user_dataList User DataARead-only
Enumerate the User Data slots on a target. Each entry carries {desc_id, name, dtype, value}. Feed desc_id back into remove_user_data / get_params / set_params as a DescID path.
Inputs: handle (required).
list_xpresso_nodesList Xpresso Graph NodesARead-only
Walk an Xpresso (Texpresso / GvNodeMaster) tag and return a flat list of its GvNodes. Each entry carries a stable dotted-index path id ('0.2' = root's first child, its third child) plus port summaries. Use the id to address nodes from apply_xpresso_graph, set_xpresso_port, remove_xpresso_node, or any handle-taking tool via {kind:'gv_node', tag, id}. Accepts either a tag handle (Texpresso) or an object handle (uses that object's first Texpresso tag).
Inputs: handle (required).
modeling_commandModeling CommandA
Run a Cinema 4D modeling operation via c4d.utils.SendModelingCommand on one or more target objects. Commands that produce new geometry (Current State to Object, Connect / Join, Split, Explode Segments) return handles to the inserted results; in-place commands (Make Editable, Subdivide, Triangulate, …) return the mutated targets. Aliases: current_state_to_object / cso, make_editable, connect / join, connect_delete, subdivide, triangulate, untriangulate, reverse_normals, align_normals, optimize, center_axis, split, explode_segments, melt, collapse, dissolve.
Inputs: command (required), targets (required), mode, params.
move_entityMove / Reparent / Reorder NodeA
Reparent a node under a new parent, promote it to the top of its hierarchy, or reorder it relative to a sibling. Works on objects, takes, and render_data — siblings/parents must share the moved node's kind. Exactly one destination field must be provided (parent, before, after, or to_root:true). For takes, to_root:true reparents under Main; the Main take itself cannot be moved. Returns the node's new canonical handle so follow-up edits remain stable.
Inputs: handle (required), after, before, parent, +1 more.
new_documentNew DocumentA
Insert a fresh empty BaseDocument into C4D's document list and (by default) switch focus to it. Useful for starting a clean scene without overwriting the current one.
Inputs: name, make_active.
open_documentOpen DocumentA
Load a Cinema 4D scene file as a new document. Unlike import_scene (which merges into the current doc), this opens the file as its own document. Pass make_active:true (default) to switch focus to the loaded document. Differs from import_scene which calls MergeDocument.
Inputs: path (required), make_active.
pingPing C4DARead-only
Check connectivity to the Cinema 4D bridge plugin.
Inputs: no named parameters.
preview_renderPreview Render (Viewport, Constant Lines)A
Quick agent-friendly verification render. Uses the Viewport renderer with the active editor view temporarily switched to Constant Shading (Lines) — sketch-style and fast. Independent of the active RenderData (built freestanding, never inserted) and restores BaseDraw / camera / time / take in finally. Returns a base64 PNG inline so the agent can directly view it. Use view: top|bottom|left|right|front|back for an auto-framed temp camera, or camera to render through a named scene camera. Pass save_path to also write the PNG to disk.
Inputs: take, view, frame, width, +3 more.
remove_entityRemove C4D EntityADestructive
Delete the resolved entity (wrapped in an undo step).
Inputs: handle (required).
remove_graph_nodeRemove Node Graph NodeADestructive
Delete a node by id from a node-material graph. The id must match the node's stable maxon.Id (as reported by list_graph_nodes or assigned via $id in apply_graph_description).
Inputs: node_id (required), scope, handle, node_space.
remove_markerRemove Timeline MarkerADestructive
Delete one timeline marker, or all of them. Pass all:true to clear every marker, or identify a single target by exactly one of index (from list_markers), frame, or name (the latter two error if several markers match). Returns {removed: N}.
Inputs: all, name, frame, index.
remove_user_dataRemove User Data SlotADestructive
Delete a User Data slot by its DescID path (as returned by list_user_data or add_user_data). Wrapped in undo.
Inputs: handle (required), desc_id (required).
remove_xpresso_nodeRemove Xpresso Graph NodeADestructive
Delete a GvNode from an Xpresso graph. The handle must be a gv_node handle pointing at the target (use list_xpresso_nodes to discover its path id). All incoming / outgoing connections on the node are severed automatically.
Inputs: handle (required).
renderRender Active DocumentA
Render the active Cinema 4D document at its currently-active render data settings. To change resolution / renderer / frame range / etc., adjust the active RenderData first via create_render_data (with update_if_exists:true on the active RD) or set_params. The request times out after 180 seconds; heavier renders that exceed that keep running in C4D but the call returns a timeout.
Inputs: output_path.
reset_sceneReset Active SceneADestructive
Clear scene state in one RPC. With prefix (e.g. 'e2e_') removes only objects / materials / non-active render data / non-main takes whose name starts with the prefix, then flushes the undo buffer — cheap cleanup for test suites. Without prefix, swaps the active document for a fresh empty BaseDocument (everything goes). Much faster than chained remove_entity calls when cleanup involves animated objects.
Inputs: prefix, keep_active_rd.
sample_transformSample Object Transform at FramesA
Evaluate the scene at each requested frame and return the object's transform. Useful to verify alembic / constraint / xpresso-driven animation without writing a bespoke exec_python sampler.
Inputs: frames (required), handle (required), fps, space, +2 more.
save_documentSave DocumentA
Save the active document to disk. Path must be absolute; the parent directory must exist. Supported formats: c4d (default), abc / alembic, fbx, obj, stl, ply, usd / usda, gltf. With copy:true the document's internal name/path is left unchanged (Save-As-Copy behaviour).
Inputs: path (required), copy, format.
set_active_documentSet Active DocumentA
Switch focus to an already-open document, identified by its list index (from list_documents) or name. Pass exactly one of the two. name errors if it matches zero or several open documents — use index to disambiguate. This only switches between documents already open; use open_document to load a file from disk.
Inputs: name, index.
set_documentSet Document SettingsB
Update document-level settings: fps, frame range, current frame, active camera, active take. FPS and frame range are also mirrored onto the active render data.
Inputs: fps, frame_end, active_take, frame_start, +2 more.
set_graph_portSet Node Graph Port ValueA
Update a single port on a node addressable by its stable $id within a node material graph. Thin convenience over apply_graph_description: internally builds a {$query:{$id:node_id}, port: value} payload. Lists of 3 numbers are coerced to maxon.Vector for vector-typed ports.
Inputs: port (required), value (required), node_id (required), scope, +2 more.
set_keyframeSet KeyframeA
Create or update a single keyframe on a resolved entity's parameter. Supports scalar (real/long/bool) and vector (x/y/z component) parameters; the bridge infers the dtype from the entity's description, or you can override it explicitly. Creates the CTrack automatically on first use.
Inputs: frame (required), value (required), handle (required), param_id (required), +4 more.
set_layer_flagsSet Layer FlagsA
Toggle a layer's visibility / render / lock flags in one call. Only fields explicitly passed are modified; omitted flags keep their current value. flags returned in the response reflects the post-update state.
Inputs: layer (required), solo, view, xref, +8 more.
set_markerEdit Timeline MarkerA
Rename, recolour, move, or resize an existing timeline marker. Identify the target by exactly one of index (from list_markers — always unambiguous), frame, or name (the latter two error if several markers match). Pass at least one update field. Returns the updated marker's info.
Inputs: name, color, frame, index, +4 more.
set_meshSet MeshA
Overwrite the points (and optionally polygons) of an editable object. Triangles may be passed as [a,b,c]; the bridge expands them to C4D's quad storage (a,b,c,c). If polygons is omitted, only points are rewritten and the count must match the existing topology. Wrapped in a single undo entry.
Inputs: handle (required), points (required), polygons.
set_mesh_selectionSet Mesh SelectionA
Replace the point / polygon / edge BaseSelect on an editable mesh. Existing selection of the specified kind is cleared first. Pair with get_mesh using include:['selections'] to read the same channels back.
Inputs: kind (required), handle (required), indices (required).
set_paramsSet Parameter ValuesA
Atomically write parameter values (wrapped in one undo). Each entry is {path, value} where path is either an int id or a DescID path (e.g. [903, 'x'] = position.x). Lists of 3 numbers auto-coerce into c4d.Vector for vector-typed destinations. Returns {applied: [{path, value}], errors: [{path, error}]}.
Inputs: handle (required), values (required).
set_selectionSet Active SelectionA
Replace or extend the active document's selection. Pass objects (first becomes the active object), tag, or material. With mode:'add' the listed objects are added to the existing selection; with mode:'replace' (default) the prior selection is cleared first. clear:true deselects everything and ignores other fields.
Inputs: tag, mode, clear, objects, +1 more.
set_transformSet Object TransformA
Write an object's transform in local or global space. Pass any combination of pos/rot (HPB radians)/scale to patch individual components — unspecified parts keep their current value. Or pass a full 4x3 matrix (rows: offset, v1, v2, v3) to replace the whole transform; matrix is mutually exclusive with the decomposed fields. Space defaults to 'local' (SetMl). Use 'global' (SetMg) to write world coordinates through a parent.
Inputs: handle (required), pos, rot, scale, +2 more.
set_xpresso_portEdit Xpresso PortA
Low-level Xpresso port primitive — covers cases apply_xpresso_graph can't express. action:'add' adds a new input/output port via GvNode.AddPort(port_id). connect wires this node's port to target (on a peer node identified by target.node_handle); output-vs-input direction is auto-detected. disconnect removes incoming connections from port. set_value writes the port's default. remove deletes the port. Use list_xpresso_nodes first to discover node path ids and existing ports.
Inputs: node (required), action (required), io, port, +3 more.
take_overrideWrite Take Parameter OverridesA
Write per-Take parameter overrides onto a target node (object / tag / material / render_data / video_post / shader). Wraps take.OverrideNode + UpdateSceneNode + override[descid] = value. Use this for shot-by-shot variations that share a single scene (e.g. override Focal Length per Take while one Camera is reused). Paths use the same syntax as set_params. If the scene's Take Manager has its "Lock Overrides" toggle off (which makes C4D refuse all override creation), the bridge enables it for the write and restores the artist's state afterward — reported as lock_overrides_toggled in the result.
Inputs: take (required), target (required), clear, params, +2 more.
undoPop Undo StackA
Pop up to steps entries off the active document's undo stack via doc.DoUndo. Stops early if the stack empties. Returns steps_performed so callers can tell when fewer steps were available than requested. Default: 1 step.
Inputs: steps.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 67 tools
Tools are grouped into distinct Cinema 4D subdomains (document, entity, render, take, marker, layer, graph, Xpresso, mesh, MoGraph, plugins), and descriptions actively cross-reference alternatives, which keeps most boundaries clear. Some overlap remains—for example set_params vs set_transform/take_override, list_entities vs list_graph_nodes, and unified create_entity vs specialized creators—but the distinctions are documented.
The set overwhelmingly follows a predictable snake_case verb_resource pattern (list_*, get_*, set_*, create_*, remove_*, apply_*), making tool intent easy to infer. A few bare command-like names such as render, undo, batch, ping, and describe slightly break the strict verb_noun convention, but overall naming remains highly consistent.
With 67 tools, the server is far above the typical agent-friendly range and creates substantial selection load, even though Cinema 4D is a broad domain. Many specialized operations (preview_render, reset_scene, batch, ping, plugin enumeration, multiple low-level graph/Xpresso primitives) could be consolidated or tiered to reduce surface area.
The surface covers core lifecycle operations across the major Cinema 4D domains: scene and document management, entity CRUD, parameter access, rendering, render data, takes, markers, layers, keyframes, meshes, node graphs, Xpresso, MoGraph, plugins, import/export, undo, and batch execution. No obvious core capability is missing for the stated purpose, and remaining gaps are minor or specialized.
Maintenance
Related MCP Connectors
Build editable 3D scenes, direct characters and cameras, and export AI video references with MCP.
214 tools for AI agents over one MCP endpoint: image, video, audio, 3D, data, storage, mail, GPUs.
MCP server for Clipkit — gives AI agents a video toolbox via the Clipkit schema.
Generate game-ready 3D models, textures, and audio from natural language, over MCP.
Related MCP Servers
- AlicenseAqualityBmaintenanceEnables an LLM to drive Cinema 4D through typed tools for scene inspection and editing, guarded Redshift rendering, animation controls, and bounded PNG sequence rendering.822MIT
- AlicenseCqualityCmaintenanceEnables prompt-assisted 3D manipulation in Cinema 4D, including scene editing, object creation, animation, lighting, and material management, through MCP clients like ChatGPT, Claude, and Codex.37MIT
- FlicenseNot gradedqualityAmaintenanceEnables users to create and manipulate Cinema 4D scenes through natural-language prompts by exposing tools for primitives, cameras, lights, materials, Redshift, MoGraph, dynamics, rendering, and custom Python execution.-
- FlicenseNot gradedqualityAmaintenanceConnects Cinema 4D to Claude, enabling prompt-assisted modeling, scene creation, object manipulation, materials, lighting, cameras, animation, MoGraph, dynamics, rendering, and Redshift inspection through MCP tools.-