Adobe XD MCP
Read-only, local MCP server for inspecting Adobe XD files and supporting design-to-code, design-system, QA, and XD-to-Figma workflows.
List artboards and inspect layer trees with positions, sizes, fills, strokes, text, and fonts.
Extract all text or copy decks as JSON/CSV, and search layers by text, name, type, or color.
Summarize colors/fonts and generate design-system outputs as JSON, CSS variables, Tailwind theme, or Figma variables.
Audit designs for WCAG contrast, tiny text, small tap targets, placeholder text, duplicate colors, and excessive fonts.
Map prototype flows and interactions, including a Mermaid flowchart.
Export artboards/layers as full-fidelity JSON for rebuilding in other tools, with paging and optional image extraction.
Render artboards/layers to PNG via local headless Chrome/Edge for visual comparison.
Infer auto-layout structure and export illustrations/icons as single self-contained SVGs.
Report fonts used, installed status, substitutions, and license notes.
List/export components, shared color swatches, library colors, and text styles.
Get embedded preview images, extract embedded assets, and summarize folders of .xd files.
Inspect raw XD archive entries for debugging and run health checks.
Stay local and read-only: no network calls, only allow-listed folders, only .xd files.
Supports XD-to-Figma workflows by exporting Adobe XD artboards, layers, components, images, and design data as clean JSON that AI tools can use alongside Figma's MCP server to recreate XD screens and components in Figma.
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@Adobe XD MCP List the screens in my XD file and extract all text from the Login screen"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
Adobe XD MCP
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 |
| Lists every screen (artboard) with its name and id |
| Layer tree of one screen: position, size, fills, strokes, radius, text, fonts |
| All text from one screen, or the whole file |
| Colors and fonts used across the file, most-used first |
| 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) |
| Design QA: text contrast (WCAG), tiny text, small tap targets, placeholder text, near-duplicate colors, too many fonts, default layer names |
| Search the whole file by text, layer name, type or color |
| All the text as JSON or CSV (a copy deck for translation or review) |
| Prototype flow map: taps, hovers, transitions, destinations, plus a Mermaid diagram |
| The raw prototype interactions stored in the file |
| 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) |
| 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 |
| 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 |
| 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 |
| Fonts used, whether they are installed on this computer, substitutions for missing weights, and a licence note |
| List reusable components (with usage counts and descriptions) and export one, including its states (hover etc.) as variants |
| Health check: version, allowed folders, browser found, and a built-in self-test |
| Saved color swatches, library colors and text styles |
| The preview image saved inside the file |
| Saves embedded images to a folder (inside your allowed folders) |
| Summarizes every |
| Advanced: look inside the raw |
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):
xd_list_artboards, then pick one screen. A 60-screen file is a lot of work, so go screen by screen.xd_font_report: warn about fonts that aren't installed before building anything.xd_get_design_systemwith formatfigma-variables: create variables, text styles and effect styles first.xd_list_components: create components for repeated items, then use instances.xd_render_artboard: look at the original so you know what you are aiming for.xd_export_artboard(withassetsDirfor images): the exact layer data, used for text styles and as the source for illustrations and photos.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 withxd_export_svg(pass the leaf'sref, or itspartsfor a merged drawing) and place it inline or absolutely inside its card. Photos are cloned from the exact export through theref.xd_render_artboardagain 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.xdin my Figma file. Save images toC:/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_ROOTSare 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
.xdfiles 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_artboardstarts 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 (setXD_MCP_CHROMEto 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_artboardis 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
.xdfiles.
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 --versionIf 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.0The #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
Open Settings → Developer → Edit Config. This opens
claude_desktop_config.json.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
npxisn'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.0Cursor
Open Settings → MCP → Add new MCP server (or edit
~/.cursor/mcp.json).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 buildThen 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 -vprints 18 or higher."Access denied ... outside the allowed roots": the file isn't inside your
XD_MCP_ROOTSfolder. Set it to the folder that holds the file.npxnot found (Windows): use thecmd /cversion 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 toolsxd_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_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
Scored across 24 tools
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.
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.
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.
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
Related MCP Connectors
Read, query, edit and render DWG drawings with AI. No AutoCAD required.
Run accessibility, contrast, and design token audits and file QA issues from your AI coding tool.
Give AI agents your deeepSpace design system: components, tokens, styles and code mappings.
Serves your design system and coding standards to coding agents, so they stop guessing.
Related MCP Servers
- AlicenseNot gradedqualityDmaintenanceEnables parsing of PSD files and extraction of layer information, design tokens, and assets to assist LLMs in converting designs to code.19 npm2MIT
- AlicenseNot gradedqualityDmaintenanceEnables Claude to interact with Adobe XD files, extract design information, and generate React components from designs.20MIT
- AlicenseNot gradedqualityBmaintenanceEnables 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.1MIT
- AlicenseBqualityBmaintenanceEnables 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.13343 npm2GPL 3.0