Blender × Claude Connector — Natural-Language 3D Authoring

Updated: 2026-05*

1. Introduction

This material covers the Blender Connector that Anthropic released in April 2026, and how to perform modeling, material setup, animation, and scene cleanup in Blender purely through conversation with Claude. Where the previous material (Blender × Claude — Python Scripting Primer) relied on manually copy-and-pasting generated Python into Blender, this material covers a setup where Claude and Blender communicate directly, so the human only has to give instructions and 3D operations are carried out automatically.

1.1 References

• Claude for Creative Work (Anthropic announcement)
• Using the Blender Connector in Claude (official tutorial)
• Blender MCP Server (Blender official)
• Claude Desktop download
• Blender download
• npaka’s Japanese walkthrough

1.2 Goals

There are three goals for this material.

First, to install the Connector on both Claude Desktop and Blender and get the two communicating. Second, to be able to model, place, assign materials, and set up animation entirely in natural language, without writing Python. Third, to learn the three-layered use of Claude as “scene organizer,” “explainer of complex structures,” and “optimization advisor.”

1.3 Difference from Python Scripting

The contrast between the Python workflow covered in the previous material and the Connector workflow covered here can be summarized as follows.

• Python workflow (manual)
  • Communication: Claude generates code → human copies → pastes into Blender’s Text Editor → Run Script
  • Context: Claude does not know the scene state, so the human has to describe it in words
  • Error handling: the human copies error logs and pastes them back to Claude
  • Environment: works with the browser version of Claude (claude.ai)
• Connector workflow (automatic)
  • Communication: Claude directly invokes Blender’s Python API and receives the result back automatically
  • Context: Claude reads the open scene and responds with full awareness of the current state
  • Error handling: Claude detects errors itself and tries to fix them automatically
  • Environment: Claude Desktop (local app) required; the browser version does not work

Note: the Connector workflow is convenient, but understanding the Python basics lets you verify and modify what gets generated, so learning both is recommended.

1.4 Intended Audience

This material primarily targets students in media art and design. Basic Blender operation (adding, selecting, moving objects, rendering) is assumed, but no Python knowledge is required. The material can be completed without having gone through the previous one.

2. How It Works

Understanding how Claude and Blender are connected makes troubleshooting easier when something goes wrong.

2.1 MCP (Model Context Protocol)

MCP is an open standard authored by Anthropic for safely connecting AI models to external tools. Just as USB-C connects diverse devices through a single standard, MCP is designed as a standard for connecting diverse software to AI. The Blender Connector runs on MCP, so any MCP-compatible AI client (Claude Code, Cursor, VS Code, etc.) can also reach the same Blender environment.

2.2 Connection Architecture

Three components work together as follows.

• Claude Desktop (client)
  • Role: receives natural-language instructions from the user and sends the required Blender operations through MCP
• Blender MCP Server (bridge)
  • Role: runs inside Blender and translates Claude’s instructions into Python API calls
• Blender itself
  • Role: actually modifies the scene from the Python API calls

All communication stays on the local machine. Scene contents are not sent over the internet to a third party; what reaches Claude is limited to “structural information about the current scene” and “the code Claude is asking to execute.”

2.3 Official vs. Third-Party Connectors

The Blender Connector comes in two broad flavors.

• Official Blender (recommended)
  • Provider: Blender Lab, under the Blender Foundation
  • Distribution: Blender MCP Server official page
  • Requirements: Blender 4.2 or later (some documentation requires Blender 5.1 or later — check at install time)
• Third-party (ahujasid/blender-mcp)
  • Provider: independent developer Siddharth Ahuja
  • Distribution: GitHub: ahujasid/blender-mcp
  • Notes: available since early 2025, with rich external asset integrations (Polyhaven, Hyper3D, Sketchfab, etc.)

This material assumes the official version. The third-party version has unique features such as automatic HDRI download from Polyhaven; use both side by side when needed.

3. Installation

Both Claude Desktop and Blender need configuration. Once set up, simply launching the two apps is enough for the integration to work.

3.1 Prerequisites

• Claude Desktop
  • Supported OS: macOS / Windows
  • Download: claude.ai/download
