Skip to main content
Glama

MCP for Cinema 4D

mcp-cinema4d

CI License: MIT Node Cinema 4D

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.

日本語 简体中文

IMPORTANT

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 hero layer; 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."

CAUTION

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:

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

  2. 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 some call_command invocations do not.

  3. Arbitrary Python is off by default. exec_python runs unrestricted code with the full authority of the Cinema 4D process (file I/O, subprocess, network). Enabled only when C4D_MCP_ENABLE_EXEC_PYTHON=1 is 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 separate C4D_MCP_ENABLE_PYTHON_OPS=1 opt-in, since their code parameter is RCE-equivalent to exec_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 4D

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

  1. Install the bridge plugin into Cinema 4D (one-off). Download the latest cinema4d_mcp_bridge-<version>.zip from the Releases page and extract the cinema4d_mcp_bridge/ folder into your Cinema 4D plugins directory (see Installing the bridge plugin for platform-specific paths).

  2. Launch (or restart) Cinema 4D. The C4D console should print [cinema4d_mcp_bridge] listening on 127.0.0.1:18710.

  3. 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 hero 200 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 16

Register 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

%APPDATA%\Claude\claude_desktop_config.json (Windows) · ~/Library/Application Support/Claude/claude_desktop_config.json (macOS)

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

ping, render, preview_render (Viewport renderer + Constant Lines, returns inline PNG), reset_scene.

Script-style

5

exec_python (opt-in), call_command, list_plugins, undo, batch — escape hatches + undo-grouped multi-op.

Generic CRUD

9

list_entities, describe, get_params/set_params, get_container, dump_shader, create_entity, remove_entity, set_keyframe.

Shot setup

11

Document state, fps / frame range / camera, import_scene (merge), RenderData + Take, take_override, timeline markers (create_marker / list_markers / set_marker / remove_marker), sample_transform.

Selection · Hierarchy

4

Active selection read / write; reparent, reorder, clone.

Modeling · Mesh

4

modeling_command (CSO / Make Editable / Connect / Subdivide / …), get_mesh, set_mesh, set_mesh_selection.

Document I/O

6

save_document, open_document, new_document, list_documents, set_active_document (switch between already-open docs), close_document (force-gated for unsaved changes).

Node graphs

10

Node-material graphs (walk / asset enum / apply_graph_description / per-port edits / removal) and Xpresso (GvNodeMaster) graphs (list_xpresso_nodes / apply_xpresso_graph / set_xpresso_port / remove_xpresso_node).

Tag helpers · Animation

5

assign_material; list_tracks, get_keyframes, delete_keyframe, delete_track.

Transforms · User data · MoGraph

5

set_transform; add_user_data / list_user_data / remove_user_data; list_mograph_clones.

Layers

5

Enumerate, create, assign, query, flag toggles (solo / view / render / locked / …).

Instances (opt-in)

4

list_instances, set_active_instance, launch_instance, stop_instance — drive several Cinema 4D processes from one server; hidden unless C4D_MCP_ENABLE_MULTIINSTANCE=1.

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

object

{kind:"object", name:"Cube"} or {kind:"object", path:"/Root/Character/Hip"}

render_data

{kind:"render_data", name:"VFX_Shot002"}

take

{kind:"take", name:"VFX_Shot002"}

material

{kind:"material", name:"Concrete"}

tag

{kind:"tag", object:"Cube", type_id:1029524, tag_name?:"..."} (or object_path instead of object)

video_post

{kind:"video_post", render_data:"VFX_Shot002", type_id:1029525}

shader

{kind:"shader", owner:<handle>, name?:"Layer 0"} or {..., index:0}

plugin_options

{kind:"plugin_options", plugin_id:"abc"|1028082, plugin_type?:"scene_saver"} — exporter / importer private settings BC

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

%APPDATA%\Maxon\Maxon Cinema 4D <VERSION>\plugins\

macOS

~/Library/Preferences/Maxon/Maxon Cinema 4D <VERSION>/plugins/

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.

NOTE

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

C4D_MCP_HOST

both

127.0.0.1

Host for the TCP bridge. Legacy aliases: C4D_BRIDGE_HOST (Node), C4D_MCP_BRIDGE_HOST (plugin).

