claude-talk-to-figma-mcp: an MCP bridge that lets AI agents edit Figma without a Dev Mode seat
A Model Context Protocol (MCP) that allows Claude Desktop and other AI tools (Claude Code, Cursor, Antigravity, etc.) to read, analyze, and modify Figma designs
At a glance
- What is it?
- A TypeScript MCP server plus a Figma plugin that relays agent commands over a WebSocket channel. The pitch is account-agnostic access to Figma; the trade-offs are manual plugin installation, a channel handshake, and blocked stateful commands under parallel agents.
- Who is it for?
- Adopt it if your team already runs an agentic client and you want Figma reads and writes on a free Figma account, accepting that every session starts with the socket, the plugin, and the channel handshake. Skip it if you need headless or CI-driven Figma access, since the README makes Figma Desktop a hard requirement and the plugin must be imported from src/claude_mcp_plugin/manifest.json by hand.
- Can I use it commercially?
- Yes. MIT is a permissive licence: you can use, modify and sell software built on it, as long as you keep its copyright and licence notices.
- Is it still maintained?
- Yes. The repository last received commits 150 days ago.
- What is it written in?
- Mainly TypeScript, according to GitHub's language statistics.
Answers come from the project's GitHub data, last synced on September 15, 2026, and from our analysis. They are not legal advice.
DEEP OPEN-SOURCE ANALYSIS
The Dev Mode licence wall this project routes around
Figma's own MCP offering is gated behind a Dev Mode licence, and the README states the key advantage plainly: this MCP works with any Figma account, including free ones. That single sentence defines the audience. It is not aimed at design-system teams who already pay for Dev Mode and get first-party tooling. It is aimed at solo developers, small studios, and students who have a Figma account, an agentic client, and no budget line for a seat upgrade.
The secondary audience is UX and UI teams who want scripted bulk work. The README lists automated accessibility audits, bulk style updates across a document, and visual hierarchy analysis as the intended chores. Those are tasks where a human clicks through dozens of layers, and where a text prompt plus a tool call is genuinely faster. The example prompts are concrete enough to judge: find all text with contrast ratio below 4.5:1 and suggest colours meeting WCAG AA, or change one hex value to another across all primary buttons.
What the project does not claim to be is a design tool. It is a control channel. The agent decides what to change; this repository only carries the instruction into Figma and the result back out.
Two processes, one WebSocket channel, and a manual handshake
The architecture is split in two halves that must both be running. On one side there is a Node WebSocket server, started from the terminal. On the other side there is a Figma plugin, imported into Figma Desktop from the manifest at src/claude_mcp_plugin/manifest.json. The MCP server is what your agentic tool talks to; the plugin is what actually touches the document.
The join between them is a channel ID. After opening the plugin in Figma, the README says you copy the bold code inside the green box and type a sentence into the agent chat: Connect to Figma, channel followed by that ID. That handshake is the whole discovery mechanism. There is no OAuth flow, no account linking, no token exchange. A short string typed into chat is what binds an agent session to a specific open Figma document.
That design has a consequence worth naming. Because the channel is created by the plugin and pasted by hand, the connection is per-session and per-document. Close Figma or restart the socket and the agent has to be told the channel again. It is a low-ceremony approach that suits a single designer at a desk and fits poorly with anything that needs to run unattended.
Installation: npx, a manifest import, and a per-client config block
The README describes a four-step setup with an advertised five minutes to install and two minutes to first automation. Step one is a single command run from a terminal in the folder where you want the tool:
npx claude-talk-to-figma-mcp
The README calls this an all-in-one that clones, installs, and starts. For later sessions it gives a shorter path: from inside the project folder, run bun run socket, with npm run socket offered as the alternative.
Step two happens inside Figma Desktop, not the browser: Menu, Plugins, Development, Import plugin from manifest, then select src/claude_mcp_plugin/manifest.json from the installed folder. Step three configures the client. Claude Desktop users download claude-talk-to-figma-mcp.dxt from the Assets section of the latest release and double-click it, after which Claude configures itself. Cursor users open Cursor Settings, Tools & Integrations, click New MCP Server to open mcp.json, and add a server entry named ClaudeTalkToFigma whose command is npx with args -p, claude-talk-to-figma-mcp@latest, and claude-talk-to-figma-mcp-server, then save and restart Cursor. Claude Code, Windsurf, VS Code with GitHub Copilot, Cline, and Roo Code are pointed at the Configure your Agentic Tool chapter of INSTALLATION.md rather than spelled out in the README.
Step four is the handshake described above. A Docker path exists for teams that prefer containers or need the WebSocket server in a shared environment, documented in the same installation guide.
Parallel agents are supported, but stateful commands are deliberately blocked
The multi-agent section is the most opinionated part of the README and the part most likely to surprise a new user. The server supports safe parallel execution, so several agents can work on the same Figma file at once. The mechanism is a built-in command queue that processes requests sequentially on the server side, which the README says prevents the Figma API from timing out.
The cost of that safety is a restriction. Because multiple agents can modify the document at the same time, implicit page context is unsafe, so stateful commands such as set_current_page are blocked outright. Every agent must pass an explicit parentId when running any creation or structural modification command, with create_frame and create_text given as examples.
This is a real design decision, not a footnote. It means prompts that work in a single-agent mental model, where you set a page and then create things, will fail here. Agents have to carry the target container with every call. If you are writing your own prompts or tool wrappers, that constraint belongs in your instructions, because the alternative is a creation command that errors or lands in the wrong place. The README credits the feature to an external contributor, which suggests it arrived after the initial design rather than shaping it.
Command surface: reads, creation, and modification
The capabilities list groups work into three buckets. Design analysis covers getting document information, the current selection and styles, scanning text, auditing components, and exporting assets. Element creation covers shapes, text and frames with style control, plus clone, group and organise operations. Modification covers colours, borders, corners and shadows, auto-layout, advanced typography, and both local components and team library components.
The full tool reference lives in COMMANDS.md, and that file is where you should look before trusting any specific claim about a command name or parameter. The README names only a few commands directly: set_current_page as blocked, and create_frame and create_text as examples that need parentId. Treat everything else as documented in COMMANDS.md rather than in the README.
The breadth is genuine. Reading a selection and writing a frame with auto-layout are different classes of operation, and supporting both means the plugin has to handle queries and mutations through the same channel. The README does not describe how the plugin serialises those calls or what happens when a mutation fails halfway, and TROUBLESHOOTING.md is the place to look for that rather than here.
Where this is the wrong tool
Figma Desktop is a stated requirement, and that rules out a whole class of usage. There is no headless mode described, no CI story, and no way to point the plugin at a Figma file in a browser tab. If your goal is to run design linting on every pull request, or to generate components in a build pipeline, this project is not shaped for it. The plugin has to be open in the desktop app, and a human has to copy a channel ID into a chat window.
The channel handshake is the second limitation. Every session begins with the socket running and the agent told the channel. That is fine for interactive work and awkward for anything scheduled. The README's subsequent-work-sessions section confirms the pattern: start the socket, open the plugin from recent plugins, copy the channel ID, tell the agent to connect.
A third constraint is the blocked stateful commands. Teams with existing prompts that assume they can set a page once and then create freely will need to rewrite them to pass parentId on every structural call. That is a migration cost, and it is not optional under the parallel-execution model the README describes.
Finally, the README does not state what happens when two agents target the same parentId, or how conflicts between simultaneous edits are resolved. The queue prevents API timeouts; it does not, on the evidence given, arbitrate intent.
Compared with Figma's official MCP
The obvious alternative is Figma's own MCP, linked from the README. The difference in approach is licensing, not architecture. Figma's official MCP requires a Dev Mode licence. This project works with any Figma account, free included, because it does not go through Figma's sanctioned integration path at all. It installs a development plugin into Figma Desktop and speaks to it over a local WebSocket, with the channel ID as the only access control.
That difference cuts both ways. You get access without a seat upgrade, and you take on the maintenance of a local bridge: a Node process, a development plugin that must be re-imported if the manifest moves, and a handshake that depends on a human copying a string. The official route presumably handles authentication and document selection in a way that does not involve pasting codes into a chat box, though the README does not describe it beyond the licence gate.
If you already hold Dev Mode seats, the licence advantage disappears and the remaining question is whether a locally run WebSocket bridge beats a first-party integration. The README does not make that case, and it does not try to.
Maintenance, licence, and what to check before adopting
The project is MIT licensed, which permits commercial use and modification, and the repository is not archived. The release history shows v1.0.0 marked as a stable release on 2026-04-18, following v0.9.2 and v0.9.1 in late February 2026. The jump to a 1.0 label is recent relative to the last push, so the stable designation reflects the maintainer's judgement rather than a long track record at that version.
Upgrade cost is concentrated in the client configuration. Cursor users pin claude-talk-to-figma-mcp@latest in mcp.json, which means the server updates on restart without a version bump in the config file. Claude Desktop users install a .dxt bundle and would re-download it from a new release. The Figma plugin lives in the repository at src/claude_mcp_plugin/manifest.json, so pulling a new version of the project can change the plugin code, and the README does not say whether Figma picks that up automatically or whether you re-import the manifest. That is worth confirming on your first upgrade rather than assuming.
The README does not state a support policy, a compatibility matrix for Node versions, or a deprecation process for commands. Before adopting, check COMMANDS.md against the operations you actually need, confirm the blocked set_current_page behaviour does not break existing prompts, and decide whether the channel handshake fits how your team starts a working session. This is an editor's note, not legal advice: MIT terms are permissive, but review the licence text yourself if you plan to redistribute a modified plugin.
Editorial conclusion
Adopt it if your team already runs an agentic client and you want Figma reads and writes on a free Figma account, accepting that every session starts with the socket, the plugin, and the channel handshake. Skip it if you need headless or CI-driven Figma access, since the README makes Figma Desktop a hard requirement and the plugin must be imported from src/claude_mcp_plugin/manifest.json by hand. Before rolling it out, verify the blocked set_current_page behaviour against your own commands in COMMANDS.md and confirm your agents always pass an explicit parentId.
Community notes