• Blender
  • Version: 4.2 LTS or later (the official guide sometimes requires 5.1 or later)
  • Download: blender.org/download

Note: the Connector does not work on the browser version (claude.ai). The desktop app is required.

3.2 Claude Desktop Setup

Launch Claude Desktop and add the Connector.

First, press the “+” button to the left of the chat input. Second, choose “Connectors” → “Add Connector” from the menu. Third, type Blender into the search box and select the Blender icon that appears. Fourth, press “Install.”

That completes the Claude Desktop side.

3.3 Blender Add-on Installation

Install the Blender MCP Server into Blender.

First, open the Blender MCP Server page in a browser. Second, drag the “install link” on that page and drop it onto the running Blender window. Third, when asked “Add a new extension repository?”, click “Add Repository” → “Create” in that order. Fourth, drag the same link onto Blender again, and press “OK” at the “Install Extension” prompt.

You may also need to enable “Allow Online Access” under Blender Preferences → System.

3.4 Allowing Online Access

From Blender 4.2 onward, features that perform external communication must be explicitly allowed.

• Edit → Preferences → System
  • Allow Online Access: enabled

Note: Blender disables external access by default for security reasons. The Connector communicates only locally, but it may fail to work if this setting is OFF.

3.5 Connection Check

With both apps running, type the following into a new Claude Desktop chat.

Connect to Blender and tell me what is in the currently open scene.

If Claude returns a list of objects in the current Blender scene, the connection is working. On a default startup scene, you should see the three default items Cube, Camera, and Light reported.

If the connection fails, quit both Claude Desktop and Blender once and restart them. The first launch after a settings change sometimes fails.

4. Basic Usage

With the Connector running, here is how to phrase instructions to Claude.

4.1 Principles for Prompts

Unlike when asking Claude to generate Python code, with the Connector you only need to describe the desired result in natural language. Three ingredients tend to improve accuracy:

First, state the scope explicitly (whole scene, a specific collection, currently selected objects). Second, be concrete about anything that can be expressed numerically (“10 of them,” “radius 5,” “2× along the Z axis,” etc.). Third, when chaining multiple operations in one request, list them as bullet points to show the order.

Example of a good prompt:

Clean up the scene first, then place 12 Spheres at equal intervals
on a circle of radius 10.
Each Sphere has radius 0.5, with smooth shading.

Example of an ambiguous prompt (Claude may ask follow-up questions):

Arrange some round things nicely.

4.2 Inspecting Scene State

Since Claude can read the entire scene, you can start by asking about the current state.

Example prompt:

List the objects in the current scene, organized by collection.
Include the type of each object (Mesh, Light, Camera, etc.).

This is the biggest advantage of the Connector workflow. In the Python workflow the user had to describe the scene state in words; with the Connector, Claude reads it directly.

4.3 Executing Operations

Operational instructions are passed in natural language directly. Claude internally generates and runs Python code, then reports the result.

Example prompt:

Select every Cube in the scene and move each one randomly along the Z axis
between -3 and 3.
Fix the seed value to 42.

After running, Claude reports something like “Moved 12 Cubes.” Switch to the Blender viewport to verify the result.

4.4 Asking to See the Code

If you want to learn what Claude is doing, you can ask it to show the code before executing.

Example prompt:

For every operation from now on, show the Python code you are going to use
before executing it.

This gives you a workflow well suited to learning the Python API while using the Connector.

5. Practice 1 — Scene Cleanup and Naming Conventions

The most practically impactful use of the Connector is cleaning up existing files. This is the headline use case in the official tutorial.

5.1 Automatic Renaming of Objects

Files made in the past, or .blend files received from someone else, are often filled with auto-named objects like Cube.001, Sphere.014. The Connector can rename these based on their contents.

Example prompt:

Look through the open scene and rename objects, collections, materials,
and data blocks to names that clearly reflect their contents.
Also, if any names contradict the actual contents or look misleading,
report them in a list without renaming.

Claude reads the whole scene and produces names like Chair_Wood_01 for a chair mesh, or Mat_Floor_Concrete for a floor texture.

5.2 Specifying a Naming Convention (optional)

If you want a project-wide naming convention, state the rules up front.

Example prompt:

