claude-talk-to-figma-mcp: Driving Figma from Claude and Other Agents

The gap claude-talk-to-figma-mcp fills

Figma's own MCP entry in the MCP catalog is the obvious point of comparison, and the README draws it explicitly: the official option "requires a Dev Mode license", while this MCP "works with any Figma account (even free ones)". That single sentence defines the audience. If your team already pays for Dev Mode seats, the official route is the sanctioned one. If you are a solo designer, a student, or an engineer on a free plan who wants an agent to inspect a file, the licence gate is the whole problem, and this project is aimed at it.

The secondary audience is broader than the name suggests. The repository is titled around Claude, but the README lists Claude Desktop, Claude Code, Cursor, Antigravity, Windsurf, VS Code with GitHub Copilot, Cline and Roo Code as supported clients. The work it targets is repetitive and mechanical: contrast audits, bulk colour swaps, component scans, generating a React or Vue component from a selected frame. Those are tasks where a human clicking through layers is slower than a script, but where writing a Figma plugin from scratch is overkill.

How the socket, plugin and channel ID fit together

There are three moving parts, and the README is clear about which does what. The WebSocket server "enables the Agent to send commands to Figma". The Figma plugin "enables Figma to receive commands from the agent and return responses". The MCP server itself is the piece the agentic tool talks to, and it is what exposes the read and modify tools.

The handshake is a channel ID. After importing the plugin, you open it in Figma, copy the bold code inside the green box, and type `Connect to Figma, channel {your-ID}` into the agent chat. That string is the only thing tying a specific Figma session to a specific agent conversation, so a stale channel ID is the first thing to suspect when nothing happens.

Parallel execution is handled server-side. The README states that "a built-in command queue processes requests sequentially on the server side, preventing the Figma API from timing out", which is what makes multiple sub-agents viable. The trade-off is stated just as plainly: because several agents can touch the document at once, implicit page context is unsafe, so stateful commands such as `set_current_page` are blocked and every creation or structural command must pass an explicit `parentId`. That is a real constraint on how you write prompts, not a footnote.

Installing the MCP and connecting a first Figma file

The README quotes a five minute setup and a two minute first automation. Requirements are Node.js, Figma Desktop, and one of the listed AI clients. Note that Figma Desktop is required, not the browser editor, because the plugin is imported as a development plugin.

The first command is the all-in-one launcher. It clones the repository, installs dependencies and starts the WebSocket server:

npx claude-talk-to-figma-mcp

Once you are inside the cloned folder, later sessions only need the socket script. The README gives both forms:

bun run socket

or `npm run socket` if you prefer npm. Next, in Figma Desktop, go to Menu, then Plugins, then Development, then Import plugin from manifest, and select `src/claude_mcp_plugin/manifest.json` from inside the folder where you installed the MCP.

For Cursor, the README walks through Settings, Tools & Integrations, New MCP Server, and adding this to `mcp.json`:

{
  "mcpServers": {
    "ClaudeTalkToFigma": {
      "command": "npx",
      "args": ["-p", "claude-talk-to-figma-mcp@latest", "claude-talk-to-figma-mcp-server"]
    }
  }
}

Save and restart Cursor. Claude Desktop takes a different path: download `claude-talk-to-figma-mcp.dxt` from the Assets section of the latest release and double-click it, and the README says Claude configures itself. For Claude Code, Windsurf, VS Code with Copilot, Cline and Roo Code, the README points at the "Configure your Agentic Tool" chapter of INSTALLATION.md.

To finish, open the plugin in Figma, copy the channel ID from the green box, and send the connect message in chat. If the agent replies that it cannot reach Figma, check that the socket process is still running in your terminal.

The plugin has to stay open, and set_current_page is blocked

The most concrete limitation is architectural. Commands travel from the agent to the MCP server to the WebSocket to the plugin running inside Figma Desktop. The plugin is the only component with access to the document, so closing it, switching to a different file without reconnecting, or running Figma in a browser tab breaks the chain. There is no documented headless mode, and the README does not describe rollback or undo semantics for a batch of agent-issued changes.

The blocked `set_current_page` command is the second limitation, and it bites hardest on large multi-page documents. An agent cannot say "work on the Components page" and then issue relative commands; it has to carry a `parentId` for every creation or structural edit. Prompts written for a single-agent workflow, where page context was implicit, will need rewriting.

Docker is offered as an alternative for running the WebSocket server "in a team environment", and the Dockerfile exposes port 3055 and starts `src/socket.ts` with Bun. That covers the server side. It does not change the fact that the plugin still runs inside someone's Figma Desktop session, so Docker is not a route to unattended operation.

How this differs from writing a Figma plugin or using the official MCP

The nearest alternative is Figma's official MCP from the MCP catalog. The difference is licensing and access: the official one requires a Dev Mode license, this one works on any account including free ones. If your organisation already holds Dev Mode seats and wants vendor-supported tooling, the official MCP is the lower-risk pick and this project's main advantage disappears.

The other alternative is writing a Figma plugin yourself. That gives you full control over which operations run, how they are batched, and what happens when one fails, and it does not depend on an agent getting a prompt right. The cost is that you write and maintain the plugin, and you lose the natural-language layer entirely. This MCP sits between the two: less control than a bespoke plugin, less setup than building one, and a licence position that the official route does not offer.

On the agent side, the comparison is between this server and whatever MCP servers you already run. Nothing in the README suggests it replaces an existing server; it adds Figma tools to the agent's toolset, and the command queue exists precisely so it can coexist with parallel agent work.

Licence, release cadence and what upgrades cost you

The repository is MIT licensed, which permits commercial use, modification and redistribution provided the copyright notice and permission notice are retained. That is the licence text, not legal advice; if you are embedding this in a product, have your own counsel read it rather than treating this paragraph as clearance.

The release history is short and recent. v0.9.1 and v0.9.2 both landed on 2026-02-28, and v1.0.0 is labelled "Stable Release" with a push on 2026-04-18. The README documents `bun run socket` and `npm run socket` for daily use, so the practical upgrade path is re-running the launcher or pulling the repository and rebuilding. The package also ships a `build:dxt` script that syncs the version from package.json into manifest.json before packing, which matters if you distribute the .dxt file internally: the plugin manifest and the npm package version are kept in step by that script, not by hand.

Editorial conclusion

Adopt it if you want agent-driven Figma edits on a free account and you can keep the desktop plugin open while the socket runs; skip it if you need headless operation or you rely on set_current_page, which the README says is blocked. Before wiring it into a real file, verify the channel ID handshake end to end and check the manifest path src/claude_mcp_plugin/manifest.json against your checkout.

Frequently asked questions

Official sources

1. arinspunk/claude-talk-to-figma-mcp on GitHub
2. Issues
3. License: MIT
4. README
5. Releases