C4D_MCP_PORT

both

18710

Port for the TCP bridge. Legacy aliases: C4D_BRIDGE_PORT, C4D_MCP_BRIDGE_PORT.

C4D_MCP_ENABLE_EXEC_PYTHON

both

unset

Opt-in. Set to 1 (or true/yes/on) on both sides to expose the exec_python tool. See Security.

C4D_MCP_ENABLE_PYTHON_OPS

C4D plugin

unset

Opt-in. Set to 1 to allow creating / editing Python-bearing plugin types (Python tag, Python generator, MoGraph Python effector, Python field (Fpython, 440000277), Xpresso Python operator). Off by default — their code parameter is RCE-equivalent to exec_python.

C4D_MCP_TOKEN

both

unset

Shared secret. When set on the C4D side, the Node client must send the same value. Strongly recommended.

C4D_MCP_ALLOW_REMOTE

C4D plugin

unset

Required to bind C4D_MCP_HOST to a non-loopback interface. The bridge refuses to start otherwise.

C4D_MCP_ENABLE_MULTIINSTANCE

MCP server

unset

Opt-in. Set to 1 to expose the instance tools (list_instances, set_active_instance, launch_instance, stop_instance) and add an optional instance argument to every other tool. See Multiple Cinema 4D instances.

C4D_MCP_EXE

MCP server

auto-detect

Cinema 4D executable for launch_instance. Defaults to the newest install under C:\Program Files\Maxon Cinema 4D <ver> (Windows) or /Applications/Maxon Cinema 4D <ver> (macOS).

C4D_MCP_MAX_INSTANCES

MCP server

3

