Model or dataset
grab/cursor-talk-to-figma-mcp avatar
grab/cursor-talk-to-figma-mcp

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

TalkToFigma: MCP integration between AI Agent (Cursor, Claude Code, Codex) and Figma, allowing Agentic AI to communicate with Figma for reading designs and modifying them programmatically.

7,109 stars796 forksJavaScriptMIT

At a glance

What is it?
TalkToFigma MCP connects AI coding agents like Cursor and Claude Code to Figma through a WebSocket server and a Figma plugin, exposing tools for reading and modifying designs. The project is early-stage, requires Bun, and assumes you are comfortable running a local server alongside your editor.
Who is it for?
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.
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 112 days ago.
What is it written in?
Mainly JavaScript, according to GitHub's language statistics.

Answers come from the project's GitHub data, last synced on November 15, 2026, and from our analysis. They are not legal advice.

From daily snapshots

Star history

  • grab/cursor-talk-to-figma-mcp7,109 ★ · +106
Star history
Repository2026-09-102026-11-15
grab/cursor-talk-to-figma-mcp7k7.1k

106 Stars in the last 66 days, measured from the daily GitHub snapshot. Compare with other projects

Editorial analysis

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.

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 credits a contributor, @dusskapark, for bulk text replacement and instance override propagation. If your Figma file is large, the scan_text_nodes tool uses intelligent chunking.

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. TalkToFigma MCP's whole point is modifying designs programmatically through a Figma plugin. Another alternative is a different MCP server that uses Figma's Plugin API through a similar bridge. TalkToFigma MCP requires a local WebSocket server and a Figma plugin. 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 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. The MCP server itself is published as the npm package cursor-talk-to-figma-mcp (version 0.3.5 in package.json), which the documented Cursor config runs with bunx cursor-talk-to-figma-mcp@latest. 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.

Frequently asked questions

What does MCP let Cursor do with a TalkToFigma document?

Through this project an agent reads the current document and selection with `get_document_info` and `get_selection`, then edits nodes with tools such as `set_text_content`, `set_fill_color`, `move_node` and `create_frame`. Nothing happens until the Figma plugin has joined a channel.

What does MCP mean in Figma for this project?

It means three moving parts: a TypeScript MCP server, a WebSocket server in `src/socket.ts`, and a Figma plugin under `src/cursor_mcp_plugin/`. The MCP server and the plugin never talk to each other directly, so the socket has to stay up for either one to work.

Is there an MCP plugin for Figma that cursor-talk-to-figma-mcp ships?

There are two routes. Install it from the Figma community page listed as the project homepage, or build it locally through Plugins > Development > New Plugin, then Link existing plugin, then choose `src/cursor_mcp_plugin/manifest.json`.

How do I run cursor-talk-to-figma-mcp on Cursor?

Install Bun, run `bun setup`, which also installs MCP into Cursor's active project, then start the bridge with `bun socket`. The manual MCP configuration in `~/.cursor/mcp.json` calls `bunx` with the argument `cursor-talk-to-figma-mcp@latest`.

Official sources

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

If you maintain this project, the badge below links readers to this analysis and shows its maintenance status from the daily GitHub snapshot. Paste the markdown into your README; add ?metric=license or ?metric=stars to the image URL for a different field.

Add this badge to your README

markdown
[![Hysen Labs](https://hysenlabs.com/badge/grab-cursor-talk-to-figma-mcp.svg)](https://hysenlabs.com/projects/grab-cursor-talk-to-figma-mcp)

Star history chart for your README

markdown
[![Star history](https://hysenlabs.com/chart/grab-cursor-talk-to-figma-mcp.svg)](https://hysenlabs.com/projects/grab-cursor-talk-to-figma-mcp)

Was this useful?