# SketchUp MCP (mcpb · sketchup-mcp-1.3.0.mcpb)

Let AI work in SketchUp: pro tagging, interior quantity takeoff by tag and room, modeling, Ruby.

- Trust score: 41/100 (low)
- Change this week: +3
- Registry status: active
- Liveness: live
- Owner verified: no
- Last scored: 2026-10-23

## Components

- mcpb · `sketchup-mcp-1.3.0.mcpb`: 41/100 (this document), [markdown](https://verifymcp.io/servers/2ez4gcx-sketchup-mcp/sketchup-mcp.md), [page](https://verifymcp.io/servers/2ez4gcx-sketchup-mcp/sketchup-mcp)

## Channel facts

- Registry: `mcpb`
- Package: `https://github.com/2ez4gcx/sketchup-mcp/releases/download/v1.3.0/sketchup-mcp-1.3.0.mcpb`
- Version: `1.3.0`
- Transport: `stdio`
- SHA-256: `eca889bb130800516d7b04c44c6c550ac5056f297e7ea2f1cf0edd2d053d5009`

## 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-10-23.

- **Supply Chain Security**: 0/100
  - No malware scan is available for this kind of package: the supply-chain vendors we use do not cover it. This is a permanent gap in our coverage, not a finding about the package.
  - Known CVEs could not be checked: we found no dependency list to check in this bundle: either it runs a compiled binary, whose bundled manifests we do not read, or none of the package.json, requirements.txt, pyproject.toml or uv.lock files it ships for its runtime declares a dependency we can read (a requirements.txt that only points at a setup.py project, a local path, or a nested requirements file we cannot follow counts as none).
  - Install-script risk not yet assessed.
  - Dependency health could not be checked: we found no dependency list to check in this bundle: either it runs a compiled binary, whose bundled manifests we do not read, or none of the package.json, requirements.txt, pyproject.toml or uv.lock files it ships for its runtime declares a dependency we can read (a requirements.txt that only points at a setup.py project, a local path, or a nested requirements file we cannot follow counts as none).
- **Provenance & Transparency**: 45/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 1 days ago).
  - Disclosure check failed: no security disclosure policy was found in the source repository.
- **Schema Quality & AI Usability**: 64/100
  - AI-judged instruction clarity (good).
  - Context-footprint check failed: tool/resource definitions use about 3750 tokens (~129/item across 29 items; 29 tools + 0 resources), over budget; trim descriptions and params.
  - Usage-examples check failed: none of the tools include examples.
- **Stability & Change Management**: 30/100
  - Stability observed for 9 of 30 days with no destabilising changes; credit accrues until the full window elapses.
