← Back to directory

TalkToFigma

Community

Connect AI agents to Figma for programmatic design work through MCP.

GitHub source repository ↗

★ 6.9k Stars Category · Collaboration Very popular

47FMRS · D

Reliability

8/20

Security and permissions

7/20

Maintenance

10/20

Documentation

11/20

Setup experience

11/20

An MIT-licensed community MCP project that connects an AI agent to Figma through an MCP server, Figma plugin, and WebSocket server. The README documents extensive read, create, modify, batch, annotation, component, connection, and export tools. Users should prepare Bun, the Figma plugin, and the local WebSocket service, and carefully review destructive or batch changes.

Read the FMRS scoring method →

TalkToFigma is an open-source MCP integration maintained by grab that connects AI agents with Figma to read designs and modify them programmatically. It includes a TypeScript MCP server, a Figma plugin, and a WebSocket server for communication between them.

Tools

get_document_info

Get information about the current Figma document

get_selection

Get information about the current selection

read_my_design

Get detailed node information about the current selection without parameters

get_node_info

Get detailed information about a specific node

get_nodes_info

Get detailed information about multiple nodes

set_focus

Select a node and scroll the viewport to it

set_selections

Select multiple nodes and scroll the viewport to show them

get_annotations

Get all annotations in the current document or a specific node

set_annotation

Create or update a Markdown-capable annotation

set_multiple_annotations

Batch create or update annotations

scan_nodes_by_types

Scan for nodes by type

get_reactions

Get prototype reactions with visual highlight animation

set_default_connector

Set the default FigJam connector style for creating connections

create_connections

Create FigJam connector lines from prototype flows or custom mappings

create_rectangle

Create a rectangle

create_frame

Create a frame

create_text

Create a text node with customizable font properties

scan_text_nodes

Scan text nodes with intelligent chunking for large designs

set_text_content

Set the content of a single text node

set_multiple_text_contents

Batch update multiple text nodes

set_layout_mode

Set a frame's layout mode and wrap behavior

set_padding

Set padding on an auto-layout frame

set_axis_align

Set primary- and counter-axis alignment on an auto-layout frame

set_layout_sizing

Set horizontal and vertical sizing modes on an auto-layout frame

set_item_spacing

Set spacing between children in an auto-layout frame

set_fill_color

Set a node's fill color

set_stroke_color

Set a node's stroke color and weight

set_corner_radius

Set a node's corner radius with optional per-corner control

move_node

Move a node

resize_node

Resize a node

delete_node

Delete a node

delete_multiple_nodes

Batch delete nodes

clone_node

Clone a node with an optional position offset

get_styles

Get information about local styles

get_local_components

Get information about local components

create_component_instance

Create a component instance

get_instance_overrides

Extract override properties from a selected component instance

set_instance_overrides

Apply extracted overrides to target instances

export_node_as_image

Export a node as PNG, JPG, SVG, or PDF; image support is limited and currently returns base64 as text

join_channel

Join a channel for communicating with Figma

Setup

Install Bun. Run bun setup to complete setup and install MCP in Cursor's active project. Run bun socket to start the WebSocket server. Install the plugin from the Figma Community page, or use Figma's Plugins > Development > New Plugin > Link existing plugin flow and select src/cursor_mcp_plugin/manifest.json. Open the plugin and join a channel with join_channel.

claude_desktop_config.json

{"mcpServers":{"TalkToFigma":{"command":"bunx","args":["cursor-talk-to-figma-mcp@latest"]}}}

Generate and validate client config

Fit and risk

Best for

Design and development teams using Cursor, Claude Code, or Codex to drive Figma with natural language
Figma workflows requiring batch text, layout, annotation, or component-instance operations
Users able to run Bun, a WebSocket server, and a Figma plugin

Not for

Static file-reading workflows that do not run the Figma plugin
Read-only review workflows where AI must not modify the Figma document
Workflows requiring explicitly documented remote hosting, authentication, or another transport

Required permissions

Requires running the companion development plugin in Figma
Requires local WebSocket communication between the MCP server and the Figma plugin
Modification tools require corresponding read/write access to the current Figma document; the exact scope depends on the tool used

Risks and side effects

delete_node and delete_multiple_nodes remove nodes, so targets should be confirmed and results verified
Batch text, layout, styling, and instance-override operations can affect multiple design elements
Incorrect WebSocket channel connections can prevent communication with Figma
Node image export has limited support and returns base64 as text

Troubleshooting

Confirm Bun is installed and run bun setup first
Confirm the WebSocket server is running with bun socket
Confirm the Figma plugin is installed, open, and joined to the correct channel
Check that the Cursor MCP configuration uses bunx and the expected package or local server path
For Windows + WSL, check the README guidance for enabling hostname 0.0.0.0 in src/socket.ts
For large designs, use scan_text_nodes chunking parameters and monitor WebSocket updates

Use cases

Read current Figma document, selection, and node information

Replace text content in bulk

Create and modify frames, rectangles, text, and layout properties

Manage annotations, component instance overrides, and prototype connections

Export nodes as image files

Supported clients

CursorFull support

Claude CodePartial support

CodexPartial support

Related MCP servers

Compare with other MCP servers