# Godot MCP (npm · @shin2344234/godot-mcp)

Edit Godot 4 scenes, nodes and scripts; run, test and debug games live in the editor or headless.

- Trust score: 80/100 (high trust)
- Change this week: +3
- Registry status: active
- Liveness: live
- Owner verified: no
- Last scored: 2026-11-05

## Components

- npm · `@shin2344234/godot-mcp`: 80/100 (this document), [markdown](https://verifymcp.io/servers/shin2344234-godot-mcp/shin2344234-godot-mcp.md), [page](https://verifymcp.io/servers/shin2344234-godot-mcp/shin2344234-godot-mcp)

## Channel facts

- Registry: `npm`
- Package: `@shin2344234/godot-mcp`
- Version: `0.1.2`
- Transport: `stdio`

## Trust breakdown

How this component scores in each security and reliability category. Every signal is checked automatically from public evidence about the published package, including repeated runs of it in an isolated sandbox, and we only credit what we can confirm. Scores are 0–100 per category. Scoring method: https://verifymcp.io/docs/scoring (what has changed: https://verifymcp.io/docs/scoring/changelog)

Scored 2026-11-05.

- **Supply Chain Security**: 99/100
  - No malware found by supply-chain analysis.
  - No known CVEs affecting this package version or its production dependencies.
  - No install/post-install scripts declared.
  - 2 of 13 dependencies flagged as unhealthy.
- **Provenance & Transparency**: 48/100
  - Source repository is publicly reachable at the declared URL.
  - Provenance check failed: no build-provenance attestation is published.
  - Clear OSI-approved license (MIT).
  - Actively maintained (last published 19 days ago).
  - Publishes a security disclosure policy (SECURITY.md).
- **Schema Quality & AI Usability**: 79/100
  - 100% of prompts and resources have a non-trivial description (not blank, and not just the item's name).
  - AI-judged instruction clarity (good).
  - Tool/resource definitions use about 11717 tokens (~81/item across 143 items; 91 tools + 52 resources), lean.
  - Usage-examples check failed: none of the tools include examples.
- **Stability & Change Management**: 67/100
  - Stability observed for 20 of 30 days with no destabilising changes; credit accrues until the full window elapses.
- **Tool Coverage**: 88/100
  - 100% of tools have a non-trivial description (not blank, and not just the tool's name).
  - 65% of tool parameters carry a description.
- **Tool Safety**: 100/100
  - No prompt-injection markers were found in the server instructions, tool names or descriptions we captured.
  - All 3 tool(s) whose name or description implies an irreversible operation declare an MCP destructiveHint annotation.
  - An AI judge read all 93 captured unit(s) of tool text and found none that tries to manipulate the model reading it.
- **Capabilities**: 100/100
  - Implements a current MCP spec version (2026-07-28).

## Install

### How do I install the Godot MCP server?

Godot MCP runs locally as an npm package, launched with npx -y @shin2344234/godot-mcp. Ready-made configuration for Claude, Cursor, VS Code, Codex and 5 more is on this page, copied from each client's own documentation.

### Claude

```bash
claude mcp add shin2344234-godot-mcp -- npx -y @shin2344234/godot-mcp
```

### Cursor

```json
{
  "mcpServers": {
    "shin2344234-godot-mcp": {
      "command": "npx",
      "args": [
        "-y",
        "@shin2344234/godot-mcp"
      ]
    }
  }
}
```

### VS Code

```json
{
  "servers": {
    "shin2344234-godot-mcp": {
      "command": "npx",
      "args": [
        "-y",
        "@shin2344234/godot-mcp"
      ]
    }
  }
}
```

### Codex

```bash
codex mcp add shin2344234-godot-mcp -- npx -y @shin2344234/godot-mcp
```

### opencode

```json
{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "shin2344234-godot-mcp": {
      "type": "local",
      "command": [
        "npx",
        "-y",
        "@shin2344234/godot-mcp"
      ],
      "enabled": true
    }
  }
}
```

### OpenClaw

```bash
openclaw mcp add shin2344234-godot-mcp --command npx --arg -y --arg @shin2344234/godot-mcp
```

### Hermes

```yaml
mcp_servers:
  shin2344234-godot-mcp:
    command: "npx"
    args: ["-y", "@shin2344234/godot-mcp"]
```

### Netclaw

```json
{
  "McpServers": {
    "shin2344234-godot-mcp": {
      "Transport": "stdio",
      "Command": "npx",
      "Arguments": [
        "-y",
        "@shin2344234/godot-mcp"
      ]
    }
  }
}
```

### Vellum

```bash
assistant mcp add shin2344234-godot-mcp -t stdio -c npx -a -y @shin2344234/godot-mcp
```

### Other

```json
{
  "mcpServers": {
    "shin2344234-godot-mcp": {
      "command": "npx",
      "args": [
        "-y",
        "@shin2344234/godot-mcp"
      ]
    }
  }
}
```

## Changelog

Every change recorded for this component, newest first. Days that predate change tracking, or that we cannot explain, say so: "we were watching and nothing happened" and "we were not watching" are different claims.

### 2026-11-05 (score 80, +1)

No change was recorded against any check on this day. Stability & Change Management went from 63 to 67. That category is still filling its 30-day observation window: 19 days of observed history at the previous scan, 20 at this one. The score rises as the window fills, whether or not the server changes.

### 2026-11-02 (score 79, +1)

No change was recorded against any check on this day. Stability & Change Management went from 53 to 57. That category is still filling its 30-day observation window: 16 days of observed history at the previous scan, 17 at this one. The score rises as the window fills, whether or not the server changes.

### 2026-10-31 (score 78, +1)

No change was recorded against any check on this day. Stability & Change Management went from 47 to 50. That category is still filling its 30-day observation window: 14 days of observed history at the previous scan, 15 at this one. The score rises as the window fills, whether or not the server changes.

### 2026-10-29 (score 77, +1)

No change was recorded against any check on this day. Stability & Change Management went from 40 to 43. That category is still filling its 30-day observation window: 12 days of observed history at the previous scan, 13 at this one. The score rises as the window fills, whether or not the server changes.

### 2026-10-27 (score 76, +1)

No change was recorded against any check on this day. Stability & Change Management went from 33 to 37. That category is still filling its 30-day observation window: 10 days of observed history at the previous scan, 11 at this one. The score rises as the window fills, whether or not the server changes.

### 2026-10-25 (score 75, +1)

No change was recorded against any check on this day. Stability & Change Management went from 27 to 30. That category is still filling its 30-day observation window: 8 days of observed history at the previous scan, 9 at this one. The score rises as the window fills, whether or not the server changes.

### 2026-10-23 (score 74, +1)

No change was recorded against any check on this day. Stability & Change Management went from 20 to 23. That category is still filling its 30-day observation window: 6 days of observed history at the previous scan, 7 at this one. The score rises as the window fills, whether or not the server changes.

### 2026-10-21 (score 73, +1)

No change was recorded against any check on this day. Stability & Change Management went from 13 to 17. That category is still filling its 30-day observation window: 4 days of observed history at the previous scan, 5 at this one. The score rises as the window fills, whether or not the server changes.

## MCP tools (91)

### `godot_status` (~48 tokens)

Status

Godot status: call this first. Shows the project, whether the live editor is connected (open scenes, unsaved changes, playing state), the Godot executable found, and running games.

### `godot_addon_install` (~52 tokens)

Install the editor addon

Godot addon: install or update addons/godot_mcp (the editor bridge and game runtime this server needs) from the copy bundled with the server, and enable it in project.godot.

### `godot_project_info` (~49 tokens)

Project info

Godot project facts from project.godot: name, Godot version, main scene, autoloads, input action names, renderer, enabled plugins, C# and test framework detection.

### `godot_project_settings` (~83 tokens)

Read project settings

Godot project settings: read raw values from project.godot, filtered by key prefix (e.g. "display/window", "input/jump"). Only non-default values are stored in the file.

Input parameters:

- `limit` (integer)
- `prefix` (string): Key prefix such as "application" or "input/". Omit to list all keys.

### `godot_files_list` (~135 tokens)

List files

Godot files: list a project folder (res://...). Skips .godot/ and .git/; hides .uid/.import sidecars and, when recursive, addons/ contents unless all. Use recursive with a glob-like "pattern" (e.g. "*.tscn") to find files by type.

Input parameters:

- `all` (boolean)
- `max` (integer)
- `path` (string): Folder to list, e.g. "res://scenes".
- `pattern` (string): Filter file names, e.g. "*.gd" or "*player*".
- `recursive` (boolean)

### `godot_files_read` (~91 tokens)

Read file

Godot files: read a text file (script, scene .tscn, resource .tres, shader, config) with line numbers. Use offset/limit for long files.

Input parameters:

- `limit` (integer): Maximum number of lines.
- `offset` (integer): First line to return (1-based).
- `path` (string, required): File path, e.g. "res://player.gd".

### `godot_files_search` (~98 tokens)

Search files

Godot files: search text across project files (scripts, scenes, resources, shaders). Literal by default; set regex for a regular expression.

Input parameters:

- `case_sensitive` (boolean)
- `max_results` (integer)
- `path` (string): Folder to search in.
- `pattern` (string): Only files whose name matches, e.g. "*.gd".
- `query` (string, required)
- `regex` (boolean)

### `godot_files_write` (~109 tokens)

Write file

Godot files: create or overwrite a text file (e.g. a .gd script or .gdshader). GDScript files are then checked for parse and type errors (as godot_script_validate). Prefer godot_files_edit for small changes to existing files.

Input parameters:

- `content` (string, required)
- `overwrite` (boolean): Set false to fail instead of replacing an existing file.
- `path` (string, required): File path, e.g. "res://scripts/enemy.gd".

### `godot_files_edit` (~105 tokens)

Edit file

Godot files: replace an exact snippet in a text file (old_text -> new_text). old_text must match exactly once unless replace_all. GDScript files are then checked for parse and type errors (as godot_script_validate).

Input parameters:

- `new_text` (string, required)
- `old_text` (string, required): Exact text to find, including indentation (tabs vs spaces matter in GDScript).
- `path` (string, required)
- `replace_all` (boolean)

### `godot_files_move` (~64 tokens)

Move or rename file

Godot files: move or rename a file or folder, carrying its .uid/.import sidecar files. References by uid:// keep working; plain res:// references in other files are NOT updated.

Input parameters:

- `from` (string, required)
- `to` (string, required)

### `godot_files_delete` (~55 tokens)

Delete file

Godot files: delete a file (and its .uid/.import sidecars). Deleting a folder requires recursive: true. This cannot be undone.

Input parameters:

- `path` (string, required)
- `recursive` (boolean)

### `godot_scene_tree` (~134 tokens)

Scene tree

Godot scene: show the node tree (names, types, scripts, instanced sub-scenes) of a scene. Use depth/max_nodes to keep large scenes small; start from a subtree with root.

Input parameters:

- `depth` (integer)
- `max_nodes` (integer)
- `root` (string): Start from this node path instead of the scene root. An instanced sub-scene lists its own (hidden_children) nodes.
- `scene` (string): Scene file, e.g. "res://main.tscn". Defaults to the scene open in the editor; required when the editor is closed.

### `godot_scene_create` (~113 tokens)

Create scene

Godot scene: create a new .tscn file with a root node of the given type (e.g. Node2D, Node3D, Control, CharacterBody2D).

Input parameters:

- `open` (boolean): Open it in the editor afterwards (editor only).
- `path` (string, required): New scene file, e.g. "res://levels/level_1.tscn".
- `root_name` (string): Defaults to the file name in PascalCase.
- `root_type` (string)

### `godot_scene_open` (~34 tokens)

Open scene

Godot scene: open a scene in the editor so later node operations target it.

Input parameters:

- `path` (string, required)

### `godot_scene_save` (~47 tokens)

Save scene

Godot scene: save the edited scene in the editor (headless edits are saved automatically).

Input parameters:

- `path` (string): An open scene to save; defaults to the edited scene.

### `godot_scene_save_as` (~34 tokens)

Save scene as

Godot scene: save the edited scene under a new path (editor only).

Input parameters:

- `path` (string, required)

### `godot_node_get` (~136 tokens)

Get node

Godot node: read a node's type, script, non-default property values and connected signals. Pass properties to read only some.

Input parameters:

- `path` (string, required): Node path relative to the scene root ("." is the root), e.g. "Player/Sprite2D".
- `properties` (array): Only these, e.g. ["position", "visible"]; ["*"] = all incl. defaults (default: non-default values only).
- `scene` (string): Scene file, e.g. "res://main.tscn". Defaults to the scene open in the editor; required when the editor is closed.

### `godot_node_add` (~235 tokens)

Add node

Godot node: add a node of a built-in type (e.g. Sprite2D, CollisionShape2D, Label) or an instance of a .tscn scene, with optional initial properties. Undoable in the editor.

Input parameters:

- `index` (integer): Child position; omit to append.
- `instance` (string): Scene to instance, e.g. "res://enemy.tscn".
- `name` (string)
- `parent` (string): Parent node path; "." for the scene root.
- `properties` (object): Property values. Godot types accept literals ("Vector2(10, 20)"), arrays ([10, 20]), "#ff0000" colors, "res://" paths to load resources, or {"new": "CircleShape2D", "properties": {...}}.
- `scene` (string): Scene file, e.g. "res://main.tscn". Defaults to the scene open in the editor; required when the editor is closed.
- `type` (string): Node class, e.g. "Sprite2D". Give type or instance.

### `godot_node_set` (~173 tokens)

Set node properties

Godot node: set one or more properties on a node (position, texture, shape, modulate, ...). Returns the values read back. Undoable in the editor.

Input parameters:

- `path` (string, required): Node path relative to the scene root ("." is the root), e.g. "Player/Sprite2D".
- `properties` (object, required): Property values. Godot types accept literals ("Vector2(10, 20)"), arrays ([10, 20]), "#ff0000" colors, "res://" paths to load resources, or {"new": "CircleShape2D", "properties": {...}}.
- `scene` (string): Scene file, e.g. "res://main.tscn". Defaults to the scene open in the editor; required when the editor is closed.

### `godot_node_remove` (~100 tokens)

Remove node

Godot node: delete a node and its children from the scene. Undoable in the editor; permanent when headless.

Input parameters:

- `path` (string, required): Node path relative to the scene root ("." is the root), e.g. "Player/Sprite2D".
- `scene` (string): Scene file, e.g. "res://main.tscn". Defaults to the scene open in the editor; required when the editor is closed.

### `godot_node_rename` (~107 tokens)

Rename node

Godot node: rename a node. Note: scripts or NodePaths that refer to the old name are not updated.

Input parameters:

- `name` (string, required)
- `path` (string, required): Node path relative to the scene root ("." is the root), e.g. "Player/Sprite2D".
- `scene` (string): Scene file, e.g. "res://main.tscn". Defaults to the scene open in the editor; required when the editor is closed.

### `godot_node_reparent` (~134 tokens)

Move node

Godot node: move a node under a different parent (and/or to a child index), keeping its global transform by default.

Input parameters:

- `index` (integer)
- `keep_global_transform` (boolean)
- `new_parent` (string, required): New parent path; "." for the root.
- `path` (string, required): Node path relative to the scene root ("." is the root), e.g. "Player/Sprite2D".
- `scene` (string): Scene file, e.g. "res://main.tscn". Defaults to the scene open in the editor; required when the editor is closed.

### `godot_node_duplicate` (~102 tokens)

Duplicate node

Godot node: duplicate a node (with children, script and properties) next to the original.

Input parameters:

- `name` (string)
- `path` (string, required): Node path relative to the scene root ("." is the root), e.g. "Player/Sprite2D".
- `scene` (string): Scene file, e.g. "res://main.tscn". Defaults to the scene open in the editor; required when the editor is closed.

### `godot_script_attach` (~118 tokens)

Attach script

Godot script: attach a .gd (or .cs) script to a node, or detach with script: null. Create the file first with godot_files_write.

Input parameters:

- `path` (string, required): Node path relative to the scene root ("." is the root), e.g. "Player/Sprite2D".
- `scene` (string): Scene file, e.g. "res://main.tscn". Defaults to the scene open in the editor; required when the editor is closed.
- `script` (string|null, required)

### `godot_script_validate` (~83 tokens)

Validate GDScript

Godot script: check GDScript for parse/type errors without running the game. Pass a file path, or source text to check before writing.

Input parameters:

- `path` (string): Script file, e.g. "res://player.gd".
- `source` (string): GDScript source to check instead of (or as if it were at) path.

### `godot_run_start` (~254 tokens)

Run game

Godot run: start the game (main scene, the current scene, or a given scene). Returns a run_id; read errors and prints with godot_run_output, stop with godot_run_stop.

Input parameters:

- `break_on_errors` (boolean): Process mode: stop at script errors like the editor does (default false: errors are recorded, the game keeps running).
- `breakpoints` (array): Process mode: breakpoints set before the first frame, e.g. ["res://player.gd:42"]. Inspect with godot_debug_state.
- `headless` (boolean): Process mode only: no window. Defaults to true when no display is available.
- `mode` (string)
- `quit_after_frames` (integer): Process mode only: quit automatically after N frames (handy for smoke tests).
- `scene` (string): "main" (default), "current" (editor only), or a scene path like "res://levels/test.tscn".
- `write_movie` (string): Process mode: record frames to this file with Godot's Movie Maker (.avi, or .png for an image sequence), e.g. "user://capture.avi". Needs a window.

### `godot_run_stop` (~45 tokens)

Stop game

Godot run: stop a running game (the given run_id, the latest process run, or the game playing in the editor).

Input parameters:

- `run_id` (string)

### `godot_run_output` (~127 tokens)

Game output

Godot run: read output and errors of a game started with godot_run_start (process or editor mode). Use level "error" to see only errors, and "since" (the "next" value from the last call) to page.

Input parameters:

- `errors` (boolean): Script errors with backtraces instead of lines (repeats merged).
- `level` (string)
- `limit` (integer)
- `run_id` (string): Default: the running game (latest run). "editor" for the editor's.
- `since` (integer)

### `godot_editor_logs` (~75 tokens)

Editor log

Godot editor: read messages, warnings and errors printed by the editor process (plugin and tool scripts, import errors; not a running game's prints). Repeats are merged with a count. Page with "since".

Input parameters:

- `level` (string)
- `limit` (integer)
- `since` (integer)

### `godot_editor_launch` (~65 tokens)

Launch editor

Godot editor: open this project in the Godot editor and wait until the MCP plugin connects (the plugin must be enabled in the project).

Input parameters:

- `headless` (boolean): Run the editor without a window (automation, CI).
- `wait_seconds` (integer)

### `godot_node_instance` (~113 tokens)

Instance scene

Godot node: instance a .tscn as a linked sub-scene under a parent, optionally with Editable Children. Undoable in the editor.

Input parameters:

- `editable_children` (boolean)
- `index` (integer)
- `instance` (string, required): e.g. "res://enemy.tscn"
- `name` (string)
- `parent` (string)
- `properties` (object)
- `scene` (string): Scene file; defaults to the edited scene, required without the editor.

### `godot_node_find` (~127 tokens)

Find nodes

Godot node: find nodes in a scene by name (glob/substring), type (incl. subclasses), group, script or property value.

Input parameters:

- `group` (string)
- `limit` (integer)
- `name` (string): Substring or glob (*, ?).
- `property` (string)
- `root` (string): Search under this node.
- `scene` (string): Scene file; defaults to the edited scene, required without the editor.
- `script` (string)
- `type` (string)
- `value`: Required property value.

### `godot_node_move` (~90 tokens)

Reorder node

Godot node: move a node to another position among its siblings (draw/process order). Undoable in the editor.

Input parameters:

- `index` (integer, required): New index; negative counts from the end (-1 = last).
- `path` (string, required): Node path from the scene root ("." = root).
- `scene` (string): Scene file; defaults to the edited scene, required without the editor.

### `godot_node_groups` (~84 tokens)

Edit node groups

Godot node: add or remove a node's groups (saved in the scene). Undoable in the editor.

Input parameters:

- `add` (array)
- `path` (string, required): Node path from the scene root ("." = root).
- `remove` (array)
- `scene` (string): Scene file; defaults to the edited scene, required without the editor.

### `godot_scene_inherit` (~94 tokens)

New inherited scene

Godot scene: create a new scene file that inherits a base scene (like "New Inherited Scene"); opens it in the editor.

Input parameters:

- `base` (string, required): Base scene, e.g. "res://enemy.tscn".
- `open` (boolean)
- `path` (string, required): New .tscn path.
- `root_name` (string): Defaults to the file name in PascalCase.

### `godot_scene_close` (~67 tokens)

Close scene tab

Godot scene: close a scene tab in the editor. Refuses unsaved changes unless save or discard is true.

Input parameters:

- `discard` (boolean): Drop unsaved changes.
- `path` (string): Open scene; defaults to the edited one.
- `save` (boolean)

### `godot_batch_apply` (~90 tokens)

Batch scene edits

Godot scene: apply up to 100 scene edits (node.add, node.set, signal.connect, ...) to one scene in order, all-or-nothing; one undo step in the editor.

Input parameters:

- `ops` (array, required): Later ops see earlier ones (add a node, then set it).
- `scene` (string): Scene file; defaults to the edited scene, required without the editor.

### `godot_signal_list` (~89 tokens)

List signal connections

Godot signal: list saved signal connections of a node or scene and flag problems (missing/mismatched handlers, unconnected _on_* methods).

Input parameters:

- `include_available` (boolean): Also list all signals.
- `path` (string): Default: root.
- `recursive` (boolean)
- `scene` (string): Scene file; defaults to the edited scene, required without the editor.

### `godot_signal_connect` (~147 tokens)

Connect signal

Godot signal: connect a node's signal to a method (saved in the scene), optionally creating the handler stub in the target's script.

Input parameters:

- `binds` (array): Extra call args.
- `create_method` (boolean): Add a stub to the target .gd if missing.
- `flags` (array)
- `from` (string, required): Emitting node.
- `method` (string): Default _on_<from>_<signal>.
- `scene` (string): Scene file; defaults to the edited scene, required without the editor.
- `signal` (string, required)
- `to` (string)
- `unbinds` (integer): Drop N trailing signal args.

### `godot_signal_disconnect` (~77 tokens)

Disconnect signal

Godot signal: remove a saved signal connection from a scene. Undoable in the editor.

Input parameters:

- `from` (string, required)
- `method` (string, required)
- `scene` (string): Scene file; defaults to the edited scene, required without the editor.
- `signal` (string, required)
- `to` (string)

### `godot_resource_read` (~84 tokens)

Read resource

Godot resource: read a .tres/.res/.gdshader (or uid://): class, uid, non-default properties, shader uniforms, theme items.

Input parameters:

- `depth` (integer): Sub-resource expansion depth (default 1).
- `path` (string, required): res:// path or uid://.
- `properties` (array): Only these (nested paths allowed).

### `godot_resource_create` (~150 tokens)

Create resource

Godot resource: create a resource file of any Resource class (materials, Theme, Gradient, shapes...) or a .gdshader with code.

Input parameters:

- `code` (string): For .gdshader.
- `overwrite` (boolean)
- `path` (string, required): e.g. "res://mats/red.tres" or "res://x.gdshader".
- `properties` (object): Values ("#ff0000", [x, y], "res://...", {"new": Class}). Keys may be nested ("next_pass:albedo_color") or Theme items ("Button/colors/font_color").
- `type` (string): Resource class, e.g. "StandardMaterial3D".

### `godot_resource_set` (~96 tokens)

Set resource properties

Godot resource: set properties of an existing resource file and save it (undoable in the editor; open scenes update).

Input parameters:

- `path` (string, required): res:// path or uid://.
- `properties` (object, required): Values ("#ff0000", [x, y], "res://...", {"new": Class}). Keys may be nested ("next_pass:albedo_color") or Theme items ("Button/colors/font_color").

### `godot_resource_deps` (~80 tokens)

Resource dependencies

Godot resource: list a file's dependencies (missing ones flagged), optionally the files that use it; resolves uid:// paths.

Input parameters:

- `dependents` (boolean): Also scan the project for files referencing it.
- `limit` (integer): Max dependents (default 100).
- `path` (string, required): res:// path or uid://.

### `godot_visual_shader_graph` (~84 tokens)

Edit visual shader

Godot visual: edit or create a VisualShader .tres with ordered node ops (add, connect, set...).

Input parameters:

- `create` (boolean)
- `mode` (string): For create.
- `ops` (array, required)
- `path` (string, required)
- `shader_type` (string): e.g. vertex, fragment, light, process.

### `godot_visual_shader_graph_read` (~60 tokens)

Read visual shader

Godot visual: list a VisualShader's nodes (id, class, properties) and connections per shader type.

Input parameters:

- `path` (string, required)
- `shader_type` (string): e.g. vertex, fragment, light, process.

### `godot_visual_layout` (~148 tokens)

Control layout

Godot visual: apply a Control layout preset, anchors/offsets, size flags or minimum size. Undoable.

Input parameters:

- `anchors` (array): [left, top, right, bottom]
- `custom_minimum_size` (array): [w, h]
- `margin` (integer)
- `offsets` (array): [left, top, right, bottom]
- `path` (string, required): Control node path.
- `preset` (string): e.g. full_rect, center, top_wide.
- `resize_mode` (string)
- `scene` (string)
- `size_flags` (object): {horizontal, vertical}: "fill", "expand_fill"...

### `godot_visual_shader_check` (~54 tokens)

Check shader

Godot visual: compile shader code or a .gdshader/VisualShader file and report errors with line numbers.

Input parameters:

- `code` (string): Shader source (wins over path).
- `path` (string)

### `godot_anim_read` (~131 tokens)

Read animations

Godot animation: list an AnimationPlayer's libraries and animations, or with animation the tracks and keys of one. Pass library (a .tres) instead of a scene player to read an AnimationLibrary file.

Input parameters:

- `animation` (string): "name" or "library/name": include its tracks.
- `library` (string): AnimationLibrary .tres instead of a player.
- `max_keys` (number): Keys per track (default 50).
- `player` (string): AnimationPlayer path; optional if the scene has one.
- `scene` (string): Scene; required headless.

### `godot_anim_edit` (~114 tokens)

Edit animations

Godot animation: create/remove/rename animations and add tracks and keys on an AnimationPlayer. ops run in order as one undo step; track paths are "Node:property" relative to the player's root_node.

Input parameters:

- `allow_missing` (boolean): Skip existence checks.
- `animation` (string): Default animation for ops that omit it.
- `ops` (array, required)
- `player` (string): AnimationPlayer path; optional if the scene has one.
- `scene` (string): Scene; required headless.

### `godot_anim_tree_read` (~73 tokens)

Read AnimationTree

Godot animation: show an AnimationTree's graph (states, transitions, blend points, blend tree nodes) and its parameters.

Input parameters:

- `parameters` (boolean)
- `scene` (string): Scene; required headless.
- `tree` (string): AnimationTree path; optional if the scene has one.

### `godot_anim_tree` (~112 tokens)

Edit AnimationTree

Godot animation: build an AnimationTree state machine, blend space or blend tree (states, transitions, start/end, blend points). ops run in order as one undo step.

Input parameters:

- `allow_missing` (boolean): Skip existence checks.
- `nested` (string): Edit a nested graph, e.g. "Locomotion".
- `ops` (array, required)
- `scene` (string): Scene; required headless.
- `tree` (string): AnimationTree path; optional if the scene has one.

### `godot_anim_frames` (~114 tokens)

Edit SpriteFrames

Godot animation: read or edit the SpriteFrames of an AnimatedSprite2D/3D (or a .tres): add/rename/remove animations, speed/loop, frames cut from a sprite sheet. No ops = summary.

Input parameters:

- `node` (string): AnimatedSprite2D/3D; optional if the scene has one.
- `ops` (array)
- `path` (string): SpriteFrames .tres instead of a node.
- `scene` (string): Scene; required headless.

### `godot_grid_read` (~97 tokens)

Read tile/grid map

Godot world: read a TileMapLayer/GridMap: cells, bounds and the TileSet tiles/terrains or MeshLibrary items to paint with.

Input parameters:

- `limit` (integer)
- `path` (string, required)
- `region` (object): {x,y,w,h}; GridMap +z,d
- `scene` (string): Scene; default edited one (required headless)
- `summary_only` (boolean)

### `godot_grid_edit` (~89 tokens)

Edit tile/grid map

Godot world: paint a TileMapLayer/GridMap with ordered ops (set, erase, fill_rect, terrain; clear wipes all cells). One undo step.

Input parameters:

- `ops` (array, required): set/erase/terrain take cells and/or rect. Max 10000 cells.
- `path` (string, required)
- `scene` (string): Scene; default edited one (required headless)

### `godot_tileset_edit` (~89 tokens)

Edit TileSet

Godot world: create/edit a TileSet .tres: atlas sources, collision (one-way), navigation, occlusion, terrains, custom data, per-tile values, alternative tiles, animation. Saved at once.

Input parameters:

- `create` (boolean)
- `ops` (array)
- `path` (string, required): .tres path
- `tile_size` (array)

### `godot_navigation_bake` (~89 tokens)

Bake navigation

Godot world: bake a NavigationRegion2D/3D from its child colliders, meshes, GridMaps and TileMapLayers.

Input parameters:

- `agent_radius` (number)
- `outline` (array): 2D walkable polygon
- `path` (string): Region; default the only one
- `scene` (string): Scene; default edited one (required headless)

### `godot_navigation_path` (~87 tokens)

Navigation path

Godot world: shortest path between two points over the scene's baked navigation regions.

Input parameters:

- `from` (array, required): [x,y] or [x,y,z]
- `layers` (number)
- `optimize` (boolean)
- `path` (string)
- `scene` (string): Scene; default edited one (required headless)
- `to` (array, required)

### `godot_audio_buses` (~37 tokens)

Read audio buses

Godot audio: list the audio buses (volume, mute, solo, send) and their effects from the project's bus layout.

### `godot_audio_edit` (~49 tokens)

Edit audio buses

Godot audio: add, remove, rename, move and set buses (volume, mute, solo, send) and their effects; saves the bus layout.

Input parameters:

- `ops` (array, required)

### `godot_project_set` (~98 tokens)

Set project settings

Godot project: change project settings (project.godot); null resets one to its default. Values are converted to each setting's type.

Input parameters:

- `create` (boolean): Allow adding settings that do not exist yet (custom settings).
- `settings` (object, required): Setting -> value, e.g. {"display/window/size/viewport_width": 1280, "application/run/main_scene": "res://main.tscn"}.

### `godot_input_edit` (~47 tokens)

Edit input map

Godot project: edit the input map (actions and their key/mouse/gamepad bindings), applied in order and saved to project.godot.

Input parameters:

- `ops` (array, required)

### `godot_autoload_edit` (~110 tokens)

Edit autoloads

Godot project: add, remove or reorder autoloads (global singletons loaded at startup).

Input parameters:

- `index` (integer): Load position (0 = first); required for move.
- `name` (string, required): Autoload name, e.g. "GameState".
- `op` (string, required)
- `path` (string): add: script or scene, e.g. "res://game_state.gd".
- `singleton` (boolean): Register as a global name (default true).

### `godot_project_plugins` (~66 tokens)

Editor plugins

Godot project: enable or disable editor plugins (addons) and list the available ones.

Input parameters:

- `disable` (array)
- `enable` (array): Plugin folder names under addons/ or plugin.cfg paths.
- `force` (boolean): Allow disabling godot_mcp itself.

### `godot_project_validate` (~127 tokens)

Validate project

Godot project: health check for missing dependencies, stale or duplicate UIDs, script compile errors, broken autoloads, main scene and plugins.

Input parameters:

- `addons` (boolean): Also check res://addons/ (skipped by default).
- `deep` (boolean): Also load each scene/resource to catch load errors (slower).
- `limit` (integer): Max issues returned (default 200).
- `offset` (integer)
- `path_prefix` (string): Only check files under this folder, e.g. "res://levels".
- `scope` (string)

### `godot_import_get` (~66 tokens)

Get import settings

Godot import: show an asset's importer, non-default options (full: all), uid and whether its imported files exist (imports new assets first).

Input parameters:

- `full` (boolean)
- `path` (string, required): Imported asset, e.g. "res://icon.svg".

### `godot_import_set` (~90 tokens)

Change import settings

Godot import: change an asset's import options (or importer) and reimport it.

Input parameters:

- `importer` (string): Switch importer, e.g. "image", "keep".
- `options` (object): Option keys from import.get (full), e.g. {"compress/mode": 2}.
- `path` (string, required): Imported asset, e.g. "res://icon.svg".

### `godot_export_presets` (~50 tokens)

Export presets

Godot export: list export presets (platform, path, filters, options; secrets redacted) and whether export templates are installed.

Input parameters:

- `preset`: Show one preset with all its options.

### `godot_export_preset_set` (~97 tokens)

Edit export preset

Godot export: change an export preset's fields/options, or create a preset, in export_presets.cfg.

Input parameters:

- `allow_new_keys` (boolean)
- `allow_secrets` (boolean)
- `create` (object)
- `preset`: Preset name or index.
- `set` (object): e.g. {"export_path": "build/game.exe", "binary_format/embed_pck": true}.

### `godot_export_run` (~133 tokens)

Export project

Godot export: build the game with an export preset (release, debug, pack-only .pck/.zip, or patch); long-running.

Input parameters:

- `allow_outside_project` (boolean): Allow an absolute output path outside the project.
- `mode` (string)
- `output` (string): Output file; default the preset's export_path. Relative = inside the project.
- `patches` (array): patch: base .pck files (default: the preset's patches).
- `preset` (string, required): Preset name (see godot_export_presets).
- `timeout_s` (integer)

### `godot_code_diagnostics` (~49 tokens)

GDScript diagnostics

Godot code: GDScript errors and warnings for .gd files or a folder, from the language server.

Input parameters:

- `paths` (array, required): .gd files or folders (res://).

### `godot_code_symbols` (~76 tokens)

GDScript symbols

Godot code: outline of a .gd file (funcs, signals, vars, consts, classes with lines), or find symbols by name with query.

Input parameters:

- `path` (string): .gd file to outline, or folder to search with query.
- `query` (string): Name substring to search for across scripts.

### `godot_code_lookup` (~107 tokens)

GDScript lookup

Godot code: hover docs, definition, references, signature, completion or highlights at a position in a .gd file.

Input parameters:

- `column` (integer): 1-based column; or give symbol.
- `kind` (string)
- `limit` (integer): Max completion items.
- `line` (integer, required): 1-based line.
- `path` (string, required): .gd file (res://).
- `symbol` (string): Identifier text on that line (instead of column).

### `godot_code_rename` (~127 tokens)

Rename GDScript symbol

Godot code: rename a GDScript symbol across the project via the language server (skips comments/strings). dry_run previews.

Input parameters:

- `column` (integer): 1-based column; or give symbol.
- `dry_run` (boolean)
- `include_comments` (boolean): Also rename matches in comments/strings.
- `line` (integer, required): 1-based line.
- `new_name` (string, required): New identifier.
- `path` (string, required): .gd file (res://).
- `symbol` (string): Identifier text on that line (instead of column).

### `godot_docs_search` (~73 tokens)

Search Godot docs

Godot docs: search the offline class reference (engine + project classes) by class/member name or words.

Input parameters:

- `kind` (string)
- `limit` (integer)
- `query` (string, required): e.g. "move_and_slide", "Timer", "Node2D.rot", "play sound".

### `godot_docs_class` (~116 tokens)

Godot class docs

Godot docs: class reference for an engine or project class, or one member ("Class.member"), as markdown.

Input parameters:

- `inherited` (boolean): Also list inherited member names.
- `max_chars` (integer): Cap on the whole result; default 4000, 12000 with members/inherited.
- `members` (boolean): List members with one-line briefs.
- `name` (string, required): e.g. "CharacterBody2D", "Node.add_child", "@GDScript.preload", a project class_name.

### `godot_game_tree` (~146 tokens)

Live game tree

Godot game: the running game's live nodes as a flat list (path, class, script, rect/pos, visible text). Filters list matches only; text "Start" finds the button to click.

Input parameters:

- `class` (string): Incl. subclasses.
- `depth` (integer)
- `group` (string)
- `max_nodes` (integer): Default 150.
- `name` (string): Name contains.
- `root` (string): Default: current scene; "/root" adds autoloads.
- `run_id` (string): Default: newest running game.
- `text` (string): Visible text contains (Label, Button, LineEdit...).

### `godot_game_get` (~124 tokens)

Read live node

Godot game: current values of a live node: script variables and non-default properties (or listed ones, "prop:sub" ok), groups; optionally signal connections and script methods.

Input parameters:

- `methods` (boolean)
- `path` (string): Node path: relative to the current scene (default ".") or /root/....
- `properties` (array): Only these; "get_x()" calls a getter; ["*"] = all incl. defaults.
- `run_id` (string): Default: newest running game.
- `signals` (boolean)

### `godot_game_edit` (~84 tokens)

Change live game

Godot game: change the running game with ops in order: set properties, call a method (returns its value, awaits coroutines), spawn, remove, change/reload scene. Stops at the first failing op; earlier ops stay (no undo, nothing saved).

Input parameters:

- `ops` (array, required)
- `run_id` (string): Default: newest running game.

### `godot_game_eval` (~131 tokens)

Evaluate code in game

Godot game: evaluate code in the running game: an Expression with self = node (default; autoloads and singletons by name), or a GDScript body of func run(node, tree, inputs) (use return). Off unless the server runs with --allow-eval.

Input parameters:

- `code` (string, required)
- `inputs` (object): Named values for the code.
- `mode` (string)
- `path` (string): Node path: relative to the current scene (default ".") or /root/....
- `run_id` (string): Default: newest running game.

### `godot_game_input` (~73 tokens)

Send input to game

Godot game: send input steps in order (keys, actions, clicks on positions or nodes, drags, scroll, typing, joypad, touch, waits). Reports the Control and physics object under each click.

Input parameters:

- `run_id` (string): Default: newest game.
- `steps` (array, required)

### `godot_game_time` (~193 tokens)

Game time control

Godot game: pause/resume the whole game (Godot's suspend: no node processes; SceneTree.paused untouched), step frames or physics ticks, set speed, or wait for a node, signal, condition, frames or seconds.

Input parameters:

- `action` (string, required)
- `condition` (string): Expression on node, e.g. "position.x > 300".
- `frames` (integer): step: frames to advance (default 1); wait_for: frames.
- `node` (string): wait_for: node to appear; signal emitter; condition base.
- `physics_ticks` (integer): step: exactly N physics ticks instead.
- `run_id` (string): Default: newest game.
- `scale` (number): speed: 1 = normal.
- `seconds` (number): wait_for: game seconds.
- `signal` (string)
- `timeout_ms` (integer)

### `godot_game_record` (~118 tokens)

Record/replay game input

Godot game: record the game's input events (real and injected) with timestamps, stop to get them as compact JSON (or save to a file), and replay them with the original timing.

Input parameters:

- `action` (string, required)
- `path` (string): stop: save JSON here (user:// or res://); replay: load from here.
- `recording` (object): replay: the object stop returned.
- `run_id` (string): Default: newest game.
- `speed` (number): replay speed (default 1).

### `godot_game_screenshot` (~205 tokens)

Game screenshot

Godot game: screenshot the running game (window, a node's viewport, or a region) or the editor's 2D/3D view, scaled down. Can save it and diff against a saved image.

Input parameters:

- `compare_to` (string): Saved image to diff with (full resolution; changed_rect in viewport px).
- `format` (string)
- `max_size` (integer): Longest side, px.
- `node` (string): Node to frame (crop to its screen rect), or a viewport.
- `quality` (number): JPEG; default 0.85.
- `region` (object): Crop, in image px (window px with stretch).
- `run_id` (string): Default: newest run, else the editor's game.
- `save_to` (string): user:// or res:// .png/.jpg (full size).
- `source` (string)
- `tolerance` (integer): Per-channel diff threshold.

### `godot_game_perf` (~134 tokens)

Game performance

Godot game: performance monitors of the running game (fps, frame times, memory, objects, draw calls...); optionally sample frames (stats, spikes) and profile script functions.

Input parameters:

- `monitors` (boolean): Full monitor snapshot. Default: only when no sample/profile is asked for.
- `profile_scripts_seconds` (number): Top script functions by self time (process runs).
- `run_id` (string): Default: newest run, else the editor's game.
- `sample_seconds` (number): Record every frame: min/avg/p95/max, spikes.
- `top` (integer): Functions to list.

### `godot_debug_state` (~122 tokens)

Debug state

Godot debug: is the game stopped (breakpoint, error, pause)? Call stack and variables (locals, members, globals) of a frame.

Input parameters:

- `expand` (array): Object variables to open, e.g. ["self","body"].
- `frame` (integer): Frame for variables (0 = innermost).
- `globals` (boolean): Also globals (autoloads).
- `run_id` (string): Default: newest process run.
- `variables` (boolean)
- `wait` (number): Seconds to wait for a stop.

### `godot_debug_control` (~134 tokens)

Debug control

Godot debug: continue, pause, step_into/over/out (returns the new location and locals), or evaluate an expression in a stopped game (process runs).

Input parameters:

- `action` (string, required)
- `expression` (string): evaluate: a Godot Expression; sees locals, self's members/methods, autoloads. Can have side effects.
- `frame` (integer): evaluate: stack frame (0 = innermost).
- `run_id` (string): Default: newest process run.
- `wait` (number): Seconds to wait for the next stop (default 10; continue 0).

### `godot_debug_breakpoints` (~83 tokens)

Breakpoints

Godot debug: list, add, remove or clear breakpoints of a game started with godot_run_start (process mode), running or stopped.

Input parameters:

- `action` (string)
- `breakpoints` (array): "res://player.gd:42" or {file, line}.
- `run_id` (string): Default: newest process run.

### `godot_test_run` (~94 tokens)

Run tests

Godot test: run GUT or GdUnit4 tests headlessly (all, a folder, a file or one test name); returns totals and failures with file:line.

Input parameters:

- `framework` (string)
- `path` (string): Test folder or .gd file; default all tests.
- `test` (string): Test function name (or part of it).
- `timeout_s` (integer)

### `godot_editor_ui` (~116 tokens)

Editor UI

Godot editor: get/set the selected nodes, open a script at a line, save all scenes and scripts, or show a toast.

Input parameters:

- `action` (string, required)
- `column` (integer)
- `line` (integer)
- `message` (string): toast text.
- `paths` (array): select: node paths ([] clears).
- `scene` (string): select/get_selection: scene to open first.
- `script` (string): open_script: res:// path.
- `severity` (string)

### `godot_tools` (~90 tokens)

Find Godot operations

Godot tool catalog: search all available Godot operations by keyword ("search"), or get full parameter schemas for some ("describe").

Input parameters:

- `action` (string, required)
- `operations` (array): describe: operation names from search, e.g. ["node.reparent"].
- `query` (string): search: keywords, e.g. "animation" or "delete node". Empty: names only.

## Diagnostics

Captured diagnostic sections: Provenance, Dependencies. The full working is on the page: https://verifymcp.io/servers/shin2344234-godot-mcp/shin2344234-godot-mcp#diagnostics

## Score history

- 2026-11-05: 80
- 2026-11-04: 79
- 2026-11-03: 79
- 2026-11-02: 79
- 2026-11-01: 78
- 2026-10-31: 78
- 2026-10-30: 77
- 2026-10-29: 77
- 2026-10-28: 76
- 2026-10-27: 76
- 2026-10-26: 75
- 2026-10-25: 75
- 2026-10-24: 74
- 2026-10-23: 74
- 2026-10-22: 73
- 2026-10-21: 73
- 2026-10-20: 72
- 2026-10-19: 72
- 2026-10-18: 72
- 2026-10-17: 60
- 2026-10-16: 71

## Common questions

### What is the Godot MCP server?

Godot MCP is listed in the public MCP registry as io.github.shin2344234/godot-mcp. Edit Godot 4 scenes, nodes and scripts; run, test and debug games live in the editor or headless. This page covers its npm package (@shin2344234/godot-mcp).

### Is the Godot MCP server safe to use?

Godot MCP scores 80 out of 100 on VerifyMCP. We found no known CVEs affecting it as of 5 November 2026. It declares no install or post-install scripts. That is a record of what we were able to check automatically, not an endorsement. The category breakdown on this page shows every signal behind the number, including the ones we could not confirm.

### What tools does the Godot MCP server expose?

Godot MCP exposes 91 tools: godot_status, godot_addon_install, godot_project_info, godot_project_settings, godot_files_list, and 86 more. Their descriptions and schemas cost roughly 9,099 tokens of context every time the server is loaded.

### Is the Godot MCP server still maintained?

Godot MCP is still listed as active in the MCP registry. We last reached this channel on 5 November 2026. Those dates come from our own scans of the registry and the channel itself, not from anything the publisher announced.

### What licence is the Godot MCP server under?

Godot MCP declares the MIT licence, which is OSI-approved. That covers the source only, and says nothing about the cost of any service it calls.

## Links

- npm package: https://www.npmjs.com/package/@shin2344234/godot-mcp
- Socket report: https://socket.dev/npm/package/@shin2344234/godot-mcp
- Repository: https://github.com/shin2344234/godot-mcp
- Changelog RSS feed: https://verifymcp.io/servers/shin2344234-godot-mcp/shin2344234-godot-mcp.xml
- Changelog JSON feed: https://verifymcp.io/servers/shin2344234-godot-mcp/shin2344234-godot-mcp.json
- HTML version of this page: https://verifymcp.io/servers/shin2344234-godot-mcp/shin2344234-godot-mcp