- **Tool Coverage**: 83/100
  - 100% of tools have a non-trivial description (not blank, and not just the tool's name).
  - 49% 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 1 tool(s) whose name or description implies an irreversible operation declare an MCP destructiveHint annotation.
  - An AI judge read all 30 captured unit(s) of tool text and found none that tries to manipulate the model reading it.
- **Capabilities**: 100/100
  - Implements a supported MCP spec version (2025-11-25); the latest is 2026-07-28.

**Unverified: 1 category.** A category scored 0 because we could not verify it: a data source with nothing on this package, evidence we could not reach, or a check we could not run. We only credit what we can confirm.

## Install

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

SketchUp MCP ships as an MCPB bundle, a single file you download and open in an MCP host that supports MCPB bundles, such as Claude Desktop. The host reads the launch command from the bundle's own manifest, so there is no command to copy. Before opening it, check the file's SHA-256 matches the one the MCP registry declares for it, eca889bb130800516d7b04c44c6c550ac5056f297e7ea2f1cf0edd2d053d5009; the commands to do that are on this page. If it does not match, do not open it.

- Download bundle: `https://github.com/2ez4gcx/sketchup-mcp/releases/download/v1.3.0/sketchup-mcp-1.3.0.mcpb`
- SHA-256: `eca889bb130800516d7b04c44c6c550ac5056f297e7ea2f1cf0edd2d053d5009`

### Verify on macOS / Linux

```bash
echo "eca889bb130800516d7b04c44c6c550ac5056f297e7ea2f1cf0edd2d053d5009  sketchup-mcp-1.3.0.mcpb" | shasum -a 256 -c
```

### Verify on Windows (PowerShell)

```powershell
(Get-FileHash -Algorithm SHA256 .\sketchup-mcp-1.3.0.mcpb).Hash -eq "eca889bb130800516d7b04c44c6c550ac5056f297e7ea2f1cf0edd2d053d5009"
```

## 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-10-22 (score 41, +1)

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

### 2026-10-21 (score 40, +2)

- [functional regression] Schema quality: pass → fail
- [functional improvement] Tool coverage: 36% → 49%
- [functional improvement] Stability: unverified → 0.23
- [functional] Package version: 1.2.0 → 1.3.0

### 2026-10-14 (score 38, +29)

- [security improvement] Injection markers: unverified → pass
- [security] First check of Judged manipulation: pass
- [security] Stability: Stability not yet verified: not enough scan history yet (needs a 30-day window).
- [functional improvement] Tool coverage: unverified → 100
- [functional improvement] MCP protocol: unverified → pass
- [functional] First check of Tool coverage: 36
- [functional] First check of Schema quality: fail
- [functional] First check of Destructive annotations: 100
- [functional] First check of Schema quality: pass
- [functional] First check of Schema quality: good

### 2026-10-12 (score 9)

First indexed and scored.

## MCP tools (29)

### `ping` (~54 tokens)

Check the connection to SketchUp: returns the SketchUp and Ruby versions, the open model name, and the versions of the bridge in SketchUp and of the MCP server (warns if the bridge is older than the bundled one).

### `model_info` (~49 tokens)

Overview of the open model: path, units, bounding box size (mm), number of top-level groups/components/
faces/edges, and number of tags, materials, definitions, scenes and selected entities.

### `list_tags` (~41 tokens)

List tags (layers): name, visible/hidden, color, folder (SketchUp 2021+) and number of entities using the tag (including inside definitions).

### `list_components` (~44 tokens)

List component definitions and their instance counts (sorted descending) - use it to count
equipment/furniture. include_groups=true also lists groups.

Input parameters:

- `include_groups` (boolean)

### `list_materials` (~26 tokens)

List the materials in the model: name, RGB color, transparency, texture file.

### `selection_info` (~65 tokens)

Info on the selected entities: id, type, name, tag, material, bounding box (mm),
face area (m2), solid volume (m3). The ids are used by the edit/delete tools.

Input parameters:

- `limit` (integer): Maximum number of entities returned in detail

### `quantity_takeoff` (~134 tokens)

Quantity takeoff: walks the whole model recursively (or only the selection) and totals by tag or material:
face area (m2, one side), face count, total edge length (m), solid volume (m3) and
instance count per component. Untagged/unpainted entities inherit from their parent group.
Raw totals only (face area counts every face of a solid): for a bill of quantities use interior_takeoff.

Input parameters:

- `group_by` (string): Group by "tag" (layer) or by "material"
- `include_hidden` (boolean)
- `selection_only` (boolean)

### `setup_tags` (~281 tokens)

Create tags in one Undo step, following the interior tag standard "<CODE>-<NN> <description>", codes: FL floor finishes, SK skirting, WL wall finishes, PA partitions, CL ceilings, CO cornices and trims, DR doors, WN windows, GL glass partitions, JN built-in joinery, FN loose furniture, LT lighting, SN sanitary ware, EQ equipment and appliances, CU curtains and blinds, DE decor and accessories, EX existing structure, RF reference (not measured). Each tag goes into its category folder (SketchUp 2021+, e.g. "FL Floor finishes") and gets its category color (Tags panel > Color by tag). Use it to create every tag of a finish schedule at once, before modelling. Existing tags keep their folder and color unless update_existing=true. Tags without a known code get no folder/color unless given.

Input parameters:

- `language`: Language of NEW category folder names; default: Vietnamese when the tag name has Vietnamese diacritics, else English
- `tags` (array, required): Tag names, e.g. ["FL-01 Engineered oak floor 12mm", "WL-01 Paint, white matt"], or objects {name, color "#RRGGBB", folder}
- `update_existing` (boolean): true = also move EXISTING tags into their category folder and recolor them

### `interior_takeoff` (~536 tokens)

Bill of quantities (BOQ) for interior work: one row per tag (= one specification), with the unit its category needs:
FL floors and CL ceilings -> area m², once per board whatever its face orientation, sloped parts at their real area; WL wall finishes, PA partitions, GL glass -> area of ONE side of each thin upright piece (openings cut in one side deducted), m²; SK skirting, CO cornices -> length m (runs made with Follow Me too); CU curtains -> width x height m²; EX existing structure -> volume m³; DR, WN, JN, FN, LT, SN, EQ, DE -> count (outermost group/component per tag, by definition). Every row also has all the other measures, and the totals per category. by_room=true adds the quantity of every row per room (a room = a named group WITHOUT a tag, e.g. "Living room"; otherwise taken from object names "<code> <room> - <location>"). RF reference tags are skipped. Warnings list geometry that is in no tagged object and parts that could not be measured (e.g. a wall that is not a thin object). csv_path also writes the table to a CSV file for Excel (with by_room: one column per room).

Input parameters:

- `by_room` (boolean): Also split every row by room (rooms = named groups without a tag)
- `csv_format` (string): semicolon = ";" separators and decimal commas, for Excel with Vietnamese/European regional settings
- `csv_path` (string|null): Absolute path of a .csv file to write, e.g. 'D:/BOQ/takeoff.csv' (UTF-8, opens in Excel)
- `include_hidden` (boolean): Also measure hidden objects and objects on hidden tags/folders (they are listed in warnings otherwise)
- `language` (string): Language of category names, room placeholder and CSV headers/units
- `max_thickness_mm` (number): Thicker pieces are never taken for a wall/board (e.g. a corridor drawn as one box)
- `measures`: Unit override per tag name, per code-number ("LT-05") or per code ("JN"), e.g. {"LT-05": "length", "JN": "elevation_area"}
- `overwrite` (boolean): Replace csv_path if it already exists
- `selection_only` (boolean): Only the selected objects (e.g. one room)
- `thin_ratio` (number): A piece is thin when its thickness <= thin_ratio x its smaller in-plane size

### `create_box` (~219 tokens)

Create a rectangular box (group). width along X, depth along Y, height along Z, in mm.
origin [x,y,z] mm is the lower-left corner. Missing tags/materials are created; color is '#RRGGBB' or a color name (only applied when the material is newly created; an existing material keeps its color). Returns: {id, persistent_id, type, name, tag, material, bounds_mm{min,max,size}}.

Input parameters:

- `color` (string|null)
- `depth` (number, required): Size along the Y axis (mm), > 0
- `height` (number, required): Size along the Z axis (mm), > 0
- `material` (string|null)
- `name` (string|null)
- `origin`: MIN corner (bottom-left-front) [x,y,z] mm, NOT the center; default [0,0,0]
- `tag` (string|null)
- `width` (number, required): Size along the X axis (mm), > 0

### `create_shape` (~178 tokens)

Draw a flat face from a polygon (list of [x,y,z] mm points, >= 3 coplanar points) in a new group.
pushpull (mm) extrudes it into a solid (e.g. draw a floor outline, then pull it up to the slab thickness). Returns: {id, persistent_id, type, name, tag, material, bounds_mm{min,max,size}}.

Input parameters:

- `color` (string|null)
- `material` (string|null)
- `name` (string|null)
- `points` (array, required): Polygon vertices [[x,y,z],...] mm, >= 3 coplanar points, in order around the perimeter
- `pushpull` (number|null): Extrusion thickness (mm); a horizontal face is pulled up along +Z
- `tag` (string|null)

### `create_lines` (~77 tokens)

Draw a polyline through [x,y,z] mm points in a new group. close_face=true: closes back to the first point and creates a face (the result has face_created).

Input parameters:

- `close_face` (boolean)
- `name` (string|null)
- `points` (array, required)
- `tag` (string|null)

### `insert_component` (~128 tokens)

Insert a component: from a .skp file (path, e.g. 'D:/Library/table.skp') or from a definition already in
the model (definition = name). position [x,y,z] mm, rotation_deg rotates about the Z axis.

Input parameters:

- `definition` (string|null)
- `material` (string|null)
- `name` (string|null)
- `path` (string|null)
- `position`: Insertion point (component origin) [x,y,z] mm
- `rotation_deg` (number)
- `tag` (string|null)

### `transform_entities` (~208 tokens)

Move / rotate / scale entities. Empty entity_ids = use the current selection.
translate [dx,dy,dz] mm; rotate_deg about axis (default Z) at pivot (mm, default entity center);
scale is a uniform factor. Order applied: scale -> rotate -> translate.

Input parameters:

- `axis`: Rotation axis [x,y,z]; default [0,0,1]
- `entity_ids`: Ids from tool results (selection_info, create_*...); only valid in the current SketchUp session. Empty = current selection.
- `pivot`: Rotation/scale center [x,y,z] mm; default = bounding box center of the FIRST entity
- `rotate_deg` (number|null): Rotation angle (degrees), positive = counterclockwise when viewed from the axis tip
- `scale`: Uniform scale factor, > 0 (e.g. 1.5)
- `translate`: RELATIVE offset [dx,dy,dz] mm, not a target position

### `set_material` (~124 tokens)

Apply a material to entities (entity_ids or the current selection). A missing material is created with color; an EXISTING material keeps its color (unless update_existing=true).

Input parameters:

- `back_too` (boolean)
- `color` (string|null)
- `entity_ids`: Ids from tool results (selection_info, create_*...); only valid in the current SketchUp session. Empty = current selection.
- `material` (string, required)
- `update_existing` (boolean|null): true = also recolor an EXISTING material (affects EVERY entity that uses it)

### `set_tag` (~91 tokens)

Assign a tag to entities (entity_ids or the current selection). A missing tag is created (in its category folder with its category color when it follows the tag standard). Tag groups/components, not raw faces or edges.

Input parameters:

- `entity_ids`: Ids from tool results (selection_info, create_*...); only valid in the current SketchUp session. Empty = current selection.
- `tag` (string, required)

### `make_group` (~189 tokens)

Put existing entities into a new group (they must be at the level being edited, e.g. the top level). Use it for rooms: a named group WITHOUT a tag (e.g. name "Living room") holding the finishes and items of that room, so interior_takeoff can split quantities by room. With tag, it makes an assembly (e.g. several skirting runs). Returns: {id, persistent_id, type, name, tag, material, bounds_mm{min,max,size}}.

Input parameters:

- `entity_ids` (array, required): Ids from tool results (selection_info, create_*...); only valid in the current SketchUp session.
- `name` (string|null): Group name, e.g. the room name "Living room" or "Level 2 / Bedroom 1" is built from nested rooms
- `tag` (string|null): Leave empty for a room

### `delete_entities` (~55 tokens)

Delete entities by id (ids are required; never deletes by selection). Can be undone.

Input parameters:

- `entity_ids` (array, required): Ids from tool results (selection_info, create_*...); only valid in the current SketchUp session.

### `select_entities` (~66 tokens)

Select entities by id in SketchUp (so the user can see them, or for later tools to use).

Input parameters:

- `clear` (boolean)
- `entity_ids` (array, required): Ids from tool results (selection_info, create_*...); only valid in the current SketchUp session.

### `undo` (~25 tokens)

Undo the last step in SketchUp (every model-editing tool is one Undo step).

### `run_ruby` (~154 tokens)

Run arbitrary Ruby code in SketchUp (Ruby API). Use it when the other tools are not enough.
Useful objects: Sketchup.active_model, model.entities, model.selection. Internal units are inches:
use 1000.mm, x.to_mm. The whole snippet is one Undo step. Returns the last value (inspect) and the puts output.
Rules: do NOT call start_operation/commit_operation (the bridge already wraps the code in one Undo step); find entities with Sketchup.active_model.find_entity_by_id(id); check face.normal before pushpull; vertex coordinates inside a group are local (multiply by the parent group transformation); end with a value or puts; never call exit.

Input parameters:

- `code` (string, required)

### `set_view` (~53 tokens)

Set a standard view and zoom extents. iso defaults to perspective, the other views to parallel projection.

Input parameters:

- `perspective` (boolean|null)
- `view` (string)
- `zoom_extents` (boolean)

### `screenshot` (~122 tokens)

Capture the SketchUp viewport and return the image so Claude can see it directly (to check modelling results).
Empty view = keep the current view. With view, the camera changes only temporarily for the capture and the previous view is restored afterwards.

Input parameters:

- `height`
- `max_size` (integer): Longest image side (px), keeps the viewport aspect ratio
- `view`: Temporary capture view; empty = the user's current view
- `width`: Fixed size (use together with height); if only width or height is given it is treated as the longest side

### `export_png` (~71 tokens)

Export the viewport as a PNG/JPG file (e.g. 'D:/Export/perspective.png'). width/height in pixels; view changes the camera first.

Input parameters:

- `height`
- `path` (string, required)
- `transparent` (boolean)
- `view`
- `width`

### `export_file` (~58 tokens)

Export the model to a 3D/2D file chosen by extension (dae, obj, stl, fbx, dwg, dxf, 3ds...). Some formats require SketchUp Pro.

Input parameters:

- `path` (string, required)

### `save_model` (~34 tokens)

Save the model. Empty path = overwrite the current file; with path = Save As.

Input parameters:

- `path` (string|null)

### `open_model` (~25 tokens)

Open a .skp file in SketchUp.

Input parameters:

- `path` (string, required)

### `new_model` (~16 tokens)

Create a new (empty) model.

### `install_sketchup_bridge` (~133 tokens)

Install (or update) the "SU MCP Bridge" extension in SketchUp so the other tools can connect. Copies su_mcp.rb + su_mcp/main.rb into the Plugins folder of every SketchUp version found (Windows: %APPDATA%/SketchUp/SketchUp 20xx/SketchUp/Plugins). SketchUp must be restarted afterwards. Empty versions = every version opened at least once; dry_run=true only reports what would be done. Also returns the path of su_mcp.rbz for a manual install via Extension Manager.

Input parameters:

- `dry_run` (boolean)
- `versions`

## Diagnostics

Captured diagnostic sections: Provenance. The full working is on the page: https://verifymcp.io/servers/2ez4gcx-sketchup-mcp/sketchup-mcp#diagnostics

## Score history

- 2026-10-23: 41
- 2026-10-22: 41
- 2026-10-21: 40
- 2026-10-20: 38
- 2026-10-19: 38
- 2026-10-18: 38
- 2026-10-17: 38
- 2026-10-16: 38
- 2026-10-15: 38
- 2026-10-14: 38
- 2026-10-13: 9
- 2026-10-12: 9

## Common questions

### What is the SketchUp MCP server?

SketchUp MCP is listed in the public MCP registry as io.github.2ez4gcx/sketchup-mcp. Let AI work in SketchUp: pro tagging, interior quantity takeoff by tag and room, modeling, Ruby. This page covers its MCPB bundle (https://github.com/2ez4gcx/sketchup-mcp/releases/download/v1.3.0/sketchup-mcp-1.3.0.mcpb).

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

SketchUp MCP scores 41 out of 100 on VerifyMCP. 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 SketchUp MCP server expose?

SketchUp MCP exposes 29 tools: ping, model_info, list_tags, list_components, list_materials, and 24 more. Their descriptions and schemas cost roughly 3,256 tokens of context every time the server is loaded.

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

SketchUp 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

- Repository: https://github.com/2ez4gcx/sketchup-mcp
- Changelog RSS feed: https://verifymcp.io/servers/2ez4gcx-sketchup-mcp/sketchup-mcp.xml
- Changelog JSON feed: https://verifymcp.io/servers/2ez4gcx-sketchup-mcp/sketchup-mcp.json
- HTML version of this page: https://verifymcp.io/servers/2ez4gcx-sketchup-mcp/sketchup-mcp