Use the following naming convention and rename accordingly:
- Mesh Object: SM_Category_Name_Number (e.g., SM_Furniture_Chair_01)
- Material: M_Category_Name (e.g., M_Wood_Oak)
- Light: L_Purpose_Number (e.g., L_Key_01, L_Fill_01)
- Camera: C_Purpose (e.g., C_Main, C_Detail)

This also works for industry-standard conventions such as the Unreal Engine naming scheme used in game development.

5.3 Removing Unused Data (optional)

In Blender, data blocks (Mesh, Material, Texture, etc.) of deleted objects can linger inside the file and inflate file size.

Example prompt:

Find unused data blocks in the scene (Mesh, Material, Texture, NodeGroup,
etc.).
Split them into "safe to delete" and "better keep just in case," and
report.
Once I confirm, delete them in one batch.

Splitting destructive operations into “confirm → execute” like this is the safer pattern.

6. Practice 2 — Understanding Complex Structures

.blend files shared online or received from collaborators often contain complex Geometry Nodes or Shader Node setups. Analyzing such structures is where the Connector really shines.

6.1 Asking About Geometry Nodes

Example prompt:

Walk through the Geometry Nodes Modifier on the active object.
Explain what each node group does, in the order data flows through it.
Include the meaning of input and output sockets.

Claude reads the node tree and produces a human-readable walkthrough such as “First, Distribute Points on Faces generates the points; next, Instance on Points places objects on them; finally, Rotate Instances applies random rotation.”

6.2 Annotating the Node Editor (bonus)

Beyond keeping the explanation in your head, you can have Claude write it directly into the Node Editor as frame labels.

Example prompt:

Add the explanation you just gave as frame labels on each node group inside
the Node Editor.
Keep it concise and in Japanese. Save the file when done.

This turns the file itself into documentation, sparing you the rediscovery work when you reopen it later.

6.3 Analyzing Shader Nodes

Material node structures can be analyzed the same way.

Example prompt:

Analyze the shader node setup of the material "M_Wood_Oak" assigned to
Cube_01.
Report the main Principled BSDF parameter values, the textures used, and
any unusual node connections, as bullet points.

7. Practice 3 — Dependency Investigation

Before changing or deleting an object or material, you should know where else it is referenced. The Connector can automate this investigation.

7.1 Finding Material References

Example prompt:

Find every place that uses the material "M_Glass_Tinted" in this file.
Cover objects, node groups, Geometry Nodes settings — anywhere it could be
referenced — in a single list.
Also tell me what would break, or could break, if I deleted this material.

Claude scans the whole scene and reports something like “Object_A, Object_B, Object_C use it directly; it is also referenced inside the node group ‘WindowGlass’.”

7.2 Investigating Object References

Objects may be referenced from Modifiers, Constraints, Drivers, Particle Systems, and more. These can be investigated the same way.

Example prompt:

Find every object and setting that references "Empty_Controller_Main."
Cover Drivers, Constraints, Modifiers, Geometry Nodes inputs — every
possible reference point.

7.3 Safe-Deletion Pattern

Destructive operations (deletion, Apply, Join, etc.) become much safer when combined with a dependency check.

Recommended pattern, as a prompt:

I'm about to clean up the scene. Proceed in the following order:
1. List candidate objects that look unnecessary.
2. Check whether each candidate is referenced elsewhere.
3. Split them into "safe to delete" and "would cause problems," and report.
4. Delete only the items I approve.

8. Practice 4 — Render Optimization

When render time is long, the cause is often uneven polygon counts or oversized textures. The Connector can survey the whole scene and identify bottlenecks.

8.1 Identifying Heavy Objects

Example prompt:

For each mesh in the scene, look up its polygon count, object name,
collection, and on-screen size from the camera's view.
Then prioritize objects with high polygon counts that appear only small
on screen.
Suggest these as optimization candidates, with a reason for each.

You get a list of “objects covering less than 1% of the screen but with over 100,000 polygons” — i.e., the worst cost/benefit spots.

8.2 Auto-LOD with Decimate (optional)

You can also batch-apply the Decimate Modifier to the identified objects.

Example prompt:

