# Sidekick for InDesign (npm · indesign-sidekick)

Lets Claude (or any other AI assistant) work in your open Adobe InDesign documents.

- Trust score: 71/100 (medium)
- Change this week: +3
- Registry status: active
- Liveness: live
- Owner verified: no
- Last scored: 2026-11-21

## Components

- npm · `indesign-sidekick`: 71/100 (this document), [markdown](https://verifymcp.io/servers/nl-eastpole-sidekick-indesign/indesign-sidekick.md), [page](https://verifymcp.io/servers/nl-eastpole-sidekick-indesign/indesign-sidekick)

## Channel facts

- Registry: `npm`
- Package: `indesign-sidekick`
- Version: `1.0.38`
- 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-21.

- **Supply Chain Security**: 100/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.
  - No production dependencies, so there is no dependency health to assess.
- **Provenance & Transparency**: 6/100
  - Repository check failed: no source repository is declared.
  - Provenance check failed: no build-provenance attestation is published.
  - Licence could not be checked: the licence is shipped as a file inside the package, not declared as a standard (SPDX) licence identifier, so we cannot tell whether it is OSI-approved.
  - Actively maintained (last published 1 days ago).
  - Security-disclosure policy not yet verified: we couldn't inspect the source repository.
- **Schema Quality & AI Usability**: 72/100
  - 100% of prompts and resources have a non-trivial description (not blank, and not just the item's name).
  - AI-judged instruction clarity (excellent).
  - Context-footprint check failed: tool/resource definitions use about 6191 tokens (~386/item across 16 items; 15 tools + 1 resources), over budget; trim descriptions and params.
  - Usage-examples check failed: none of the tools include examples.
- **Stability & Change Management**: 77/100
  - Stability observed for 23 of 30 days with no destabilising changes; credit accrues until the full window elapses.
- **Tool Coverage**: 100/100
  - 100% of tools have a non-trivial description (not blank, and not just the tool's name).
  - 100% of tool parameters carry a description.
  - Structured output schemas are declared (20% of tools); any adoption earns full credit.
- **Tool Safety**: 75/100
  - No prompt-injection markers were found in the server instructions, tool names or descriptions we captured.
  - 0 of 2 tool(s) whose name or description implies an irreversible operation declare an MCP destructiveHint annotation; "execute" implies "execute" and declares no destructiveHint at all, which the MCP spec reads as destructive by default.
  - An AI judge read all 17 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.
  - Supports UI / widget rendering.

## Install

### How do I install the Sidekick for InDesign MCP server?

Sidekick for InDesign runs locally as an npm package, launched with npx -y indesign-sidekick start. 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 nl-eastpole-sidekick-indesign -- npx -y indesign-sidekick start
```

### Cursor

```json
{
  "mcpServers": {
    "nl-eastpole-sidekick-indesign": {
      "command": "npx",
      "args": [
        "-y",
        "indesign-sidekick",
        "start"
      ]
    }
  }
}
```

### VS Code

```json
{
  "servers": {
    "nl-eastpole-sidekick-indesign": {
      "command": "npx",
      "args": [
        "-y",
        "indesign-sidekick",
        "start"
      ]
    }
  }
}
```

### Codex

```bash
codex mcp add nl-eastpole-sidekick-indesign -- npx -y indesign-sidekick start
```

### opencode

```json
{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "nl-eastpole-sidekick-indesign": {
      "type": "local",
      "command": [
        "npx",
        "-y",
        "indesign-sidekick",
        "start"
      ],
      "enabled": true
    }
  }
}
```

### OpenClaw

```bash
openclaw mcp add nl-eastpole-sidekick-indesign --command npx --arg -y --arg indesign-sidekick --arg start
```

### Hermes

```yaml
mcp_servers:
  nl-eastpole-sidekick-indesign:
    command: "npx"
    args: ["-y", "indesign-sidekick", "start"]
```

### Netclaw

```json
{
  "McpServers": {
    "nl-eastpole-sidekick-indesign": {
      "Transport": "stdio",
      "Command": "npx",
      "Arguments": [
        "-y",
        "indesign-sidekick",
        "start"
      ]
    }
  }
}
```

### Vellum

```bash
assistant mcp add nl-eastpole-sidekick-indesign -t stdio -c npx -a -y indesign-sidekick start
```

### Other

```json
{
  "mcpServers": {
    "nl-eastpole-sidekick-indesign": {
      "command": "npx",
      "args": [
        "-y",
        "indesign-sidekick",
        "start"
      ]
    }
  }
}
```

## 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-20 (score 71, +1)

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

### 2026-11-19 (score 70, 0)

- [security regression] Tool safety: pass → unverified
- [security regression] Stability: 0.67 → unverified
- [functional regression] Capabilities: pass → unverified
- [functional regression] Tool coverage: 100 → unverified
- [functional regression] Schema quality: 100 → unverified
- [functional] Package version: 1.0.37 → 1.0.38

### 2026-11-18 (score 70, +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-15 (score 69, +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-11-13 (score 68, +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-11-11 (score 67, +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-11-09 (score 66, +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-11-07 (score 65, +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.

## MCP tools (15)

### `execute` (~1617 tokens)

Use this when the user wants to create, inspect or change anything in their open Adobe InDesign documents (Sidekick for InDesign).

Execute JavaScript code in InDesign via UXP (NOT ExtendScript). The code has access to the full InDesign DOM via require('indesign'). The 'app' object is NOT a global — you must import it: const { app } = require('indesign'). Use 'return' to return values.

Capabilities:
\- Full InDesign DOM access (documents, pages, text frames, styles, etc.)
\- Async/await supported - Promises are awaited before returning
\- File operations via UXP storage APIs (with sandbox restrictions)

Units (IMPORTANT):
\- Always specify units explicitly as strings: "12pt", "1in", "5mm", "6p" (picas)
\- Bare numbers use the document's current measurement units - this causes unpredictable results
\- Examples: fontSize = "11pt", leading = "14pt", margins = "0.5in", textFrameHeight = "200pt"
\- WRONG: fontSize = 11 (will be interpreted as 11 of whatever unit the doc uses)

Limitations:
\- File system is sandboxed - cannot freely access arbitrary paths; doc.fullName returns a Promise that may fail
\- No shell command execution (no app.system())
\- No inter-app communication (no BridgeTalk)
\- Return values must be JSON-serializable
\- Text encoding limited to UTF-8

InDesign DOM quirks:
\- Many properties are type-dependent; accessing a property that doesn't apply throws "The property is not applicable in the current state" - always check object type first or use try/catch
\- Text variables have different variableOptions depending on variableType (e.g., CUSTOM_TEXT_TYPE has contents, others don't)
\- COLLECTION INDEXING: Bracket notation does NOT work in UXP (doc.pages[0] returns undefined). Use these instead:
  \- doc.pages.item(0) - for single item by index
  \- doc.pages.firstItem() / doc.pages.lastItem() - for first/last
  \- doc.pages.everyItem().getElements() - to get a real JS array for forEach/map/filter
\- OBJECT COMPARISON: UXP DOM objects and enums don't support === or ==.…

Input parameters:

- `actions` (array): Saved actions to call from the code, by name (list_actions lists them). Each becomes an async function named in camelCase -- alt-text-audit becomes altTextAudit -- taking the action's params as one o…
- `code` (string, required): JavaScript code to execute in InDesign
- `description` (string): Brief description shown in the InDesign plugin panel. REQUIRED FORMAT: Line 1: What Sidekick is doing (present progressive tense, e.g., 'Getting the page count') Line 2: Manual alternative with key…

### `snapshot` (~453 tokens)

Capture a snapshot of a page or spread from the active InDesign document. Returns the image as base64-encoded JPEG, rendered at the resolution a vision model can actually use (you do not set dpi).

Pass an optional `region` ([x0,y0,x1,y1], normalized 0..1 over the page) to zoom into part of a page at full detail — use this when a whole-page snapshot is too coarse to read an image or fine type. To capture one specific object by id, use `snapshot_object` instead.

Pass `preview: true` for a cheap low-resolution thumbnail — use it for quick 'did the layout roughly change / is the block where I dropped it' checks where you don't need to read detail. Omit it to read detail.

IMPORTANT: Use this tool only when YOU need to verify your work or when the user explicitly requests a snapshot. The user is viewing changes directly in InDesign - they do not need snapshots in the chat unless they ask for them.

Input parameters:

- `description` (string): Brief description shown in the InDesign plugin panel. REQUIRED FORMAT: Line 1: What Sidekick is doing (present progressive tense, e.g., 'Capturing page 1 for review') Line 2: Manual alternative (e.…
- `index` (integer, required): Zero-based index of the page or spread to capture
- `preview` (boolean): Set true for a low-resolution thumbnail (~0.3 MP) for quick rough-glance checks where you don't need to read detail. Ignored when `region` is set (region always captures at full detail).
- `region` (array): Optional zoom-box [x0,y0,x1,y1] in normalized 0..1 page coordinates (top-left origin). Omit to capture the whole page. Only valid with target 'page'. Example: [0.5,0,1,0.4] = top-right area.
- `target` (string, required): Whether to capture a single page or an entire spread

### `snapshot_object` (~375 tokens)

Capture a single page item (frame, image, group, …) from the active InDesign document as a base64 JPEG, at the resolution a vision model can use (you do not set dpi).

By default it renders the object **as it appears on the page** — including anything overlapping it, and with any parts hidden by content in front left hidden (so it reflects what's actually visible). Pass `isolate: true` to render **only the object itself**: this strips overlapping items, but also reveals any parts of the object that are covered on the page — so it shows the object's full content rather than just the visible portion.

For alt text: if nothing overlaps the image, `isolate: true` is the cleanest input. If something overlaps/occludes it, prefer the default — alt text should describe what's visible, not content hidden in the layout. The returned note lists overlapping items so you can decide.

Get `pageItemId` from `get_layout({ includeItems: true })`.

Input parameters:

- `description` (string): Brief description shown in the InDesign plugin panel. REQUIRED FORMAT: Line 1: What Sidekick is doing (present progressive tense, e.g., 'Capturing image frame for review') Line 2: Manual alternativ…
- `isolate` (boolean): Render only the object itself, stripping overlapping page content (default false = render it as composed on the page). Note: isolating reveals parts of the object that are covered by other items on t…
- `pageItemId` (integer, required): The id of the page item to capture (from get_layout with includeItems)

### `show_snapshot` (~443 tokens)

Capture a snapshot and PRESENT it inline in the chat for the user to see. Returns the same base64 JPEG as `snapshot`, but in MCP Apps hosts (e.g. Claude Desktop) it also renders as a full inline preview with fit-to-width and zoom — no need to expand the tool accordion.

Use this ONLY when the user asked to see a result, or when showing a finished result is genuinely useful to them. For your own iterative verification ('did the layout change', 'is the block where I dropped it'), use `snapshot` / `snapshot_object` instead — those stay collapsed and won't clutter the chat.

Targets mirror the other snapshot tools: a page/spread (with optional `region` zoom-box), or a single object by `pageItemId`. Pass `pageItemId` to present one object; otherwise pass `target` + `index`.

Input parameters:

- `description` (string): Brief description shown in the InDesign plugin panel. REQUIRED FORMAT: Line 1: What Sidekick is doing (present progressive tense, e.g., 'Showing page 1') Line 2: Manual alternative (e.g., 'You can…
- `index` (integer): Zero-based index of the page or spread to capture (required with `target`).
- `isolate` (boolean): With `pageItemId`: render only the object itself, stripping overlapping content.
- `pageItemId` (integer): Present a single page item by id (from get_layout with includeItems). When set, `target`/`index`/`region` are ignored.
- `preview` (boolean): Set true for a low-resolution preview. Ignored with `region` or `pageItemId`.
- `region` (array): Optional zoom-box [x0,y0,x1,y1] in normalized 0..1 page coordinates (top-left origin). Only valid with target 'page'.
- `target` (string): Capture a single page or an entire spread. Omit when presenting an object.

### `snapshot_zoom` (~186 tokens)

Internal to the show_snapshot viewer: renders a sharper close-up of the part of a snapshot the user zoomed into. Not for assistants: use `snapshot` with `region` for a close-up.

Input parameters:

- `documentId` (integer, required): Document.id of the snapshot's document.
- `documentName` (string): The document's name, checked with the id.
- `maxLongEdgePx` (number, required): Long edge of the close-up in pixels.
- `maxPixels` (number, required): Pixel count of the close-up.
- `pageId` (integer): Page.id of the snapshot's page.
- `pageIndex` (integer, required): Zero-based page index.
- `region` (array, required): [x0,y0,x1,y1] in normalized 0..1 page coordinates (top-left origin).
- `snapshotKey` (string, required): The key of the snapshot being zoomed into.

### `get_layout` (~209 tokens)

Get comprehensive layout information for the active InDesign document. Returns page dimensions, margins, and pre-calculated content area coordinates for accurate text frame placement.

Use this BEFORE placing text frames to get correct coordinates. The contentArea bounds can be used directly for geometricBounds.

Returns:
\- facingPages: whether document uses facing pages
\- measurementUnits: horizontal and vertical units (use values as-is, no unit suffix needed)
\- pages: array with bounds, margins, and contentArea for each page (max 20)
\- contentArea accounts for page side (recto/verso) automatically
\- items (when includeItems is true): each page's items with id, type, bounds, and hasGraphic — pass an id to snapshot_object to capture that item

geometricBounds format is [top, left, bottom, right].

Input parameters:

- `includeItems` (boolean): Include each page's items (id, type, bounds, hasGraphic). Use the ids with snapshot_object. Default false.

Output parameters:

- `facingPages` (boolean): Whether document uses facing pages (spreads with recto/verso)
- `geometricBoundsFormat` (string): Format reminder: geometricBounds are [top, left, bottom, right]
- `hasActiveDocument` (boolean): False if no document is open in InDesign
- `measurementUnits` (object): Document measurement units - use returned values as-is, no unit suffix needed
- `pageCount` (number): Total number of pages in the document
- `pages` (array): Layout info for each page (max 20 returned)
- `pagesIncluded` (number): Number of pages included in response (max 20)

### `get_font_metrics` (~383 tokens)

Get comprehensive font metrics for a specified font. Returns all available metrics including x-height, cap-height, ascender, descender, line gap, underline/strikeout positions, subscript/superscript sizes, and bounding box.

The tool searches system fonts (including .ttc collections such as Helvetica), the fonts bundled with InDesign (e.g. Minion Pro, Myriad Pro), and Adobe Fonts installed via Creative Cloud.

IMPORTANT: Adobe Fonts limitation - Some Adobe Fonts are loaded on-demand by Adobe apps and may not be locally cached in the CoreSync folder. If a font is available in InDesign but not found by this tool, the user should:
1\. Open Adobe Creative Cloud → Fonts
2\. Find the font and click the Download icon to install it locally
3\. Use refresh=true after installation to rebuild the font cache

Parameters:
\- fontIdentifier: Font name to search for (family name, PostScript name, or full name)
\- style: Optional style specifier to disambiguate (e.g., "Bold", "Italic")
\- refresh: Force rebuild of font cache (use after installing new fonts)

All metric values are in font units. Divide by unitsPerEm and multiply by point size to get actual measurements.

Example: For a 12pt font with unitsPerEm=1000 and xHeight=500:
  Actual x-height = (500 / 1000) * 12 = 6pt

Input parameters:

- `fontIdentifier` (string, required): Font identifier - family name (e.g., 'Helvetica'), PostScript name (e.g., 'Helvetica-Bold'), or full name
- `refresh` (boolean): Force refresh of font cache (rebuilds index from disk)
- `style` (string): Optional style (e.g., 'Bold', 'Italic') to disambiguate multiple matches

Output parameters:

- `ascender` (number): Distance from baseline to top of tallest glyph (in font units)
- `bbox` (object): Bounding box enclosing all glyphs in the font (in font units)
- `capHeight` (number|null): Height of capital letters (in font units)
- `capHeightSource` (string): Whether capHeight came from font metadata or was measured from glyphs
- `descender` (number): Distance from baseline to bottom of lowest glyph (negative, in font units)
- `faceIndex` (integer): Face index inside a font collection (.ttc); absent for single-font files
- `filePath` (string): Absolute path to the font file on disk
- `fontFamily` (string): Font family name (e.g., 'Helvetica', 'Times New Roman')
- `fontSubfamily` (string): Style variant (e.g., 'Regular', 'Bold', 'Italic')
- `fullName` (string): Complete font name including family and style
- `isMonospace` (boolean): True if all glyphs have equal width (e.g., Courier, Consolas)
- `lineGap` (number): Recommended additional line spacing (in font units)
- `postScriptName` (string): PostScript name for precise font identification
- `strikeoutPosition` (number|null): Vertical position for strikethrough
- `strikeoutSize` (number|null): Recommended strikethrough stroke thickness
- `subscriptXOffset` (number|null): Horizontal offset for subscript positioning
- `subscriptXSize` (number|null): Recommended width scale for subscripts
- `subscriptYOffset` (number|null): Vertical offset for subscript positioning
- `subscriptYSize` (number|null): Recommended height scale for subscripts
- `superscriptXOffset` (number|null): Horizontal offset for superscript positioning
- `superscriptXSize` (number|null): Recommended width scale for superscripts
- `superscriptYOffset` (number|null): Vertical offset for superscript positioning
- `superscriptYSize` (number|null): Recommended height scale for superscripts
- `underlinePosition` (number): Vertical position for underline (negative = below baseline)
- `underlineThickness` (number): Recommended underline stroke thickness
- `unitsPerEm` (number): Font units per em. Divide other metrics by this and multiply by point size to get actual measurements
- `version` (string): Font version string
- `xHeight` (number|null): Height of lowercase 'x' (in font units). Key for optical alignment
- `xHeightSource` (string): Whether xHeight came from font metadata or was measured from glyphs

### `list_actions` (~168 tokens)

Use this to see the user's saved Sidekick actions and the built-in ones: what each does and the params it takes. Call it before run_action when you need an action's params, when the user asks what actions there are, or when a task looks like one a saved action might already do. It reads the actions folder fresh, so it includes actions saved since this conversation began, from any assistant. set_configuration sets the user's own actions folder (actionsDir) and shared folders (sharedActionsDirs). If set_configuration has no such settings, the user's Sidekick is older than actions: ask the user to update Sidekick (https://sidekick.eastpole.nl/install) and the Sidekick UXP plugin in InDesign from Adobe Exchange, which also brings the Sidekick Actions panel.

### `run_action` (~344 tokens)

Use this to run a saved Sidekick action by name in the user's open InDesign document. An action is JavaScript the user (or Sidekick) saved earlier, with a header that names it, describes it and types its params.

Pass the params as one object; leave a param out to use its default. The answer is the action's report as text (summary, rows, what a changeCount means for this run's mode), any problems the report has, its log, and the report as JSON with at most 200 rows. When an action fails, the answer carries the error, the stack (lines refer to the action's file) and the numbered source, so a fix needs no second call. Fix the action, run it again, and ask the user before saving the fix. An action with an apply param is not finished until both modes have run; ask the user before a trial run with the param on, and undo it afterwards with Edit › Undo when the answer shows an Undo line; without one, run the trial on a copy of the document instead, as an older Sidekick plugin does not make the run one undo step.

Actions as of the last scan: alt-text-audit (built-in), dutch-typography (built-in), overset-hunt (built-in), rich-black-sweep (built-in). list_actions reads the folders fresh and shows the params; call it when a name you expect is missing.

Input parameters:

- `name` (string, required): The action's name, as this description or list_actions gives it
- `params` (object): The action's params by name; leave one out to use its default

### `get_action` (~64 tokens)

Use this to read the source of a saved Sidekick action, for example before changing it at the user's request. Returns the file as it is, header included. list_actions lists the actions.

Input parameters:

- `name` (string, required): The action's name, as list_actions gives it

### `save_action` (~1015 tokens)

Use this to save code as a Sidekick action the user can run again by name, from this or any other assistant, and from the Sidekick Actions panel in InDesign when the user's Sidekick plugin has it. Save only when the user asks, or agrees after you offered; never on your own initiative. When saving a fix to an action that failed, say what changed.

The source is one JavaScript file: a header, then an async function main(params, sidekick) and any helpers it needs. Saving under an existing name replaces that action.

/* @sidekick
{
  "name": "alt-text-audit",
  "description": "Lists every placed image without alt text",
  "params": {
    "scope": { "type": "string", "enum": ["document", "selection"], "default": "document",
               "description": "Which images to check" }
  }
}
\*/
function hasAltText(frame) {
  const options = frame.objectExportOptions;
  const source = String(options.altTextSourceType);
  if (source === "SOURCE_CUSTOM") return options.customAltText.trim() !== "";
  return source !== "SOURCE_XML_STRUCTURE"; // InDesign's default; for an untagged document it means none
}

async function main({ scope }, sidekick) {
  const { app } = require("indesign");
  const doc = sidekick.doc();
  const graphics = scope === "selection" ? app.selection : doc.allGraphics;
  const items = [];
  for (const graphic of graphics) {
    const frame = graphic.parent;
    if (hasAltText(frame)) continue;
    const image = graphic.itemLink ? graphic.itemLink.name : "embedded image";
    items.push(sidekick.item(frame, image, "No alt text"));
  }
  return {
    summary: items.length === 0 ? "All images have alt text" : items.length + " images without alt text",
    items,
  };
}

Header rules: name is kebab-case (a lower-case letter, then 1-63 lower-case letters, digits or hyphens); description is one line of at most 200 characters, best about 100: what the action does, the most important first, without repeating what a param's description says (the Sidekick Actions panel…

Input parameters:

- `source` (string, required): The whole action: the @sidekick header, then main and its helpers

### `delete_action` (~101 tokens)

Use this to delete one of the user's saved Sidekick actions. Deleting cannot be undone from Sidekick, so always ask the user to confirm first, naming the action. Built-in actions and actions in a shared folder cannot be deleted, nor can a locked (read-only) file; deleting a saved action that replaced a built-in or a shared one brings that one back.

Input parameters:

- `name` (string, required): The action's name, as list_actions gives it

### `get_configuration` (~15 tokens)

Get current Sidekick configuration settings.

### `set_configuration` (~255 tokens)

Update Sidekick configuration settings.

Input parameters:

- `actionsDir` (string): The folder the user's own Sidekick actions are saved in, or "default" to go back to Documents/Sidekick Actions. Sidekick's action tools use the change from their next call, and pass it on to the Side…
- `observers` (boolean): Allow local processes (a demo recorder, a session transcript) to watch commands sent to InDesign. Off by default.
- `pinned` (boolean): Stay on the installed version: nothing is downloaded. Takes effect when each Sidekick server next starts. The next start runs the version installed with Sidekick, which can be older than the one runn…
- `sharedActionsDirs` (array): Folders of actions to read in addition to the user's own, for example a studio's shared folder, in order of precedence. Sidekick never writes there; an action of the same name in the user's own folde…
- `telemetry` (boolean): Enable/disable anonymous error telemetry

### `get_health` (~55 tokens)

Use this when the user asks for "sidekick health", whether Sidekick or InDesign is connected, or why InDesign commands fail. Returns Sidekick's health and status: server version/role and the InDesign plugin connection.

Output parameters:

- `connections` (object): Live connection state for the current server role
- `lastError`: Most recent command error, or null if none this session
- `lastSuccessfulCommandSecondsAgo` (number|null): Seconds since the last command succeeded, or null if none yet this session
- `plugin`: InDesign UXP plugin connection status
- `probe` (object): Live end-to-end probe: runs an inert command through the real path (this server -> primary -> plugin) so health reflects whether commands actually work right now
- `server` (object): MCP server information
- `settings` (object): Where this server's settings come from (#566)

## Diagnostics

Captured diagnostic sections: Provenance, Dependencies. The full working is on the page: https://verifymcp.io/servers/nl-eastpole-sidekick-indesign/indesign-sidekick#diagnostics

## Score history

- 2026-11-21: 71
- 2026-11-20: 71
- 2026-11-19: 70
- 2026-11-18: 70
- 2026-11-17: 69
- 2026-11-16: 69
- 2026-11-15: 69
- 2026-11-14: 68
- 2026-11-13: 68
- 2026-11-12: 67
- 2026-11-11: 67
- 2026-11-10: 66
- 2026-11-09: 66
- 2026-11-08: 65
- 2026-11-07: 65
- 2026-11-06: 64
- 2026-11-05: 64
- 2026-11-04: 48
- 2026-11-03: 63
- 2026-11-02: 62
- 2026-11-01: 62
- 2026-10-31: 62
- 2026-10-30: 61
- 2026-10-29: 61

## Common questions

### What is the Sidekick for InDesign MCP server?

Sidekick for InDesign is an MCP server listed in the public MCP registry as nl.eastpole.sidekick/indesign. Lets Claude (or any other AI assistant) work in your open Adobe InDesign documents. This page covers its npm package (indesign-sidekick).

### Is the Sidekick for InDesign MCP server safe to use?

Sidekick for InDesign scores 71 out of 100 on VerifyMCP. We found no known CVEs affecting it as of 21 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 Sidekick for InDesign MCP server expose?

Sidekick for InDesign exposes 15 tools: execute, snapshot, snapshot_object, show_snapshot, snapshot_zoom, and 10 more. Their descriptions and schemas cost roughly 5,683 tokens of context every time the server is loaded.

### Is the Sidekick for InDesign MCP server still maintained?

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

### What did VerifyMCP test on the Sidekick for InDesign MCP server?

VerifyMCP ran 15 checks on Sidekick for InDesign, covering Malware scan, Known CVEs, Install scripts, Dependency health and 11 more. 2 items could not be completed, a gap on our side rather than a finding about Sidekick for InDesign: License and Security disclosure. Endpoint Security and Transport & Reachability do not apply to an npm package, so they were not tested. The score does not measure everything, and the scoring documentation lists what it leaves out.

## Links

- npm package: https://www.npmjs.com/package/indesign-sidekick
- Socket report: https://socket.dev/npm/package/indesign-sidekick
- Website: https://sidekick.eastpole.nl/
- Changelog RSS feed: https://verifymcp.io/servers/nl-eastpole-sidekick-indesign/indesign-sidekick.xml
- Changelog JSON feed: https://verifymcp.io/servers/nl-eastpole-sidekick-indesign/indesign-sidekick/changelog.json
- Trust report (JSON): https://verifymcp.io/servers/nl-eastpole-sidekick-indesign/indesign-sidekick.json
- HTML version of this page: https://verifymcp.io/servers/nl-eastpole-sidekick-indesign/indesign-sidekick
