Skip to main content
Glama
Adobe XD MCP

Adobe XD MCP

by srayan-uxd

Adobe XD MCP

CI License: MIT

Let your AI assistant read Adobe XD (.xd) files: screens, layers, text, colors, fonts, prototype links, images, and more.

It's a small MCP server. It runs on your own computer, only reads your files, and can only open the folders you allow. The server itself never connects to the internet.

Good to know: whatever your AI reads from a file (for example a screen's text) becomes part of your chat with that AI, just like anything you type. Don't point it at designs you can't share with your AI provider.

Try asking: "List the screens in my XD file", "What colors and fonts does this design use?", "Build the Home screen as React + Tailwind."

Mac: Jump to the step-by-step guide

Windows: Jump to the step-by-step guide


What can I do with it? (Examples)

  • Design to code: "Build the Home screen as React + Tailwind, using the file's real colors and fonts."

  • XD to Figma: "Recreate the Login screen in Figma." (details)

  • Design system in minutes: "Give me this file's colors, type scale and shadows as Tailwind config / CSS variables."

  • Auto layout, by default: "Recreate the Login screen in Figma." The result is one auto-layout frame, not a pile of grouped vectors.

  • Look at it: "Render the Home screen so I can compare it with what you built."

  • Design QA: "Audit this file for contrast, tiny text and small tap targets."

  • Copy and translation: "Export all the text as CSV." Find placeholder text, or every use of a word.

  • Docs: "Draw the prototype flow as a diagram and write a screen inventory."

  • Search: "Which screens use the color #0033a0?"

  • Many files: "Summarize every XD file in this folder."

Some MCP apps also show three ready-made prompts: xd-to-figma, xd-to-code and xd-design-review.


Related MCP server: Adobe XD MCP Server

All the tools

You don't call these yourself. Your AI picks the right one. This is what's available:

Tool

What it does

xd_list_artboards

Lists every screen (artboard) with its name and id

xd_get_artboard

Layer tree of one screen: position, size, fills, strokes, radius, text, fonts

xd_extract_text

All text from one screen, or the whole file

xd_get_design_tokens

Colors and fonts used across the file, most-used first

xd_get_design_system

The design system actually used in the file: colors, type styles and size scale, radii, stroke widths, shadows. As JSON, CSS variables, a Tailwind theme, or Figma variables (collections, text styles named by role, effect styles)

xd_audit_design

Design QA: text contrast (WCAG), tiny text, small tap targets, placeholder text, near-duplicate colors, too many fonts, default layer names

xd_find_layers

Search the whole file by text, layer name, type or color

xd_export_copy

All the text as JSON or CSV (a copy deck for translation or review)

xd_get_flow

Prototype flow map: taps, hovers, transitions, destinations, plus a Mermaid diagram

xd_get_interactions

The raw prototype interactions stored in the file

xd_export_artboard

Full-fidelity export of a screen (or one layer) as clean JSON: frames, shapes, vector paths, text, fills, gradients, images, strokes, shadows, transforms, constraints, stacks, interactions. Linked components are resolved, big screens are paged, nothing is silently cut. Built for rebuilding designs in other tools (XD to Figma)

xd_render_artboard

See the screen: renders an artboard (or one layer) to a PNG using a local Chrome or Edge. Handy to check a rebuild against the original

xd_infer_layout

Auto-layout proposal from the exact export: cards, rows and columns, spacing, padding, buttons, illustrations and icons kept as single units (including loose pieces that were never grouped in XD), and a drift report showing how far the result moves things

xd_export_svg

Exports any layers (a group, or the pieces of a drawing) as ONE self-contained SVG, so an illustration or icon can be imported into Figma as a single vector

xd_font_report

Fonts used, whether they are installed on this computer, substitutions for missing weights, and a licence note

xd_list_components / xd_export_component

List reusable components (with usage counts and descriptions) and export one, including its states (hover etc.) as variants

xd_ping

Health check: version, allowed folders, browser found, and a built-in self-test

xd_get_shared_assets

Saved color swatches, library colors and text styles

xd_get_preview

The preview image saved inside the file

xd_extract_assets

Saves embedded images to a folder (inside your allowed folders)

xd_project_overview

Summarizes every .xd file in a folder

xd_list_entries / xd_read_raw

Advanced: look inside the raw .xd archive


XD to Figma (and other design tools)

Use this server together with the official Figma MCP server (set that up from Figma's help center) in an AI tool that supports several MCP servers (Claude, Cursor, Codex, ...). This server reads the XD file, the Figma server writes into Figma, and the AI connects the two.

The default result is ONE auto-layout Figma frame that looks as close to the XD original as possible: real, editable text, repeated items as components, illustrations and photos kept as they are, and semantic layer names. Small spacing differences (a few pixels) are fine; looks, hierarchy, colours, fonts and shadows should match. You don't have to ask for auto layout, and you don't get a second "exact copy" version (the exact export is only a temporary source for illustrations). If you really want a pixel-exact, non-auto-layout copy, say so.

The recommended workflow (you can paste this to your AI):

  1. xd_list_artboards, then pick one screen. A 60-screen file is a lot of work, so go screen by screen.

  2. xd_font_report: warn about fonts that aren't installed before building anything.

  3. xd_get_design_system with format figma-variables: create variables, text styles and effect styles first.

  4. xd_list_components: create components for repeated items, then use instances.

  5. xd_render_artboard: look at the original so you know what you are aiming for.

  6. xd_export_artboard (with assetsDir for images): the exact layer data, used for text styles and as the source for illustrations and photos.

  7. xd_infer_layout: the auto-layout structure (cards, rows, columns, spacing, padding, sizing). Build the page from it. Illustrations and icons arrive as single fixed leaves: import each one with xd_export_svg (pass the leaf's ref, or its parts for a merged drawing) and place it inline or absolutely inside its card. Photos are cloned from the exact export through the ref.

  8. xd_render_artboard again and compare it with your Figma result. Fix anything that looks different, name layers semantically (suggestedName), and remove temporary helper layers.

Example prompts:

  • "Recreate the 'Login' screen from C:/Designs/app.xd in my Figma file. Save images to C:/Designs/_assets."

  • "Compare it with the original and fix what looks different. List anything you couldn't reproduce."

What's handled: linked components (resolved to their real content), masks, text (top-left box, baseline, line breaks, alignment, auto-resize, partly underlined or mixed-style text), the full transform matrix (rotation and flips pivot about the layer's top-left), vector paths in local coordinates, solid, gradient and image fills, strokes, shadows, opacity, constraints, XD stacks, scroll settings, component states as variants, and prototype interactions on the layer they belong to.

Big screens are paged. If the JSON is large, the result comes in pages (page, pageCount, hasMore). Each page holds whole top-level layers, and nothing is ever cut silently (truncated is false unless you ask for a smaller depth). To go deeper into one big layer, pass its nodeId.

About xd_infer_layout: it is a heuristic proposal, not magic. It groups layers into cards by containment, finds rows and columns, measures spacing and padding (rounded to a 4px grid), keeps drawings and photos as fixed layers, and marks overlapping decorations as absolute. Where auto layout would move something by more than maxDrift pixels (default 10), that layer keeps its exact position instead. Lower maxDrift (for example to 5) for stricter positions with less auto layout; raise it for more auto layout with more drift. The quality block tells you what you got.

How illustrations and icons are grouped: a group with more than 20 vector parts (and no text) is kept as ONE illustration, and a small group (up to 64 px, no text) as ONE icon. Groups with photos, masks or rotations stay as single fixed units, and any text inside them is listed on the leaf (textLayers), so nothing is lost. Many XD files also contain drawings whose parts were never grouped: overlapping or touching free-form paths are merged into one illustration, listed in parts. Clusters made only of circles, rectangles and lines (a stepper, a progress bar) are left alone so they stay editable. The thresholds are adjustable (illustrationMinParts, iconMaxSize, mergeLoose, looseMinParts); the grouping block in the result says what was merged. This is a heuristic: check the result with xd_render_artboard.

What doesn't carry over: stack padding, "live" repeat grids (they come as their repeated layers plus the grid settings), text in rotated layers, and exact widths of single-line text (XD doesn't store them; they are estimated and flagged widthApprox). Treat the result as a strong head start and check it with xd_render_artboard.

Fonts: xd_font_report only reads font names. This tool never creates, edits or uploads fonts. If a weight is missing, use the substitution table it gives you (for example Medium to Regular) instead of generating one, and check each font's licence before uploading it to another tool.


Safety

  • Local only. The server makes no network calls and uploads nothing. (Your AI app still receives whatever the server returns, see the note at the top.)

  • Folder allow-list. Files outside XD_MCP_ROOTS are refused, including sneaky paths (.., shortcuts/symlinks). If you don't set it, only the folder the app starts the server in is allowed, which can be a surprising place, so always set it.

  • Only .xd files can be opened, and network paths (\\server\share) are blocked.

  • Booby-trapped files: hard limits on file, entry and total size stop "zip bombs" from using up your memory.

  • Rendering stays on your computer. xd_render_artboard starts your own Chrome or Edge in headless mode with networking switched off, on a temporary file that is deleted afterwards. It needs a browser installed (set XD_MCP_CHROME to its path if it isn't found).

  • Only trusted files. Text inside a design is passed to your AI, and a malicious file could try to give the AI instructions. Open files from people you trust.

Details and how to report a problem privately: SECURITY.md.


Known limits

  • XD's file format is closed and undocumented. This is built from files seen in practice, so unusual files may show gaps. Open an issue (without sharing private designs).

  • The audit's contrast check estimates the background from the shapes behind the text (and skips text over pictures). Treat results as leads, not verdicts. Positions of rotated layers are approximate.

  • Components are exported with their ids, usage counts and states, and repeat grids as their layers plus grid settings. Neither is rebuilt as a "live" object.

  • xd_render_artboard is an approximation of how XD draws: "inside" and "outside" strokes, blend modes and fonts that aren't installed can look slightly different.

  • Only drop shadows are mapped for effects; other effects are passed through raw. Gradients are passed through with colors converted to hex (not yet checked against many real files).

  • Read-only. It can't edit or create .xd files.


Quick start (3 steps)

You need: Node.js 18 or newer (the "LTS" download) and Git. Check with node -v and git --version.

Step 1. Pick the folder that holds your .xd files. For example C:/Designs (Windows) or /Users/you/Designs (Mac/Linux). The server can only read inside this folder. That's a safety feature, so always set it.

Step 2. Add the server to your AI tool. Find your tool in Setup for each tool, copy the setting, and replace the folder with yours.

Step 3. Restart the tool and ask. For example: "Use the adobe-xd tool to list the artboards in C:/Designs/app.xd."


Mac: step-by-step

This guide is for designers who have never used a terminal. It takes about 15 minutes and uses the Claude desktop app. Other AI tools work too (see Setup for each tool).

Honest note: the server is written to run on macOS, Windows and Linux, but so far it has only been tested on Windows. If something doesn't work on your Mac, please open an issue (without attaching private designs). You'd be helping a lot.

What you need: a Mac, a Claude account, a Figma account (only if you want to rebuild screens in Figma), and your .xd files.

1. Install Node.js

Go to nodejs.org, download the LTS version for macOS, and double-click the installer.

2. Install Git

Open Terminal (press Cmd + Space, type Terminal, press Return). Type this and press Return:

git --version

If a pop-up offers to install the developer tools, click Install and wait for it to finish.

3. Put your XD files in one folder

For example a folder called XD inside Documents. The server can only read the folder you give it.

Get the folder's full path: in Finder, right-click the folder, hold the Option key, and choose Copy "XD" as Pathname. It looks like /Users/yourname/Documents/XD.

4. Install the Claude desktop app

Download it from claude.ai and sign in.

5. Connect the server to Claude

In Claude, open Settings → Developer → Edit Config. A file called claude_desktop_config.json opens. Paste this into it (if the file already has content, add the "adobe-xd" part inside the existing mcpServers), and replace the folder path with yours:

{
  "mcpServers": {
    "adobe-xd": {
      "command": "npx",
      "args": ["-y", "github:srayan-uxd/adobe-xd-mcp#v0.4.0"],
      "env": { "XD_MCP_ROOTS": "/Users/yourname/Documents/XD" }
    }
  }
}

#v0.4.0 pins this tested version. To update later, change it to the newest version on the Releases page.

Use the full path. A ~ shortcut does not work here. Then quit Claude completely (Cmd + Q) and open it again. The first start can take a minute while the server downloads.

If Claude can't find npx (common if you installed Node with Homebrew): in Terminal run which npx, then put the full path it prints (for example /opt/homebrew/bin/npx or /usr/local/bin/npx) in place of "npx" above.

If macOS asks whether Claude may access your Documents (or Desktop, Downloads) folder, click Allow.

6. Connect Figma (only for XD to Figma)

In Claude, open Settings → Connectors, add Figma's official connector, and sign in to Figma. The menu names change between Claude versions, so look for "Connectors" or "Integrations".

7. Check that it works

Ask Claude:

Use the adobe-xd tool to list the screens in /Users/yourname/Documents/XD/myfile.xd.

You can also ask: "Run xd_ping." It reports the version, which folders the tool may read, and whether it can render previews.

8. Convert a screen to Figma

Ask Claude:

Recreate the "Login" screen from that XD file in my Figma file. Keep the fonts, colours and images the same.

It builds the screen with auto layout by default, so you don't need to ask for it. Do one screen at a time. If something looks different from the original, ask: "Compare it with the original and fix what looks different."

Good to know on a Mac

  • Screen previews (xd_render_artboard) need Google Chrome, Microsoft Edge or Chromium in your Applications folder. They are found automatically.

  • Fonts: if the fonts used in your XD file aren't installed, the text will change. Ask: "Run xd_font_report" to see which are missing.

  • Privacy: what the AI reads from your files is shared with your AI provider, like anything you type to it.


Windows: step-by-step

This guide is for designers who have never used a terminal. It takes about 15 minutes and uses the Claude desktop app. Other AI tools work too (see Setup for each tool). Windows is the system this tool was built and tested on.

What you need: a Windows 10 or 11 PC, a Claude account, a Figma account (only if you want to rebuild screens in Figma), and your .xd files.

1. Install Node.js

Go to nodejs.org, download the LTS version for Windows, run the installer, and click Next through the steps (the default choices are fine).

2. Install Git

Go to git-scm.com, download Git for Windows, run the installer, and click Next through the steps (the default choices are fine).

3. Put your XD files in one folder

For example a folder called XD inside Documents. The server can only read the folder you give it.

Get the folder's full path: open the folder in File Explorer, click the address bar, and copy what it shows. It looks like C:/Users/yourname/Documents/XD (in the settings file below, use forward slashes /, or double every backslash).

4. Install the Claude desktop app

Download it from claude.ai, run the installer, and sign in.

5. Connect the server to Claude

In Claude, open Settings → Developer → Edit Config. A file called claude_desktop_config.json opens. Paste this into it (if the file already has content, add the "adobe-xd" part inside the existing mcpServers), and replace the folder path with yours:

{
  "mcpServers": {
    "adobe-xd": {
      "command": "npx",
      "args": ["-y", "github:srayan-uxd/adobe-xd-mcp#v0.4.0"],
      "env": { "XD_MCP_ROOTS": "C:/Users/yourname/Documents/XD" }
    }
  }
}

#v0.4.0 pins this tested version. To update later, change it to the newest version on the Releases page.

Then quit Claude completely and open it again. Closing the window can leave it running in the background, so right-click the Claude icon near the clock (bottom-right of the taskbar) and choose Quit. The first start can take a minute while the server downloads.

If Claude says it can't find npx: use this version of the settings instead:

{
  "mcpServers": {
    "adobe-xd": {
      "command": "cmd",
      "args": ["/c", "npx", "-y", "github:srayan-uxd/adobe-xd-mcp#v0.4.0"],
      "env": { "XD_MCP_ROOTS": "C:/Users/yourname/Documents/XD" }
    }
  }
}

6. Connect Figma (only for XD to Figma)

In Claude, open Settings → Connectors, add Figma's official connector, and sign in to Figma. The menu names change between Claude versions, so look for "Connectors" or "Integrations".

7. Check that it works

Ask Claude:

Use the adobe-xd tool to list the screens in C:/Users/yourname/Documents/XD/myfile.xd.

You can also ask: "Run xd_ping." It reports the version, which folders the tool may read, and whether it can render previews.

8. Convert a screen to Figma

Ask Claude:

Recreate the "Login" screen from that XD file in my Figma file. Keep the fonts, colours and images the same.

It builds the screen with auto layout by default, so you don't need to ask for it. Do one screen at a time. If something looks different from the original, ask: "Compare it with the original and fix what looks different."

Good to know on Windows

  • Screen previews (xd_render_artboard) need Microsoft Edge or Google Chrome. Edge comes with Windows, so this usually works without doing anything.

  • Fonts: if the fonts used in your XD file aren't installed, the text will change. Ask: "Run xd_font_report" to see which are missing.

  • Privacy: what the AI reads from your files is shared with your AI provider, like anything you type to it.


Setup for each tool

The server command is always the same:

npx -y github:srayan-uxd/adobe-xd-mcp#v0.4.0

The #v0.4.0 part pins this exact, tested version, so nothing changes under you. To update later, look at the Releases page and change the version number (for example #v0.4.0 to a newer one), then restart your AI tool.

The one setting you change is XD_MCP_ROOTS, your designs folder. To allow several folders, separate them with ; on Windows or : on Mac/Linux. In JSON files use forward slashes (C:/Designs), or double every backslash (C:\\Designs).

Claude Desktop

  1. Open Settings → Developer → Edit Config. This opens claude_desktop_config.json.

  2. Add this, save, and restart Claude:

{
  "mcpServers": {
    "adobe-xd": {
      "command": "npx",
      "args": ["-y", "github:srayan-uxd/adobe-xd-mcp#v0.4.0"],
      "env": { "XD_MCP_ROOTS": "C:/Designs" }
    }
  }
}

Windows tip: if it says npx isn't found, use "command": "cmd" and "args": ["/c", "npx", "-y", "github:srayan-uxd/adobe-xd-mcp#v0.4.0"].

Claude Code

One command:

claude mcp add adobe-xd -e XD_MCP_ROOTS=/path/to/Designs -- npx -y github:srayan-uxd/adobe-xd-mcp#v0.4.0

Cursor

  1. Open Settings → MCP → Add new MCP server (or edit ~/.cursor/mcp.json).

  2. Paste the same JSON as Claude Desktop above.

VS Code (GitHub Copilot)

Create .vscode/mcp.json in your project:

{
  "servers": {
    "adobe-xd": {
      "command": "npx",
      "args": ["-y", "github:srayan-uxd/adobe-xd-mcp#v0.4.0"],
      "env": { "XD_MCP_ROOTS": "C:/Designs" }
    }
  }
}

Windsurf

Open Settings → Cascade → MCP Servers → View raw config (~/.codeium/windsurf/mcp_config.json) and paste the Claude Desktop JSON.

OpenAI Codex (CLI)

Edit ~/.codex/config.toml:

[mcp_servers.adobe-xd]
command = "npx"
args = ["-y", "github:srayan-uxd/adobe-xd-mcp#v0.4.0"]
env = { XD_MCP_ROOTS = "C:/Designs" }

Gemini CLI

Edit ~/.gemini/settings.json and add the same mcpServers block as Claude Desktop.

Cline, Continue, Zed, and other apps

Almost every MCP app uses the same recipe: command npx, args -y github:srayan-uxd/adobe-xd-mcp#v0.4.0, and the environment variable XD_MCP_ROOTS. Look for "MCP servers" in the app's settings.

ChatGPT, Replit, Lovable, and other web/cloud tools

These run in the cloud, so they can't reach files on your computer, and this server is a local one. Your options:

  • Use one of the local tools above to read the XD file, then paste the result (text, colors, layout) into the cloud tool.

  • Check whether the tool supports custom local (stdio) MCP servers. If it does, use the recipe above.

A hosted (HTTP) mode is not built yet. Contributions are welcome, but a file-reading server on the internet needs real care.

Alternative: install from source

If npx gives you trouble:

git clone https://github.com/srayan-uxd/adobe-xd-mcp.git
cd adobe-xd-mcp
npm install
npm run build

Then use node as the command and the full path to dist/index.js as the argument:

{
  "mcpServers": {
    "adobe-xd": {
      "command": "node",
      "args": ["/full/path/to/adobe-xd-mcp/dist/index.js"],
      "env": { "XD_MCP_ROOTS": "C:/Designs" }
    }
  }
}

Something not working?

  • The tool doesn't show up: restart the app completely, and check that node -v prints 18 or higher.

  • "Access denied ... outside the allowed roots": the file isn't inside your XD_MCP_ROOTS folder. Set it to the folder that holds the file.

  • npx not found (Windows): use the cmd /c version from the Claude Desktop tip above.

  • Still stuck: open an issue. Please don't attach private designs.


Contributing

Ideas and fixes are welcome. See CONTRIBUTING.md and the CHANGELOG.

npm install
npm test                              # builds, then runs the smoke, export, render, health, layout, insights and security tests
node test/real.mjs path/to/file.xd    # try the server on a real file (read-only)

License

MIT. Not affiliated with or endorsed by Adobe. "Adobe XD" is a trademark of Adobe Inc.

Available Tools

24 tools
xd_audit_designA

Design QA. Checks text contrast (WCAG, background estimated), tiny text, small tap targets on interactive layers, placeholder text, near-duplicate colors, too many fonts/sizes and default layer names. Returns findings with artboard and layer ids plus per-check totals.

Inputs: file (required), artboard, maxPerCheck, minFontSize, +1 more.

xd_export_artboardA

Full-fidelity export of one artboard (or a sub-layer via nodeId) as clean JSON for rebuilding the design in another tool such as Figma: frames, rectangles (with corner radius), ellipses, lines, vector paths (SVG path data), boolean shapes, text (font, size, styled runs), fills (solid/gradient/image), strokes, shadows/effects, opacity, rotation, constraints, components, repeat grids and layout grids. Linked components (syncRef) are resolved to their real content. Text is normalised (top-left box, baselineY, line breaks as , alignment, autoResize, underline runs). The full transform matrix is given with transformOrigin top-left. Positions are relative to the parent; masks are in the masked group's local space. Images are referenced by imageRef; pass assetsDir to save them. Big screens are split into pages (page / pageCount / hasMore); each page lists whole top-level layers. Use nodeId to drill into one layer.

Inputs: file (required), artboard (required), page, depth, +3 more.

xd_export_componentB

Export one component master (see xd_list_components) in the same format as xd_export_artboard.

Inputs: file (required), component (required), page, depth, +2 more.

xd_export_copyA

Export all text content (a copy deck) for translation or review, as json or csv. CSV cells are protected against spreadsheet formula injection.

Inputs: file (required), format, artboard.

xd_export_svgA

Export one or more layers as ONE self-contained SVG (vectors, gradients, shadows, masks and images embedded), so an illustration, icon or any drawing can be imported into Figma as a single vector instead of dozens of pieces. Pass the layer ids of a group, or the parts of a merged drawing from xd_infer_layout. Only the selected layers are drawn (no page background). Use saveTo to write the SVG to a folder inside the allowed roots; otherwise it is returned inline (up to 600k characters).

Inputs: ids (required), file (required), artboard (required), saveTo, +1 more.

xd_extract_assetsC

Extract embedded images/resources from the XD file into an output directory.

Inputs: file (required), outDir (required).

xd_extract_textB

Extract all text content from one artboard, or from every artboard if none is given.

Inputs: file (required), artboard.

xd_find_layersA

Search layers across the file by text content, layer name, type (text, rectangle, ellipse, path, group, ...) or color (#rrggbb, matched with a small tolerance).

Inputs: file (required), name, text, type, +3 more.

xd_font_reportA

Fonts used by the file (or one artboard): family, weights/styles, sizes, how often, whether each family is installed on this computer, a substitution table for missing weights (e.g. Medium -> Regular), and a licence note. Run this before rebuilding a design elsewhere and warn the user about missing fonts. Only reads font names; never creates or alters fonts.

Inputs: file (required), artboard.

xd_get_artboardA

Get the layer tree of one artboard (positions, sizes, fills, strokes, text, fonts). Match by id or name (partial ok).

Inputs: file (required), artboard (required), depth.

xd_get_design_systemA

Extract the design system actually used in the file: color palette (ranked, with fill/text/stroke usage), typography styles and size scale, corner radii, stroke widths and shadows. Output as json, css (custom properties), tailwind (theme.extend) or figma-variables (variable collections, text styles named by role and effect styles, ready to create in Figma).

Inputs: file (required), format.

xd_get_design_tokensA

Summarize colors and fonts used across the document (by frequency), plus shared styles if present.

Inputs: file (required).

xd_get_flowB

Prototype flow map: every interaction (tap/hover/time triggers, transitions, destinations) with source screen and layer, the home screen, and a Mermaid flowchart of screen-to-screen links.

Inputs: file (required).

xd_get_interactionsC

Return prototype interactions / flows (interactions.json) if the file has any.

Inputs: file (required).

xd_get_previewA

Return the embedded preview image of the XD file (first artboard render).

Inputs: file (required).

xd_get_shared_assetsC

Document-level libraries: saved color swatches, library colors and character (text) styles.

Inputs: file (required).

xd_infer_layoutA

Phase 2 of a conversion: from the exact export of a screen, propose frames with AUTO-LAYOUT intent. Clusters layers into cards by containment, detects rows/columns and header-style space-between rows, derives item spacing (median gap) and padding (rounded to a grid), marks equal-width cards and full-width text as FILL, keeps illustrations/photos/masked or rotated groups as fixed leaves, puts overlapping decorations in absoluteChildren, turns centred-label rectangles into buttons, and suggests semantic layer names. Leaves reference the exact layers by ref. Returns a drift report (pixelDeltaEstimate, within3px, within5px, elementsAbsolute, elementsAutoLayout) so you know how far the auto-layout version moves things. A heuristic proposal: rebuild it beside the exact copy and compare with xd_render_artboard.

Inputs: file (required), artboard (required), grid, nodeId, +6 more.

xd_list_artboardsA

List the artboards in an Adobe XD file with their ids and names, plus document name. Set includeGeometry to also get each artboard's canvas position and size (slower on big files).

Inputs: file (required), includeGeometry.

xd_list_componentsB

List the reusable components (symbols) defined in the file: id, name, size.

Inputs: file (required).

xd_list_entriesB

List every file inside the XD archive (for debugging / finding raw data).

Inputs: file (required).

xd_pingA

Health check: server version, allowed folders, Node and platform, whether a browser for xd_render_artboard was found, and a built-in self-test of the parser and exporter. Pass a file to also check that it opens.

Inputs: file.

xd_project_overviewA

Scan a folder (inside the allowed roots) for .xd files and summarize each: name, size, artboard and component counts, whether it has a prototype. Searches up to 3 levels deep, max 60 files.

Inputs: folder (required).

xd_read_rawA

Read a raw JSON entry from the archive (e.g. manifest, an artboard's graphicContent.agc), optionally drilling in with a dotted path like children.0.artboard.children.2. Output is truncated to maxChars.

Inputs: file (required), entry (required), path, maxChars.

xd_render_artboardA

Render one artboard (or one layer via nodeId) to a PNG so you can SEE the result and verify a rebuild. Renders the full-fidelity export (linked components, masks, gradients, images, shadows, text) as one SVG and screenshots it in a local headless Chrome/Edge. Set XD_MCP_CHROME if the browser isn't found automatically. Nothing is uploaded.

Inputs: file (required), artboard (required), scale, nodeId, +1 more.

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

Loading tool schema changelog…

    TDQS

    B3.3/5.0

    Scored across 24 tools

    Disambiguation3/5

    There are several overlapping tool clusters: design-system/tokens/shared-assets extraction, get-artboard vs export-artboard, get-interactions vs get-flow, and extract-text vs export-copy. Descriptions usually clarify the intended use, but an agent can still plausibly misselect within these pairs.

    Naming Consistency4/5

    All tools use the xd_ prefix and most follow a verb_noun pattern such as xd_list_artboards, xd_get_flow, and xd_export_svg. A few names are noun phrases or exceptions (xd_project_overview, xd_font_report, xd_ping), but the convention remains readable and predictable.

    Tool Count3/5

    At 24 tools, the surface is heavy for an MCP server and includes several specialized and debug-oriented tools. Most tools serve the broad XD extraction/conversion workflow, but the count is borderline rather than comfortably scoped.

    Completeness4/5

    The read-only extraction and conversion surface is comprehensive: artboards, components, assets, text, design tokens, interactions, rendering, QA, and conversion planning are covered. Minor gaps remain around batch artboard/component export and some write/edit operations, though writing may be intentionally out of scope.

    Maintenance

    ActivityMaintained
    ResponsivenessNo recent community issues

    Related MCP Connectors

    Related MCP Servers

    • A
      license
      Not graded
      quality
      D
      maintenance
      Enables parsing of PSD files and extraction of layer information, design tokens, and assets to assist LLMs in converting designs to code.
      19 npm
      2
      MIT
    • A
      license
      Not graded
      quality
      B
      maintenance
      Enables AI tools to read, edit, check, and export the currently open Figma file locally, with support for design files, FigJam boards, and Slides decks plus quality checks and design-to-code workflows.
      1
      MIT
    • A
      license
      B
      quality
      B
      maintenance
      Enables coding agents to read, render, and normalize design documents from Figma and Adobe XD, providing visual context plus structured design data and generating starter code for web, React, Vue, Flutter, SwiftUI, and Jetpack Compose.
      13
      343 npm
      2
      GPL 3.0