Instance slots including the primary; instance id listens on C4D_MCP_PORT + id.

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_instances shows every reachable instance. Instance 0 is the primary (C4D_MCP_PORT); the others live on C4D_MCP_PORT + id, so ids stay stable across server restarts and instances a previous session launched are picked up again.

  • launch_instance starts another Cinema 4D with g_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_INSTANCES caps the total (default 3, primary included).

  • Every other tool gains an optional instance argument. Calls without it go to the active instance (set_active_instance). When issuing calls in parallel against different instances, pass instance explicitly — the active instance is shared session state.

  • stop_instance quits a secondary instance, discarding its unsaved documents. It never targets instance 0, and the bridge only honours quit when C4D_MCP_ENABLE_MULTIINSTANCE is 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_python is opt-in. It runs unrestricted Python on Cinema 4D's main thread (file I/O, subprocess, network). Hidden and rejected by the bridge unless C4D_MCP_ENABLE_EXEC_PYTHON=1 is 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 to exec_python. The bridge refuses create_entity, set_params, apply_xpresso_graph, and take_override operations targeting these types unless C4D_MCP_ENABLE_PYTHON_OPS=1 is 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.1 by default. Binding C4D_MCP_HOST to a non-loopback interface refuses to start unless C4D_MCP_ALLOW_REMOTE=1 is 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_instance starts Cinema 4D executables. The binary comes only from C4D_MCP_EXE or the default install location — never from tool arguments — and the new process inherits the server's environment, so the token and every C4D_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_python if 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. When exec_python is enabled, a malicious string in a scene can steer the model into running arbitrary Python. Don't run import_scene against untrusted .c4d / .fbx / .abc files while exec_python is on, and rely on your MCP client's per-call approval for exec_python / call_command / save_document / import_scene rather than blanket-approving them.

  • Audit log. Every exec_python call records the code body to the local bridge log (%TEMP%/cinema4d_mcp_bridge.log on Windows, $TMPDIR/cinema4d_mcp_bridge.log on 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-cinema4d

Troubleshooting

Symptom

Likely cause / fix

Cannot connect to Cinema 4D bridge at 127.0.0.1:18710

C4D isn't running, plugin didn't load, or a firewall is blocking localhost. Check the C4D console for the listening on … line and look at %TEMP%/cinema4d_mcp_bridge.log (Windows) / $TMPDIR/cinema4d_mcp_bridge.log (macOS).

Plugin loads but the listening line never prints

Usually a Python import error in cinema4d_mcp_bridge.pyp. Inspect the C4D console; common cause is leftover stale files from an older install — delete the destination folder and re-extract the latest release zip, then restart C4D.

listening on 127.0.0.1:18710 fails with OSError: address already in use

Another process already owns that port. Either quit it, or set both C4D_MCP_PORT (C4D side) and the same value on the MCP server launch command.

unknown command: <tool>

Bridge plugin is older than the npm package. Download the matching release zip, re-extract it into your plugins folder, and restart C4D.

object name '…' is ambiguous

Two or more scene objects share the name. Use a path-based handle: {kind:"object", path:"/A/B/C"}. Candidate paths are included in the error.

exec_python is disabled on this C4D instance

exec_python is off by default. Set C4D_MCP_ENABLE_EXEC_PYTHON=1 in both the Cinema 4D launch environment and the MCP server env map, then restart C4D. See Security.

requires C4D_MCP_ENABLE_PYTHON_OPS=1 …

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 C4D_MCP_ENABLE_PYTHON_OPS=1 in the Cinema 4D launch environment and restart.

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_editable is unreliable on Cinema 4D 2026. The SDK's SendModelingCommand handling of MCOMMAND_MAKEEDITABLE shifts across builds — sometimes it returns the new polygon object, sometimes it removes the source without inserting a replacement. Use current_state_to_object instead when you need a guaranteed polygon copy (the bridge inserts the result for you and returns its handle).

  • list_graph_node_assets can 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 returns supported: true with shape-correct output; treat an empty assets array as "discovery unavailable on this C4D build" and pass $type asset ids you already know (e.g. from list_graph_nodes on an existing material).

  • Node material friendly names vary. apply_graph_description accepts the declarative $type strings 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 by list_graph_node_assets / list_graph_nodes instead.

  • exec_python is the only way to seed classical-shader fixtures. A handful of E2E tests (for dump_shader) need to build a shader tree before asserting on it, so they skip cleanly when C4D_MCP_ENABLE_EXEC_PYTHON isn't set on both sides. The tools themselves don't require exec_python.

  • Older Cinema 4D versions are not tested. The CI + E2E suite targets C4D 2026. The bridge guards optional SDK constants with getattr fallbacks, 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 tools
add_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 DocumentA
Destructive

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 KeyframeA
Destructive

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 TrackB
Destructive

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 EntityA
Read-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 TreeA
Read-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 BaseContainerA
Read-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 StateA
Read-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 InfoA
Read-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 KeyframesA
Read-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 MeshA
Read-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 LayerA
Read-only

Return the layer currently assigned to a target entity (object / tag / material), or null if unassigned.

Inputs: target (required).

get_paramsGet Parameter ValuesA
Read-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 SelectionA
Read-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 DocumentsA
Read-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 EntitiesA
Read-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 TypesA
Read-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 NodesA
Read-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 LayersA
Read-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 MarkersA
Read-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 ClonesA
Read-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)A
Read-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 TracksA
Read-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 DataA
Read-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 NodesA
Read-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 C4DA
Read-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 EntityA
Destructive

Delete the resolved entity (wrapped in an undo step).

Inputs: handle (required).

remove_graph_nodeRemove Node Graph NodeA
Destructive

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 MarkerA
Destructive

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 SlotA
Destructive

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 NodeA
Destructive

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 SceneA
Destructive

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

    A3.7/5.0

    Scored across 67 tools

    Disambiguation4/5

    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.

    Naming Consistency4/5

    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.

    Tool Count2/5

    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.

    Completeness5/5

    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

    ActivitySlowing
    ResponsivenessLimited data

    Related MCP Connectors

    Related MCP Servers

    • A
      license
      A
      quality
      B
      maintenance
      Enables an LLM to drive Cinema 4D through typed tools for scene inspection and editing, guarded Redshift rendering, animation controls, and bounded PNG sequence rendering.
      82
      2
      MIT
    • A
      license
      C
      quality
      C
      maintenance
      Enables 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.
      37
      MIT
    • F
      license
      Not graded
      quality
      A
      maintenance
      Enables 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.
      -
    • F
      license
      Not graded
      quality
      A
      maintenance
      Connects 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.
      -