For the optimization candidates flagged earlier whose screen coverage is
under 5%, add a Decimate Modifier with ratio=0.3.
Report the polygon count before and the expected count after, then run it.

8.3 Texture Resolution Audit (bonus)

Example prompt:

For every Image Texture used in the scene, list its resolution, file size,
assigned material, and on-screen coverage from the camera.
Suggest as optimization candidates anything whose resolution looks
excessive for its on-screen coverage.

9. Practice 5 — Modeling and Animation

So far the focus has been on analyzing and cleaning up existing scenes, but the Connector is just as useful for building from scratch.

9.1 Placing Objects

Example prompt:

Empty the scene, then place Cubes as follows:
- 10×10 grid
- Spacing of 2.0 between Cubes
- Z height of each Cube determined by sin(x * 0.5) + cos(y * 0.5)
- Apply smooth shading to all Cubes

You don’t have to write Python — describing the desired end state is enough.

9.2 Bulk Material Assignment

Example prompt:

For every Mesh Object in the scene, assign a Principled BSDF material with
a random color.
- Base Color: HSV space, Hue=random, Saturation=0.8, Value=0.9
- Roughness: 0.3
- Seed: 42
Name materials as "M_Random_Number".

9.3 Setting Up Animation

Example prompt:

For every Cube in the scene, set keyframes between frame 1 and 240 so that
Z height varies as sin(frame * 0.1 + (x + y) * 0.3).
Use each Cube's world X and Y coordinates for x and y.
Set interpolation mode to LINEAR.

After running, press Space on the Blender timeline to play the wave-like animation.

9.4 Automatic Camera and Light Placement (bonus)

Example prompt:

Place one Camera at a vantage point that overlooks the whole current scene,
and set up Three-Point Lighting (Key, Fill, Rim).
Use Area-type lights, and auto-size their Size and intensity to the scale
of the scene.
Set the renderer to Cycles, with Samples = 128.

This gives you a “decent-looking render” instantly, even without lighting design experience.

10. Patterns for Collaborating with Claude

Effective workflows for the Connector workflow.

10.1 The “Read → Propose → Execute” Three-Step Pattern

Always split destructive operations (deletion, Apply, Join) and large-scale changes into three steps.

Step 1: have Claude read the current state and report it. Step 2: have Claude propose changes for human approval. Step 3: execute only what was approved.

Following this pattern dramatically reduces accidents from unintended changes.

10.2 Treat the Scene as Shared Conversational Ground

The Connector lets Claude see the same “scene in front of you” that the human sees. This collapses the cost of describing things in words.

For example, even an instruction like “make that object in the back right a bit redder” works — Claude sees the scene and resolves it to “you mean Cube_007.” That kind of context-rich conversation was not possible with plain code generation.

10.3 Use It as a Python Learning Aid

By saying “show me the code before running it,” you can turn the Connector into a strong Python learning tool. Describe what you want in natural language, read the generated code, and gradually start writing it yourself — the cycle is easy to run.

10.4 Knowing the Limits

The Connector is not a silver bullet. The following areas are weak as of May 2026:

• Building complex Geometry Nodes from scratch (a few nodes work; beyond that the error rate rises)
• Rigging (creating Armatures works, but a full character rig with IK and weight paint is not realistic)
• Aesthetic judgment (“the lighting feels off somehow,” “the composition is unbalanced,” and similar subjective tuning)
• Version-dependent API changes (e.g., the Geometry Nodes interface API from Blender 4.0 onward, where training-data drift still produces occasional errors)

The Connector is strong at “automating technical work,” but the calls of “what to make” and “what makes it beautiful” remain on the human side — arguably the high-value part to keep for yourself right now.

11. Conclusion

This material covered driving Blender in natural language through the Blender Connector. Compared with the Python scripting in the previous material, not writing code makes the flow of thought and the flow of making more directly connected, with the largest gains in “scene cleanup,” “analyzing existing assets,” and “optimization” — the non-creative but time-consuming work.

Still, the Connector is not magic. Behind the scenes the generative AI is writing and running Python code to operate Blender. Keeping this in mind makes troubleshooting easier and the move to more advanced use smoother. Learning the previous material and this one as a pair is recommended.