# GridPath (npm · gridpath)

Edit real .xlsx files with your agent: live formulas, and you review every change before it saves.

- Trust score: 63/100 (medium)
- Registry status: active
- Liveness: live
- Owner verified: no
- Last scored: 2026-10-18

## Components

- npm · `gridpath`: 63/100 (this document), [markdown](https://verifymcp.io/servers/pixelsmasher13-gridpath/gridpath.md), [page](https://verifymcp.io/servers/pixelsmasher13-gridpath/gridpath)

## Channel facts

- Registry: `npm`
- Package: `gridpath`
- Version: `0.1.9`
- 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-10-18.

- **Supply Chain Security**: 98/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.
  - 31 of 93 dependencies flagged as unhealthy.
- **Provenance & Transparency**: 32/100
  - Source repository is publicly reachable at the declared URL.
  - Provenance check failed: no build-provenance attestation is published.
  - License check failed: the license (FSL-1.1-Apache-2.0) isn't a recognized OSI-approved license.
  - Actively maintained (last published 16 days ago).
  - Disclosure check failed: no security disclosure policy was found in the source repository.
- **Schema Quality & AI Usability**: 58/100
  - AI-judged instruction clarity (good).
  - Context-footprint check failed: tool/resource definitions use about 5408 tokens (~169/item across 32 items; 32 tools + 0 resources), over budget; trim descriptions and params.
  - Usage-examples check failed: none of the tools include examples.
- **Stability & Change Management**: 0/100
  - Stability not yet verified: not enough scan history yet (needs a 30-day window).
- **Tool Coverage**: 89/100
  - 100% of tools have a non-trivial description (not blank, and not just the tool's name).
  - 68% 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 8 tool(s) whose name or description implies an irreversible operation declare an MCP destructiveHint annotation.
  - An AI judge read all 33 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 GridPath MCP server?

GridPath runs locally as an npm package, launched with npx -y gridpath. 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 pixelsmasher13-gridpath -- npx -y gridpath
```

### Cursor

```json
{
  "mcpServers": {
    "pixelsmasher13-gridpath": {
      "command": "npx",
      "args": [
        "-y",
        "gridpath"
      ]
    }
  }
}
```

### VS Code

```json
{
  "servers": {
    "pixelsmasher13-gridpath": {
      "command": "npx",
      "args": [
        "-y",
        "gridpath"
      ]
    }
  }
}
```

### Codex

```bash
codex mcp add pixelsmasher13-gridpath -- npx -y gridpath
```

### opencode

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

### OpenClaw

```bash
openclaw mcp add pixelsmasher13-gridpath --command npx --arg -y --arg gridpath
```

### Hermes

```yaml
mcp_servers:
  pixelsmasher13-gridpath:
    command: "npx"
    args: ["-y", "gridpath"]
```

### Netclaw

```json
{
  "McpServers": {
    "pixelsmasher13-gridpath": {
      "Transport": "stdio",
      "Command": "npx",
      "Arguments": [
        "-y",
        "gridpath"
      ]
    }
  }
}
```

### Vellum

```bash
assistant mcp add pixelsmasher13-gridpath -t stdio -c npx -a -y gridpath
```

### Other

```json
{
  "mcpServers": {
    "pixelsmasher13-gridpath": {
      "command": "npx",
      "args": [
        "-y",
        "gridpath"
      ]
    }
  }
}
```

## 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-14 (score 63, +27)

- [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 Schema quality: fail
- [functional] First check of Schema quality: fail
- [functional] First check of Destructive annotations: 100
- [functional] First check of Tool coverage: 68
- [functional] First check of Schema quality: good

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

First indexed and scored.

## MCP tools (32)

### `set_cell` (~196 tokens)

Set the value or formula of a single cell. `cell` is an Excel A1-style address (case-insensitive, e.g. "A1", "B17", "AA42"). For formulas, pass them in `formula` starting with '=' (e.g. "=SUM(A1:A10)") — do NOT put formulas in `value`.

Input parameters:

- `cell` (string, required): A1 address. Examples: "A1", "B17", "AA42".
- `formula` (string|null): Excel-style formula starting with '='. References inside use A1 notation. Example: "=SUM(A1:A10)".
- `path` (string, required): Path of the .xlsx to operate on (absolute, or ~/… for the user's home directory).
- `sheet` (string, required): Sheet name (case-sensitive).
- `value`: Literal value (string, number, boolean, or null). Leave null when using `formula`.

### `set_range` (~441 tokens)

Set a rectangular block of values starting at `top_left` (A1 address). `values` is a 2D array — outer rows, inner cells. Strings starting with '=' inside `values` are treated as formulas; formula references must use A1 notation pointing at the FINAL placement of cells (e.g. if `top_left` is "A9" and the value at row index 2 / col 0 should reference the data row just above your block at A8, write "=A8" — not "=A1" or "=A11"). **Off-by-one guard: if formulas will reference rows created by THIS call, split the work — write labels + hardcoded values first, read the `row_map` in this call's result, then write formulas in a second set_range against those verified row numbers.** Composing formulas in the same call that lays out their target rows is the top source of off-by-one references. Use this for bulk writes; prefer it over many set_cell calls. **`null` and empty string `""` inside `values` are treated as PRESERVE — the cell is left untouched, NOT cleared.** This means you can ship `[["Gross Profit", "", "", ""]]` to set only the label in column A without wiping the data in B–D. To actually clear cells, use `clear_range`. **Writing to a sheet name that doesn't exist CREATES that sheet automatically** (near-miss spellings of an existing sheet are rejected as probable typos) — so organize multi-section builds across purposefully named sheets (e.g. Data / Assumptions / Model / Notes) instead of piling everything onto one long sheet; a new tab costs nothing.

Input parameters:

- `path` (string, required): Path of the .xlsx to operate on (absolute, or ~/… for the user's home directory).
- `sheet` (string, required)
- `top_left` (string, required): A1 address of the top-left cell, e.g. "A9".
- `values` (array, required): 2D array — outer = rows, inner = cells. Strings beginning with '=' are formulas.

### `copy_range` (~370 tokens)

Copy a rectangular range to another location with Excel copy/paste semantics, executed against the LIVE grid: relative formula references shift by the paste offset exactly like Excel ($ anchors are respected — `$B$5` stays put, `B5` shifts), and cell formatting (number format, font, fill, alignment) travels with the cells. STRONGLY PREFER this over reading a range and re-typing shifted formulas yourself — it cannot make off-by-one mistakes and costs a fraction of the tokens. Ideal for: extending a projection by one more period (copy the last full year column block to the next column), duplicating a section as a template, or seeding a new sheet from an existing block. Blank source cells leave the destination untouched (they do NOT clear it). Result reports the evaluated destination values so you can verify. Limited to 5000 cells per call.

Input parameters:

- `dest` (string, required): A1 address of the destination TOP-LEFT cell, e.g. "BU5". The copy lands in a rectangle of the same size starting here.
- `dest_sheet` (string|null): Destination sheet if different from `sheet`. Formula references shift the same way; sheet-qualified refs keep pointing at their original sheets.
- `mode` (string): "all" (default): shifted formulas + values + formats. "values": paste evaluated values only — use to freeze a calculation as hardcodes. "formats": formatting only, contents untouched.
- `path` (string, required): Path of the .xlsx to operate on (absolute, or ~/… for the user's home directory).
- `sheet` (string, required): Source sheet name (case-sensitive).
- `source` (string, required): A1 range to copy, e.g. "BT5:BT120" or a single cell "C7".

### `run_script` (~698 tokens)

Execute a short JavaScript program against the workbook and land ALL its writes as one reviewable batch. STRONGLY PREFER this over long set_range payloads or many tool turns whenever the edit is loop-shaped: per-row conditional transforms ("for every row where margin < 0 …"), repeating formula patterns across many rows/columns, address arithmetic, or edits that depend on reading existing cells first. One run_script call replaces dozens of tool turns and cannot drift out of alignment mid-payload, because it computes addresses programmatically.

API (plain synchronous JavaScript, strict mode — no async/await, no imports, no network, no DOM):
  sheets() -> array of sheet names
  sheet(name) -> handle for one sheet (name must match exactly; the name arg may be omitted ONLY if the workbook has a single sheet). Handle methods:
    .get("B7") -> {value, formula} — evaluated value as of BEFORE this script, overlaid with your own literal writes
    .values("A2:C50") -> 2D array of values (rows × cols)
    .set("B7", x) — write a value; strings starting with '=' are formulas; null clears the cell's content
    .setValues("A9", [[...],[...]]) — bulk write with set_range semantics: null / "" preserve the existing cell
    .format("A1:F1", {bold: true, number_format: "0.0%", background_color: "#1F4E79", font_color: "#FFFFFF"}) — same keys as set_format
    .clear("B2:D10") — empty values + formulas, formatting preserved
    .usedRange() -> "A1:Q48" or null
  log(...) — up to 100 entries, returned to you in the result as `script_logs` for debugging

Rules: formulas you write are NOT evaluated during the script — .get on a cell you just wrote a formula into returns {value: null, formula}; the automatic readback after the script (cells + row_map) carries the evaluated results, so verify there. Follow the same conventions as set_range: write raw numbers (never pre-formatted strings), write formulas for derived values, compose against row_map. Limits: 5-second CPU cap, 20,000 touche…

Input parameters:

- `path` (string, required): Path of the .xlsx to operate on (absolute, or ~/… for the user's home directory).
- `script` (string, required): JavaScript source, executed as a function body. Example: const s = sheet("Model"); const rows = s.values("A2:C50"); rows.forEach((r, i) => { if (r[2] !== null && r[2] < 0) s.set("D" + (i + 2), "=C" +…

### `set_format` (~379 tokens)

Apply formatting to one OR MANY cell ranges in a single call. STRONGLY PREFER the bulk `operations` form when you have more than one format to apply — it's one tool call instead of N, dramatically faster. Each operation's `format` is a partial object; only specified properties are applied, others are left as-is. Use this for: bold headers, currency / percent / number formatting on data columns, italic notes, alignment, font color/size/family, **text wrap via `wrap_text`** (long methodology notes / descriptions in a fixed-width column — wrap beats restructuring the layout around overflow), and **cell fill via `background_color`** (e.g. dark-blue header bars, yellow assumption highlights — see the financial-model color conventions). v1 limitation: cell borders are not yet supported.

Two equivalent shapes:
  • Single range: { sheet, range, format }
  • Bulk:         { sheet, operations: [ { range, format }, ... ] }

Input parameters:

- `format` (object): Partial format (only when using single-range form).
- `operations` (array): Bulk form — array of {range, format} pairs. Use this whenever you have ≥2 formats to apply. Example: [{"range":"A1","format":{"bold":true,"font_size":16}},{"range":"B8:F8","format":{"number_format":"…
- `path` (string, required): Path of the .xlsx to operate on (absolute, or ~/… for the user's home directory).
- `range` (string): A1 range (only when using single-range form). Examples: "A1", "B2:B10", "A1:F1".
- `sheet` (string, required)

### `set_column_width` (~182 tokens)

Set the pixel width of one or more columns. **Always prefer the bulk `operations` form when you need multiple widths** (e.g. label column A wide, data columns narrower) — one call instead of N. The flat single-width form is kept for trivial cases. Default Excel column is ~64px; a wide column for labels is typically 180–220.

Input parameters:

- `columns` (string): Single-op form (omit `operations`). Comma-separated column letters.
- `operations` (array): Bulk form. Each entry sets a width on a group of columns. Use this when you need different widths for different column groups.
- `path` (string, required): Path of the .xlsx to operate on (absolute, or ~/… for the user's home directory).
- `sheet` (string, required)
- `width` (number): Single-op form pixel width.

### `set_row_height` (~159 tokens)

Set the pixel height of one or more rows. **Always prefer the bulk `operations` form when you need multiple heights** (e.g. title row tall, body rows short) — one call instead of N. The flat single-height form is kept for trivial cases. Default row is ~24.

Input parameters:

- `height` (number): Single-op form pixel height.
- `operations` (array): Bulk form. Each entry sets a height on a group of rows.
- `path` (string, required): Path of the .xlsx to operate on (absolute, or ~/… for the user's home directory).
- `rows` (string): Single-op form (omit `operations`). Comma-separated 1-indexed row numbers.
- `sheet` (string, required)

### `merge_cells` (~80 tokens)

Merge a rectangular range into a single visible cell (e.g. for section headers). `range` is an A1 range like "A1:F1".

Input parameters:

- `path` (string, required): Path of the .xlsx to operate on (absolute, or ~/… for the user's home directory).
- `range` (string, required)
- `sheet` (string, required)

### `unmerge_cells` (~56 tokens)

Unmerge a previously merged range.

Input parameters:

- `path` (string, required): Path of the .xlsx to operate on (absolute, or ~/… for the user's home directory).
- `range` (string, required)
- `sheet` (string, required)

### `set_note` (~121 tokens)

Attach a note (Excel-style cell comment) to a single cell — a small indicator that shows the given text on hover. Use this for methodology callouts, source citations, or caveats that would clutter the cell's own value. Overwrites any existing note on that cell.

Input parameters:

- `cell` (string, required): A1 address, e.g. "B7".
- `path` (string, required): Path of the .xlsx to operate on (absolute, or ~/… for the user's home directory).
- `sheet` (string, required)
- `text` (string, required)

### `delete_note` (~78 tokens)

Remove a cell's note, if it has one. No-op if the cell has no note.

Input parameters:

- `cell` (string, required): A1 address, e.g. "B7".
- `path` (string, required): Path of the .xlsx to operate on (absolute, or ~/… for the user's home directory).
- `sheet` (string, required)

### `create_sheet` (~164 tokens)

Create a new sheet (worksheet tab) in the workbook. Use a clear human-readable name like "Assumptions", "Q4 2024", "Inputs". The new sheet starts empty — write cells with set_cell / set_range afterwards. NOTE: writes to a not-yet-existing sheet name auto-create it, so an explicit create_sheet is only needed when you want to set a tab_color or create an empty tab ahead of time.

Input parameters:

- `name` (string, required): Sheet name (must be unique in the workbook).
- `path` (string, required): Path of the .xlsx to operate on (absolute, or ~/… for the user's home directory).
- `tab_color` (string|null): Optional CSS color for the tab, e.g. "#22c55e".

### `delete_sheet` (~69 tokens)

Remove a sheet from the workbook. Permanent — every cell on this sheet is lost. Cross-sheet references in other sheets will become #REF!.

Input parameters:

- `name` (string, required)
- `path` (string, required): Path of the .xlsx to operate on (absolute, or ~/… for the user's home directory).

### `rename_sheet` (~70 tokens)

Rename a sheet. Cross-sheet formula references in other sheets will be updated automatically by the workbook engine.

Input parameters:

- `new_name` (string, required)
- `old_name` (string, required)
- `path` (string, required): Path of the .xlsx to operate on (absolute, or ~/… for the user's home directory).

### `clear_range` (~106 tokens)

Empty the values AND formulas of cells in `range`. Use this when you want to delete content (not just overwrite with new values). `range` is an A1 range like "A1", "A1:F1", or "B2:D10". Cell formatting is preserved.

Input parameters:

- `path` (string, required): Path of the .xlsx to operate on (absolute, or ~/… for the user's home directory).
- `range` (string, required)
- `sheet` (string, required)

### `insert_rows` (~135 tokens)

Insert `count` empty rows starting at (and shifting down from) row `before` (1-indexed Excel row number). Existing content at row `before` and below shifts down. Use this to make space in the middle of a model. Charts and conditional-formatting references in unrelated areas of the workbook may not auto-adjust to the new layout.

Input parameters:

- `before` (integer, required): 1-indexed row number to insert before.
- `count` (integer)
- `path` (string, required): Path of the .xlsx to operate on (absolute, or ~/… for the user's home directory).
- `sheet` (string, required)

### `delete_rows` (~84 tokens)

Delete `count` rows starting at row `start` (1-indexed). Content below shifts up. Permanent — the removed rows are gone.

Input parameters:

- `count` (integer)
- `path` (string, required): Path of the .xlsx to operate on (absolute, or ~/… for the user's home directory).
- `sheet` (string, required)
- `start` (integer, required)

### `insert_columns` (~96 tokens)

Insert `count` empty columns starting at (and shifting right from) column `before` (column letter like "C"). Existing content shifts right.

Input parameters:

- `before` (string, required): Column letter to insert before, e.g. "C".
- `count` (integer)
- `path` (string, required): Path of the .xlsx to operate on (absolute, or ~/… for the user's home directory).
- `sheet` (string, required)

### `delete_columns` (~82 tokens)

Delete `count` columns starting at column `start` (column letter like "C"). Content to the right shifts left. Permanent.

Input parameters:

- `count` (integer)
- `path` (string, required): Path of the .xlsx to operate on (absolute, or ~/… for the user's home directory).
- `sheet` (string, required)
- `start` (string, required)

### `freeze_panes` (~128 tokens)

Freeze the top `rows` rows and left `cols` columns of a sheet so they stay visible while scrolling. Classic financial-model setup is `freeze_rows: 1, freeze_cols: 1` (lock the header row and label column). Pass 0 to disable that axis.

Input parameters:

- `freeze_cols` (integer, required): Number of left columns to freeze.
- `freeze_rows` (integer, required): Number of top rows to freeze.
- `path` (string, required): Path of the .xlsx to operate on (absolute, or ~/… for the user's home directory).
- `sheet` (string, required)

### `unfreeze_panes` (~51 tokens)

Remove any freeze panes from a sheet.

Input parameters:

- `path` (string, required): Path of the .xlsx to operate on (absolute, or ~/… for the user's home directory).
- `sheet` (string, required)

### `hide_rows` (~105 tokens)

Hide one or more rows. `rows` is a comma-separated list of 1-indexed row numbers (e.g. "3" or "3,5,12"). Hidden rows still hold data but don't display in the workbook.

Input parameters:

- `path` (string, required): Path of the .xlsx to operate on (absolute, or ~/… for the user's home directory).
- `rows` (string, required): Comma-separated 1-indexed row numbers.
- `sheet` (string, required)

### `show_rows` (~64 tokens)

Unhide one or more rows. Same `rows` format as hide_rows.

Input parameters:

- `path` (string, required): Path of the .xlsx to operate on (absolute, or ~/… for the user's home directory).
- `rows` (string, required)
- `sheet` (string, required)

### `hide_columns` (~83 tokens)

Hide one or more columns. `columns` is a comma-separated list of column letters (e.g. "D" or "D,F,H").

Input parameters:

- `columns` (string, required): Comma-separated column letters.
- `path` (string, required): Path of the .xlsx to operate on (absolute, or ~/… for the user's home directory).
- `sheet` (string, required)

### `show_columns` (~64 tokens)

Unhide one or more columns. Same `columns` format as hide_columns.

Input parameters:

- `columns` (string, required)
- `path` (string, required): Path of the .xlsx to operate on (absolute, or ~/… for the user's home directory).
- `sheet` (string, required)

### `read_range` (~216 tokens)

Read evaluated cell values from a specific A1 range WITHOUT modifying anything. Use this to verify your own work, confirm where the assumption block actually landed before composing dependent formulas, or pull current values you need to reference. Returns each non-empty cell's value AND formula (if any) in `A1 = value` form. Costs one tool turn but is the cheapest way to prevent the formula-pointing-at-wrong-row class of bug on long sheets. Range limited to 500 cells per call. To LOCATE a row/section/header by NAME, don't probe with this — use `find_rows` or `describe_workbook` first, then read the exact range.

Input parameters:

- `path` (string, required): Path of the .xlsx to operate on (absolute, or ~/… for the user's home directory).
- `range` (string, required): A1 range, e.g. "G45:K45", "A1:Z10", or a single cell "B7".
- `sheet` (string, required): Sheet name (case-sensitive).

### `describe_workbook` (~187 tokens)

Get a structural map of the ACTIVE workbook without reading cell data. Per sheet: the used range, the detected header row with its period/column headers mapped to column letters (e.g. {"BU": "FY2026E"}), and a table of contents of sections — contiguous row bands with their titles, like {"rows": "5-42", "title": "Revenue build"}. Also lists workbook defined names. Served from an in-memory index, so it's near-instant and returns in ONE call what would take many read_range probes. Call it once to orient on any sheet whose preview is truncated. Optional `sheet` filters to a single sheet.

Input parameters:

- `path` (string, required): Path of the .xlsx to operate on (absolute, or ~/… for the user's home directory).
- `sheet` (string): Optional: limit the map to this sheet (case-sensitive).

### `find_rows` (~230 tokens)

Search the ACTIVE workbook's row labels and column headers by name and get exact positions back — e.g. query "total revenue" returns each matching row's sheet, 1-indexed row number, containing section, and one evaluated sample cell ("BT209 = =BT194 → 39001.1") read live from the grid. Matching is case-insensitive substring plus word-prefix ("tot rev" matches "Total revenue"). Near-instant. Use this — NOT exploratory read_range probes — whenever you need to LOCATE a row or header ("where is Subscriber ARPU?", "which column is FY2027E?"); then read_range the exact range you need. Searches only the active workbook, not reference workbooks.

Input parameters:

- `max_results` (integer): Max matches to return (default 20).
- `path` (string, required): Path of the .xlsx to operate on (absolute, or ~/… for the user's home directory).
- `query` (string, required): Label text to find, e.g. "total revenue".
- `sheet` (string): Optional: search only this sheet (case-sensitive).

### `define_name` (~261 tokens)

Create (or replace) a workbook-scoped named range so formulas can reference a cell/range by a readable name instead of a raw address — e.g. name `GrowthRate` for the assumption cell, then write `=Revenue*(1+GrowthRate)`. The name persists in the saved .xlsx. `name` must be a valid Excel name (letters, digits, underscores; can't look like a cell reference such as "A1"). `ref` must be sheet-qualified, e.g. "Model!B22" or "Model!B5:B12" (absolute `$` signs optional — they're added automatically). Calling again with the same `name` replaces its target.

Input parameters:

- `name` (string, required): Defined name, e.g. "GrowthRate" or "Revenue". Must not look like a cell address.
- `path` (string, required): Path of the .xlsx to operate on (absolute, or ~/… for the user's home directory).
- `ref` (string, required): Sheet-qualified target, e.g. "Model!B22" or "Assumptions!B5:B12".
- `sheet` (string): Optional. Only needed if `ref` is a bare range without a sheet prefix; supplies the sheet for it.

### `list_batches` (~55 tokens)

List this workbook's pending (unsaved) change batches with their mutation counts, and the review link.

Input parameters:

- `path` (string, required): Path of the .xlsx to operate on (absolute, or ~/… for the user's home directory).

### `reject_batch` (~68 tokens)

Drop one pending batch. The remaining batches are replayed onto a fresh model, so later edits that depended on it may change.

Input parameters:

- `batch_id` (string, required)
- `path` (string, required): Path of the .xlsx to operate on (absolute, or ~/… for the user's home directory).

### `save_workbook` (~131 tokens)

Write every pending batch into the .xlsx on disk through the surgical patcher: only the parts an edit touched are rewritten, everything else stays byte-identical. This is the ONLY tool that modifies the file. When the server runs with --review-required, this returns the review link instead and the user saves from there.

Input parameters:

- `as` (string): Optional: write the result to this path instead (a copy), leaving the original untouched. Pending batches stay pending against the original.
- `path` (string, required): Path of the .xlsx to operate on (absolute, or ~/… for the user's home directory).

## Diagnostics

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

## Score history

- 2026-10-18: 63
- 2026-10-17: 63
- 2026-10-16: 63
- 2026-10-15: 63
- 2026-10-14: 63
- 2026-10-13: 36
- 2026-10-12: 36

## Common questions

### What is the GridPath MCP server?

GridPath is an MCP server listed in the public MCP registry as io.github.pixelsmasher13/gridpath. Edit real .xlsx files with your agent: live formulas, and you review every change before it saves. This page covers its npm package (gridpath).

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

GridPath scores 63 out of 100 on VerifyMCP. We found no known CVEs affecting it as of 18 October 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 GridPath MCP server expose?

GridPath exposes 32 tools: set_cell, set_range, copy_range, run_script, set_format, and 27 more. Their descriptions and schemas cost roughly 5,209 tokens of context every time the server is loaded.

### Is the GridPath MCP server still maintained?

GridPath is still listed as active in the MCP registry. We last reached this channel on 18 October 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 GridPath MCP server under?

GridPath declares the FSL-1.1-Apache-2.0 licence, which is not on the OSI-approved list. Read the terms before using it at work, and note this covers the source only, not the cost of any service it calls.

## Links

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