# Blender

> Drive a live Blender session from an agent — create objects, set materials, run Python, render.

[Canonical HTML page](https://top-mcps.com/mcp/blender) · [server.json](https://top-mcps.com/mcp/blender.json) · [methodology](https://top-mcps.com/about/methodology)

## Install

### Claude Desktop — `claude_desktop_config.json`

Paste under mcpServers. Fully quit and reopen Claude after editing.

```json
{
  "mcpServers": {
    "blender": {
      "command": "uvx",
      "args": [
        "blender-mcp"
      ]
    }
  }
}
```

### Claude Code — `CLI or .mcp.json`

Run from your repo. Commit .mcp.json to share with your team.

```shell
claude mcp add blender -- uvx blender-mcp
```

### Cursor — `.cursor/mcp.json`

Global path: ~/.cursor/mcp.json. Reload window after editing.

```json
{
  "mcpServers": {
    "blender": {
      "command": "uvx",
      "args": [
        "blender-mcp"
      ]
    }
  }
}
```

### VS Code — `.vscode/mcp.json`

VS Code uses the "servers" key (not "mcpServers").

```jsonc
{
  "servers": {
    "blender": {
      "command": "uvx",
      "args": [
        "blender-mcp"
      ]
    }
  }
}
```

### Windsurf — `~/.codeium/windsurf/mcp_config.json`

Open via Cascade → hammer icon → Configure.

```json
{
  "mcpServers": {
    "blender": {
      "command": "uvx",
      "args": [
        "blender-mcp"
      ]
    }
  }
}
```

### Cline — `cline_mcp_settings.json`

Open via the Cline sidebar → MCP Servers → Edit.

```json
{
  "mcpServers": {
    "blender": {
      "command": "uvx",
      "args": [
        "blender-mcp"
      ]
    }
  }
}
```

### Continue — `~/.continue/config.json`

Continue uses modelContextProtocolServers with a transport block.

```json
{
  "experimental": {
    "modelContextProtocolServers": [
      {
        "transport": {
          "type": "stdio",
          "command": "uvx",
          "args": [
            "blender-mcp"
          ]
        }
      }
    ]
  }
}
```

### Codex CLI — `~/.codex/config.toml`

Codex uses TOML. Each server is a [mcp_servers.<name>] subtable.

```shell
# ~/.codex/config.toml
[mcp_servers.blender]
command = "uvx"
args = [
  "blender-mcp",
]
```

### Zed — `~/.config/zed/settings.json`

Zed calls them "context_servers". Settings live-reload on save.

```jsonc
{
  "context_servers": {
    "blender": {
      "command": {
        "path": "uvx",
        "args": [
          "blender-mcp"
        ]
      }
    }
  }
}
```

### ChatGPT — `ChatGPT → Apps directory`

Blender doesn't ship a hosted HTTPS endpoint today. ChatGPT supports remote MCP servers only — to use this server in ChatGPT you'll need to deploy it to a public HTTPS URL first (e.g. via Cloudflare Workers or Vercel) or wait for an official remote build.

```none

```

## At a glance

- **Maintainer:** Community (Siddharth Ahuja)
- **Transport:** stdio
- **Auth model:** None
- **Required secrets:** None
- **Supported clients:** Claude, Claude Code, Cursor, Any MCP-compatible client, Blender 3.0+
- **License:** MIT
- **Language:** Python
- **Latest version:** latest
- **Last verified:** 2026-06-17
- **GitHub stars:** 22,870 (fetched 2026-06-17T11:53:23.348Z)
- **Score:** 86/100 (rubric 2026-04 — see https://top-mcps.com/about/methodology)
- **Source:** https://github.com/ahujasid/blender-mcp

## Tools & permissions

| Tool | Description | Args | Side effects |
|------|-------------|------|--------------|
| `get_scene_info` | Inspect the current Blender scene: objects, materials, and hierarchy. | `—` | read |
| `execute_blender_code` | Run arbitrary Python in Blender's interpreter (create/modify objects, materials, lighting, render). | `code: string` | write |
| `get_viewport_screenshot` | Capture a screenshot of the Blender viewport for visual grounding. | `—` | read |
| `download_polyhaven_asset` | Download a free asset (HDRI, texture, model) from Poly Haven into the scene. | `asset_id: string` | write |

## Security & scope

- **Access scope:** read-write
- **Sandbox:** Runs a local socket link to a Blender instance and executes Python inside Blender's interpreter. It can read and modify the open scene and run any code Blender can — there is no sandbox around the Python execution.
- **Gotchas:**
  - Arbitrary Python runs in your Blender process — a wrong instruction can wipe scene data or worse. Save/version the .blend file first.
  - Blender must be open with the add-on connected; if the socket drops, the agent's commands silently fail until you reconnect.

## Quick answer

**What it does.** Exposes Blender's scene to the agent: create and modify objects, set materials and lighting, inspect the scene graph, execute arbitrary Python in Blender's interpreter, capture viewport screenshots for visual grounding, and download assets from Poly Haven and Sketchfab.

**Best for:**
- Prompt-to-3D-scene prototyping
- Scripted batch edits in Blender
- Asset sourcing from Poly Haven/Sketchfab
- Learning Blender's Python API
- Quick blockouts and concept renders

**Not for:**
- Production modeling without an artist
- Photoreal final renders on a deadline
- Unattended/headless render pipelines

## Recipes

### Block out a simple scene from a prompt

```
Use the Blender MCP. Create a low-poly scene: a ground plane, a simple house (cube body + prism roof), and a sun lamp at a 45-degree angle. Assign a matte grey material to the house and a green material to the ground. Then take a viewport screenshot so I can check the composition.
```

_Tested with: Claude Desktop, Cursor_

## Description

The Blender MCP connects an AI agent to a running Blender instance through a small in-app add-on, so the agent can build and edit 3D scenes by calling Blender's Python API. The most common use: describe a scene or model in chat and have the agent create the geometry, assign materials, position the camera, and render — then iterate on the result. It is the de facto MCP for AI-assisted 3D work and the most-starred design/3D MCP server.

## Why it matters

3D is the modality LLMs are worst at describing blind — coordinates, transforms, and material graphs are easy to hallucinate. Giving the agent a live Blender session plus viewport screenshots replaces guesswork with a real render it can see and correct, which turns "model me a low-poly house" from a wall of broken Python into an iterative loop.

## Key features

- Live two-way link to a running Blender
- Object, material, and lighting control
- Arbitrary Python execution in Blender
- Viewport screenshot capture for grounding
- Poly Haven + Sketchfab asset download

## FAQ

### How does it connect to Blender?

You install a small add-on inside Blender and click "Connect" on a panel. The MCP server then talks to that add-on over a local socket, so commands from the agent run inside your live Blender session. Blender has to be open and the add-on toggled on.

### Does it need an API key?

No. The link is local between the MCP server and your running Blender instance — there is no account or API key. Asset downloads from Poly Haven are free; Sketchfab downloads use your own Sketchfab login if you enable that feature.

### Is it safe to run?

It executes arbitrary Python in your Blender process, which is powerful and risky — a bad instruction can delete scene data or run any code Blender can. Save your .blend file (or use version control) before letting an agent loose, and keep a human in the loop.

### Which Blender versions work?

The add-on targets Blender 3.0 and newer. Newer Blender releases are generally supported quickly because the integration rides on Blender's stable Python API rather than UI internals.

### Is this an official Blender project?

No. It is a community project by Siddharth Ahuja (ahujasid/blender-mcp), MIT-licensed, and the most-starred Blender MCP. It is not maintained by the Blender Foundation.

## Changelog

- **2026-06-17** — Refreshed install snippets and fact sheet; verified for 2026.
- **2025-03-01** — Initial directory listing.