figme
figme reads a local Figma .fig file offline — no account, token or network — and lets an agent explore its layers, styles, components, tokens and images, with optional PNG/SVG rendering.
Overview (
fig_overview) — document name, export date, node counts by type, page list, number of components/variables/images; the recommended starting point.Browse the layer tree (
fig_tree) — flat, depth-limited (max 6) listing under any node, filterable by type, withoutlinetext format and cursor paging.Inspect a node (
fig_node) — geometry, position, corner radii, fills/strokes/effects as hex, auto-layout, text basics, component/variable links, child summaries;rawdetail for unmapped fields.Search (
fig_find) — case-insensitive substring over layer names and text, scoped to a subtree or node types, returning page, ancestor breadcrumb and matched field.Text inventory (
fig_text) — every string in document order with fonts, size, line-height, colour, plus optional mixed-style runs and ancestor paths, for copy audits and translation.Resolved style (
fig_style) — flattened CSS-ready style: hex colours, typography, and auto-layout as flexbox (direction, gap, padding, justify/align, sizing, flexGrow, alignSelf, margin), with named shared styles and variable bindings.Components (
fig_components) — all SYMBOL nodes with description, component-set/variant, property definitions and usage counts, sorted most-used first.Instance overrides (
fig_instance) — which component an INSTANCE points at, its property assignments, and each override's path and changed fields.Design tokens (
fig_variables) — collections, modes and per-mode values (hex/numbers/strings), with aliases followed inside the file.Images (
fig_image) — embedded bitmaps by 40-hex hash or node guid, or the document thumbnail; inline for small images or save to disk.Raw vector data (
fig_blob) — undecoded blob-table bytes (vector networks, path commands) as base64/hex with byte truncation.Render (
fig_render) — draw any node or page to PNG (default 2x, capped 1568 px) or SVG, offline, with a report ofapproximatedandunsupporteddetails.Safety/behaviour — read-only toward the
.fig(writes only when you passsavePath), entirely offline, responses kept small via shallow defaults, filters and pagination.
Reads local Figma .fig files offline, providing access to document structure, geometry, fills, strokes, effects, auto-layout, text runs, components, instances, variables, prototype links, and embedded bitmaps.
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., "@figme Open design.fig and summarize its pages and components."
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.
figme
An MCP server that lets your AI agent read Figma .fig
files — offline, with no Figma account or API token.
Save a design from Figma as a .fig file, and your agent can read everything in it: layers and
layout, colours, text, components, design tokens and images. figme can also draw any frame as a
picture, so the agent can compare what it built with the design.
you: "what does the tab component in design.fig look like?"
fig_overview → 10 pages, 2,046 components, 273 variables, 212 images
fig_find → "lv2/tab/large" is 2:1337, on page "Page 1"
fig_style → display:flex, direction:row, gap:8, padding:"8px 16px",
cornerRadius:4, stroke #FFFFFF bound to variable "tab/large/underline"
(active #FFFFFF / inactive #333333)Why figme
No account, token or network. figme reads the file on your disk and never contacts figma.com.
Everything in the file. Layers and geometry, auto-layout, fills, strokes, effects, text with mixed styles, components and instances, variables, prototype links and images. Layout comes back as CSS flexbox, colours as hex, and colours bound to variables keep their token names.
What Figma shows, not just what it stores. The layers inside a component instance come back with the instance's overrides applied, under the ids Figma itself gives them, and a shared style reports its live value rather than the stale copy cached beside it.
Pictures as well as numbers.
fig_renderdraws any layer as a PNG or SVG.Small responses. Even on a 116,000-node file, a response stays around 20 KB. Results are shallow by default, filterable and paged.
Robust to Figma updates. Every
.figcarries the schema that describes it, and figme decodes the file with that schema, so fields Figma adds later don't break it.
Related MCP server: Figma MCP Server
Quick start
You need Node.js 22.15 or newer.
1. Save the design as a .fig file. In Figma, choose File → Save local copy… If it's a
Community file, click Open in Figma first.
2. Add figme to your agent. In Claude Code:
claude mcp add figme -- npx -y figme-mcpFor Cursor, VS Code, Windsurf and other clients, see Set up your client.
3. Ask. Give the full path to the file, and paste a Figma link if you have one:
Using figme, read /Users/me/Desktop/App.fig and build this frame as a React component: https://www.figma.com/design/AbC123/App?node-id=3017-121
The agent picks the tools from there. A few more things to try:
"List the pages and the most-used components in /Users/me/Desktop/App.fig."
"Turn the colour variables in /Users/me/Desktop/App.fig into CSS custom properties."
"Render the sign-in screen in /Users/me/Desktop/App.fig to /Users/me/Desktop/sign-in.png."
Set up your client
Every client runs the same command, npx -y figme-mcp. Only the place you put it changes.
claude mcp add figme -- npx -y figme-mcp # this project
claude mcp add -s user figme -- npx -y figme-mcp # every projectTo share the server with everyone who works on a repository, commit a .mcp.json at its root:
{
"mcpServers": {
"figme": { "command": "npx", "args": ["-y", "figme-mcp"] }
}
}The Claude Code extensions for VS Code and JetBrains use this same configuration. They don't read the editor's own MCP settings.
Add this to ~/.cursor/mcp.json for every project, or to .cursor/mcp.json for one:
{
"mcpServers": {
"figme": { "command": "npx", "args": ["-y", "figme-mcp"] }
}
}From a terminal:
code --add-mcp '{"name":"figme","command":"npx","args":["-y","figme-mcp"]}'Or add this to .vscode/mcp.json. VS Code uses the key servers, not mcpServers:
{
"servers": {
"figme": { "type": "stdio", "command": "npx", "args": ["-y", "figme-mcp"] }
}
}Then switch the Chat view to Agent mode.
Add this to ~/.codeium/windsurf/mcp_config.json:
{
"mcpServers": {
"figme": { "command": "npx", "args": ["-y", "figme-mcp"] }
}
}Any client that can start a local (stdio) MCP server works. Give it:
{ "command": "npx", "args": ["-y", "figme-mcp"] }Config file locations change between client releases. If a path above doesn't match what you see, check your client's MCP documentation.
On Windows, some clients can't find npx by themselves. If the server doesn't start, run it
through cmd:
{ "command": "cmd", "args": ["/c", "npx", "-y", "figme-mcp"] }Tips
Always give the full path to the file, even with a link. A Figma link can't tell figme which file on your disk it belongs to, and a relative path is resolved from wherever your client started the server.
Don't let the agent open the Figma link. The page needs a login, so the agent gets nothing useful back, and it may then invent a design from the words in the URL. figme tells agents not to; if yours tries anyway, stop it.
"Node not found" usually means the saved file isn't the one the link points to. Compare the document name that
fig_overviewreports with the name in the link, or ask the agent to find the layer by name instead.Big files need memory. A 39 MB
.figtakes about 900 MB of RAM once parsed, and figme keeps up to 4 parsed files. On a smaller machine, keep just one:{ "command": "npx", "args": ["-y", "figme-mcp", "--max-files", "1"] }
Tools
Your agent picks these on its own; you don't need to name them.
Tool | What it gives the agent |
| The pages, node counts, and how many components, variables and images the file has |
| The layer tree under a node, a few levels at a time, instances opened |
| One layer in detail: size, position, corner radii, auto-layout, children |
| Layers whose name or text contains a string |
| All the text, with fonts and mixed styles |
| Fills, strokes, effects and typography, with auto-layout as CSS flexbox |
| The components, their properties, and how often each is used |
| What an instance changes from its component |
| Design tokens: every collection, mode and value |
| Embedded images, and the file's thumbnail |
| Raw vector data, for anything the other tools don't decode |
| A PNG or SVG picture of any layer or page |
Parameters and example responses for each are in docs/tools.md.
Limitations
Read-only. figme never changes your
.fig. It writes a file only when you askfig_imageorfig_renderto save one.A snapshot, not a live link. A
.figholds the design as it was when you saved it. When the design changes, save it again; figme picks up the new file.Rendering is close, not pixel-perfect.
fig_renderapproximates a few effects, such as background blur and angular gradients, and skips a few things, such as emoji. Every render lists what it approximated or skipped. See docs/rendering.md.Libraries from other files aren't included. Styles, variables and components published from another file show up as references, without their values.
Vector paths aren't decoded.
fig_blobreturns their raw bytes.
Contributing
Issues and pull requests are welcome. CONTRIBUTING.md explains how to build from source and run the tests, and how the parser works.
License
Available Tools
12 toolsfig_blobRaw blob bytesARead-only
Return the raw bytes of one entry in the file's blob table. Vector geometry, glyph outlines and similar bulk payloads are stored there and referenced by index from fields such as vectorData.vectorNetworkBlob and Path.commandsBlob (fig_node reports these as vector.networkBlob / vector.fillBlobs). This server does not decode the vector-network format — you get the bytes, base64 or hex, truncated to maxBytes with a flag when longer.
Inputs: file (required), index (required), encoding, maxBytes.
fig_componentsComponent catalogueARead-only
List the components (SYMBOL nodes) defined in the file: guid, name, description, the component-set it belongs to when it is a variant, its property definitions with defaults, and how many instances of it exist. Filter with query (case-insensitive substring of the name). Sorted by instance count, most-used first, so the load-bearing parts of the design system come back before one-off symbols. Follow up with fig_instance on a specific INSTANCE guid.
Inputs: file (required), limit, query, cursor.
fig_findSearch layers and textARead-only
Search a file for nodes by name and by text content (case-insensitive substring), optionally restricted to node types and/or a subtree. Each hit comes back with the page it lives on, a breadcrumb of ancestor names, and which field matched — so you can jump straight to a guid and then call fig_node / fig_style. Omit query to list every node of the given types.
Inputs: file (required), limit, query, scope, +2 more.
fig_imageEmbedded imageA
Fetch a bitmap stored inside the .fig: pass hash (the 40-hex image id reported by fig_node / fig_style on an image paint), or guid to take the image(s) used by that node, or hash:"thumbnail" for the document preview. Small images come back as viewable image content; larger ones come back as metadata (mime, byte size, pixel dimensions) — give savePath to write the exact bytes to disk instead. NOTE: a .fig contains no rendered pictures of frames, only the bitmaps placed in image fills plus thumbnail.png, so this cannot screenshot a design.
Inputs: file (required), guid, hash, savePath.
fig_instanceInstance overridesARead-only
Explain one component INSTANCE: which SYMBOL it points at, its component-property assignments with the property names resolved, and every override it applies — each with the path down into the component, the node that path addresses, and the fields it changes. Use it to see how an instance differs from its component without diffing two subtrees.
Inputs: file (required), guid (required).
fig_nodeInspect a nodeARead-only
Inspect one node by guid (e.g. "2:1339"). detail:"full" (default) gives geometry, fills/strokes/effects as hex colours, corner radii, auto-layout, text basics, component and variable links, plus child summaries. detail:"raw" returns the decoded Figma record verbatim — the escape hatch for fields this server does not map yet; it is limited to one node per call and can be large.
Inputs: file (required), guid (required), detail, includeChildren.
fig_overviewFigma file overviewARead-only
Open a local Figma .fig file and summarise it: document name, export date, node counts by type, the page list, and how many components / variables / images it holds. START HERE. Then fig_tree a page, then fig_node / fig_style on interesting guids; fig_find jumps straight to a name or a piece of text. Everything is read-only and offline.
Inputs: file (required).
fig_renderRender a node to an imageA
Render a node — frame, component, instance, group, shape, text, or a whole page — to a PNG the model can look at, or to SVG. Fully offline: geometry, text outlines and images all come from the file. Rendering is best-effort: read approximated and unsupported in the report before trusting fine details; exact values remain available from fig_node / fig_style / fig_text. Default output is PNG at 2x, capped to 1568 px on the longest edge; use savePath to write a file instead of inlining it.
Inputs: file (required), guid (required), scale, format, +4 more.
fig_styleResolved style of a nodeARead-only
The flattened style of one node, shaped for writing code: hex fills / strokes / effects, corner radii, typography, and auto-layout translated into CSS flexbox terms (display, direction, gap, padding, justifyContent, alignItems, sizing) plus how the node behaves inside its parent layout (flexGrow, alignSelf, margin). Shared styles and variable bindings are named whenever they resolve inside this file.
Inputs: file (required), guid (required), includeRuns.
fig_textText inventoryARead-only
Extract every string of copy in the file (or in one subtree via scope), in document order: guid, layer name, the characters, the page, and the base typography (font, size, line-height, colour). With includeRuns:true each node also carries its styled runs — the mixed-format spans Figma stores per UTF-16 code unit — with only the fields each run overrides. Use this for copy audits and translation passes rather than walking the tree.
Inputs: file (required), scope, cursor, includePath, +2 more.
fig_treeExplore the layer treeARead-only
List the layers under a node, breadth-limited by depth (default 2, max 6). Returns a FLAT list in document order; each entry carries depth (relative to the requested root) and parent, so the hierarchy is reconstructable, and children (count) so you can see where to deepen. format:"outline" returns indented text lines instead of JSON and is roughly 4x denser for browsing. Large subtrees are truncated with truncated:true and a nextCursor you can pass back to continue.
Inputs: file (required), root, depth, types, +2 more.
fig_variablesVariables and modesARead-only
List the design tokens in the file: every variable collection (VARIABLE_SET) with its modes, and every variable with its value per mode — colours as hex, numbers and strings verbatim. Aliases are followed when the target variable lives in this file; a variable published from another library is returned as its opaque assetRef instead. Filter with set (collection name or guid) or query (substring of the variable name).
Inputs: file (required), set, limit, query, +2 more.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 12 tools
Each tool targets a distinct concern: overview, tree, node, find, text, style, components, instances, images, blobs, render, variables. The only mild overlap is fig_node vs fig_style (both inspect a single node) and fig_image vs fig_blob (both fetch raw bytes), but descriptions clarify the different purposes.
All tools share the fig_ prefix and use lowercase snake_case, which is consistent. The verbs are mostly clear (overview, tree, node, find, text, style, components, instance, image, blob, render, variables), though fig_overview is a noun-ish name rather than a verb_noun pattern like fig_list_pages or fig_get_overview.
12 tools is well-scoped for a Figma file inspection server. Each tool covers a distinct aspect of the domain: navigation, inspection, text extraction, style extraction, components, instances, images, blobs, and rendering. No tool feels redundant or unnecessary.
The server covers the read-only Figma file inspection domain thoroughly: overview, tree navigation, node lookup, search, text extraction, style extraction, components, instances, images, blobs, and rendering. Minor gaps include no direct way to list all pages as a standalone tool (only via fig_overview) and no tool for comparing two nodes, but these are workarounds.
Maintenance
Related MCP Connectors
OCR, transcription, file extraction, and image generation for AI agents via MCP.
Design canvas for agents: create, edit, render and export Figma-shaped designs over MCP.
Your personal library, readable by AI agents: durable snapshots, hybrid search, 46 MCP tools.
Your org's AI agents, tasks, runs, search, and brain files as MCP tools and resources.
Related MCP Servers
- AlicenseBqualityDmaintenanceEnables offline reading and rendering of Figma .fig files, allowing AI agents to extract design specs, export assets, and generate code without needing the Figma API or network access.262MIT
- FlicenseNot gradedqualityBmaintenanceEnables AI agents to access Figma design context, generate code from frames, extract variables, components, and layout data, and create or modify Figma files directly from MCP clients.-
- AlicenseNot gradedqualityCmaintenanceEnables agents to extract, inspect, search, and bundle design context from local Figma .fig files entirely offline, exposing frame summaries, node context, style tokens, assets, vector SVGs, and visual-match review via MCP.MIT
- AlicenseAqualityBmaintenanceProvides read-only Figma design data to AI agents via MCP, supporting local .fig files and browser-based figma.com access without plugins or API tokens.18106 npm1MIT