Check connectivity to the Cinema 4D bridge plugin.

Report the Cinema 4D runtime, security posture, and available capabilities.

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. May take up to 60 seconds.

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.

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.

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.

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.

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.

Run many generic ops in one main-thread 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 unless undo_group=false. Pass document_name to bind every allowed active-document operation to one uniquely named open document and restore the prior active document afterward; document lifecycle, arbitrary Python, and command operations are rejected in this scoped mode.

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.

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.

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.

Write parameter values in one undo group. 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. For DTYPE_BASELISTLINK parameters only, use {link: <handle>} to reference an entity or {link: null} to clear it. Link targets and destination types are validated before any writes. Returns {applied: [{path, value}], errors: [{path, error}]}; inspect errors for rejected writes.

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.

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.

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.

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

Create or update one keyframe. Use a full DescID path (including user data) or legacy param_id/component. Supports real/long/bool scalar channels and individual vector components. Creates the CTrack on first use.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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

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

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

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.

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.

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.

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.

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.

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.

Delete a User Data slot by its DescID path (as returned by list_user_data or add_user_data). Wrapped in undo.

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.

Enumerate CTracks. Each entry includes name, full path ([[id,dtype,creator],...]), legacy param_id/component, dtype and key_count. Pass path alone with the entity handle to get/set/delete keyframes or delete_track. Vector channels have separate entries per component.

Read keys using a full path from list_tracks or legacy param_id/component. Returns [{frame, value, interp}], preserving fractional frame positions. Optional integer start_frame/end_frame clip the exact key times inclusively without rounding subframes.

Remove keys selected by full path or legacy param_id/component. Pass an integer frame for an exact-time key, or integer start_frame/end_frame for an inclusive range; fractional key times are not rounded into the selection. Omitting all frame bounds deletes every key on that track. Returns {removed, track}.

Remove an entire CTrack identified by full path or legacy param_id/component. Returns {removed: bool}.

Read an existing REAL F-Curve: stable key indices for this snapshot, precise frame times, values, interpolation, tangent offsets and pre/post extrapolation. Optionally sample the track. At most 1000 keys. Does not create a track/curve or change document time. Not a scene/constraint evaluation or character-animation reader.

Edit existing REAL keys by snapshot index: values, linear/spline/step interpolation, automatic or manual tangents. Left/right are signed offsets, not absolute control-point positions. Manual takeover splits handles and disables automatic/clamp/auto-weight/overshoot/tangent-lock options; key time/value locks are respected. Read get_fcurve first and avoid simultaneous scene edits. Preflights the complete batch before a single undo-grouped track update. Does not create keys or edit coupled XYZ/time tracks.

Retime/scale selected or all REAL keys. Manual tangents scale with the keys; AUTO remains automatic and is recalculated by Cinema 4D. New time = pivot + (old time - pivot) * scale + offset; value uses the analogous formula. Supports subframes, rejects collisions with all keys and out-of-range results before writing. Read the curve again afterward because sorted key indices can change. No time reversal or cross-track bake.

Set pre/post behavior for an existing REAL track: off, hold constant, continue (linear), repeat, offset repeat or oscillate. Omitted side is preserved. Does not duplicate keys, extend the document frame range or bake loops.

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

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.

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.

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

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.

One-shot reader for the active document's key fields: fps, min/max and loop frame range, current frame, document name/path, and canonical handles for the active camera / take / render data. Pairs with set_document for the writer side.

Report exact Redshift renderer, module, node-space, AOV, light, camera, and render support without mutating the scene.

Create a Redshift node material, or reuse one exact-name match when requested.

Create or update a native Redshift light using only runtime-supported properties.

Create or update a native Redshift camera and report unavailable requested settings.

Patch supplied Redshift Standard Material PBR channels. Texture paths are prevalidated; replace_graph requires an explicit document and reliable rollback support.

List Redshift AOVs from the active or named RenderData.

Create or update one exact Redshift AOV type/name pair.

Remove one indexed Redshift AOV when its expected name and type still match.

Clear all Redshift AOVs from one explicitly named document.

Create or update a validated Redshift RenderData without implicit activation.

Run a guarded synchronous Redshift render, optionally at an explicit frame with time restoration. sequence_frame restricts output to PNG Beauty without enabled AOVs. The client timeout does not cancel Cinema 4D rendering.

Start a bounded background Beauty-only PNG sequence (1..300 unique frames), returning job_id immediately. Requires an updated bridge, a uniquely named open document/RenderData with PNG format and no enabled AOVs, and a new output directory whose parent exists. Never overwrites. Do not edit the scene during rendering. Use rs_sequence_status and rs_sequence_control on this same MCP server. Manifest and SHA-256 checks persist beside the frames; job control does not survive server restart.

Read this MCP session's sequence state, current frame, verified completed outputs, and any error without querying or modifying C4D. An uncertain state means a timed-out render may still be running; do not retry it automatically.

Cancel stops scheduling after the in-flight frame finishes; it does not abort a C4D render. Resume is allowed only after clean cancellation in this same MCP session, verifies completed-file hashes, and never overwrites. Do not resume after modifying the scene. Failed or uncertain jobs require inspection; their output files remain intact.