TalkToFigma MCP: A WebSocket Bridge That Lets Cursor and Claude Edit Figma Files Directly

What Problem Does TalkToFigma MCP Solve?

Design-to-code workflows usually force a human to translate a Figma file into code or manually copy text and style values. TalkToFigma MCP attacks the reverse direction: it lets an AI agent that already lives inside a coding tool, Cursor or Claude Code, reach into a live Figma document and change it. The README frames this as agentic AI communicating with Figma for reading designs and modifying them programmatically. The intended user is a developer who wants to ask an agent to scan text nodes, replace copy, apply component overrides, or adjust auto-layout properties without switching windows and without exporting assets. The project also contributes specific automation patterns, like bulk text content replacement and instance override propagation, which target designers who maintain many component instances. It is not a design tool for non-programmers; it is a bridge for people who already trust an AI agent to edit code and now want that same agent to edit design files.

Architecture: Three Moving Parts

The repository is split into three components. The first is a TypeScript MCP server under src/talk_to_figma_mcp, which speaks the Model Context Protocol to the AI agent. The second is a Figma plugin under src/cursor_mcp_plugin, which runs inside Figma and gives the server a way to act on the document. The third is a WebSocket server in src/socket.ts that sits between the two. The flow is: the agent calls an MCP tool, the MCP server forwards that request over a WebSocket channel to the Figma plugin, the plugin executes the Figma API call, and the result returns along the same path. The plugin must first join a channel using the join_channel tool, which implies a shared channel name ties a specific plugin instance to a specific server session. This design means the MCP server does not talk to Figma directly; it relies on a live plugin instance being open in the Figma file. That is a meaningful architectural constraint because it couples the automation to a running desktop session of Figma, rather than a headless API.

Setup Commands and Configuration

The README gives a clear setup path. First, install Bun, the JavaScript runtime, with curl -fsSL https://bun.sh/install | bash. Then run bun setup, which the README says also installs MCP in Cursor's active project. Next, start the WebSocket server with bun socket. Finally, install the Figma plugin from the community page or locally. For local plugin installation, you open Figma, go to Plugins > Development > New Plugin, choose Link existing plugin, and select src/cursor_mcp_plugin/manifest.json. The MCP server is registered in Cursor's configuration file ~/.cursor/mcp.json with a JSON block that points to bunx cursor-talk-to-figma-mcp@latest. For local development, the same file can direct to your repository with command bun and args pointing at src/talk_to_figma_mcp/server.ts. Windows with WSL users must uncomment the hostname: "0.0.0.0" line in src/socket.ts before starting the socket. The setup assumes you are comfortable editing JSON config files and running multiple terminal processes.

The MCP Toolset: From Reading to Writing

The MCP server exposes a wide range of tools grouped by function. Document and selection tools include get_document_info, get_selection, read_my_design, get_node_info, and set_focus. Annotations tools let an agent get_annotations and set_annotation with markdown support, which is useful for leaving review comments directly on design nodes. Prototyping tools include get_reactions and create_connections, the latter creating FigJam connector lines based on prototype flows or custom mappings. Creation tools cover basic shapes like create_rectangle, create_frame, create_section, and create_text. Text modification is a strong area with scan_text_nodes, set_text_content, and set_multiple_text_contents. Auto-layout tools like set_layout_mode, set_padding, and set_item_spacing allow structural changes to frames. Styling tools include set_fill_color, set_stroke_color, set_corner_radius, and set_image_fill, which accepts a local file path, URL, or base64 data. Layout tools such as move_node, resize_node, clone_node, and set_parent round out the set. There is also a components section with get_local_components, create_component_instance, get_instance_overrides, and set_instance_overrides. This is a broad surface, but the README does not specify which Figma API version or which node types are fully supported, so expect edge cases with complex nodes.

A Real Limitation: Requires a Live Plugin and a Local Server

The most significant limitation is that the automation cannot run without a human opening the Figma file and running the plugin. The WebSocket server must be running locally, the plugin must be connected to that server via a channel, and the AI agent must be configured to reach the MCP server. This rules out any batch or CI/CD use case where you want to update a design file without a desktop session. The README also warns about Windows + WSL specifically, where the default hostname does not allow connections and you must edit the source file to bind to 0.0.0.0. That is a sign that networking is a fragile point. The project has no recent releases listed, so you are depending on the default branch and the community plugin page for updates. The README mentions contributions for bulk text replacement and instance overrides, which suggests the feature set grows through community pull requests rather than a structured roadmap. If your Figma file is large, the scan_text_nodes tool uses intelligent chunking, but the README does not define the chunk size or the failure mode when a node is too large.

Alternatives: Figma REST API and Other MCP Servers

The natural alternative is the official Figma REST API, which lets you read file data and comments without any plugin. That API is read-only for file content in most plans; it does not let you modify the document structure or text nodes directly. TalkToFigma MCP's whole point is write access, which the REST API cannot give you. Another alternative is a different MCP server that uses Figma's Plugin API through a similar bridge. The README does not name any, but the design pattern of an MCP server plus a WebSocket plugin is common. The difference in approach is that TalkToFigma MCP requires a local WebSocket server and a development plugin, whereas a hypothetical server that uses the Figma Plugin API over a cloud relay would not require a local process but would introduce latency and security concerns. If you only need to read design tokens or export assets, the REST API is simpler and does not require Bun or a running plugin. If you need to mutate designs, TalkToFigma MCP is one of the few options that gives an agent that ability, but you must accept the operational overhead.

Maintenance, License, and Upgrade Cost

The project is licensed under MIT, so you can use and modify it freely, but the license does not come with support or warranty. The repository shows a last push date of 2026-07-26, which indicates recent activity, but there are no formal releases listed. That means you are tracking the default branch, and upgrades come as git pulls rather than versioned releases. The setup script bun setup modifies your Cursor project's MCP configuration, so running it again after an update could overwrite your custom settings. The README does not describe an uninstall process, so removing the integration requires manually editing ~/.cursor/mcp.json and deleting the plugin from Figma. The local plugin is linked from a manifest file, so if you pull new changes, you may need to reload the plugin in Figma to pick up new tools. The cost of maintenance is moderate: you need to keep Bun updated, monitor the WebSocket server for crashes, and re-verify the plugin after Figma updates its Plugin API. Given the absence of releases, you should pin your repository to a specific commit if you depend on a stable toolset.

Editorial conclusion

Adopt TalkToFigma MCP if you are a front-end developer or designer using Cursor or Claude Code and you want to automate repetitive Figma edits like text replacement, instance override propagation, or layout adjustments without leaving your editor. Do not adopt it if you need a production-grade, multi-user solution or if you cannot run a local WebSocket server and install a development Figma plugin. Before relying on it, verify that the WebSocket connection is stable in your environment, especially on Windows with WSL where you must uncomment the 0.0.0.0 hostname, and confirm that the plugin is approved for your Figma workspace. The project has no recent releases and is maintained as a single repository, so check the commit history for activity and test the tools against a copy of your design file first.

Official sources

1. grab/cursor-talk-to-figma-mcp on GitHub
2. Issues
3. License: MIT
4. Project website
5. README