Talk to Figma MCP
Connect an MCP-capable coding assistant to Figma for design inspection and programmatic edits.
Per-dimension scores and reasoning
Evidence: MCP server communicates with Figma plugin via WebSocket, requiring manual channel join, but no explicit least-privilege design or user confirmation mechanism found. Data flow transparency limited; README describes communication flow but not detailed data paths. Sensitive data handling not mentioned; dependencies not pinned (uuid, ws use latest), supply chain risk. External effects include modifying Figma documents, no rollback. Source attribution: MIT license and GitHub user sonnylazuardi, but publisher unverified. Deductions: lack of least privilege, user confirmation, data flow transparency, sensitive data handling, dependency security, external effects control, rollback, and source verification.
Evidence: README and code structure consistent, tool list clear, but no tests or error handling details. Dependencies like @modelcontextprotocol/sdk pinned, but others use latest, availability risk. Failure messages not detailed, only mention all commands can throw exceptions. Deductions: dependency availability not guaranteed, failure messages insufficient.
Evidence: Targets AI agents like Cursor, Claude Code, provides multiple use cases and best practices. Capability boundaries listed in README but not explicit limits. Trigger precision via tool names and descriptions, but no detailed parameter docs. Environment fit includes Windows WSL guide, but not all platforms. Deductions: capability boundaries and trigger precision not detailed enough.
Evidence: README structure clear, install notes detailed, tool naming consistent, examples and best practices provided. Known limitations not explicitly listed, version exists but no changelog. License MIT, maintenance responsibility unclear. Deductions: missing known limitations, changelog, and maintenance responsibility.
Evidence: Outputs are Figma operation results, high usability, batch operations and automation features, clear marginal value. Cost-benefit not quantified, but installation and use simple. Deductions: cost-benefit not quantified.
Evidence: README claims consistent with code structure, but no tests or independent verification. Cross-source corroboration insufficient, facts and inferences not clearly separated. Deductions: lack of tests and independent verification.
- Dependencies not pinned, supply chain risk.
- No user confirmation mechanism, AI agent may directly modify Figma documents.
- No rollback mechanism, mistakes may be unrecoverable.
- Publisher identity unverified, use with caution.
What does this agent do, and when should you use it?
Talk to Figma MCP is an MCP integration between AI coding assistants and Figma. It consists of a TypeScript MCP server, a Figma plugin, and a WebSocket server that relays communication between them. Through its MCP tools, an assistant can inspect documents, selections, and nodes, then create, edit, organize, or export Figma nodes. The Figma plugin must join a WebSocket channel before the MCP server can send commands to the open Figma session. The repository provides detailed Cursor setup and names Claude Code and Codex as integration targets, but does not document configuration steps for the latter two.
After bun socket starts the communication layer in src/socket.ts, the Figma plugin in src/cursor_mcp_plugin/ connects through join_channel. The MCP server reads designs with get_document_info, get_selection, read_my_design, get_node_info, and get_nodes_info; it creates nodes with create_rectangle, create_frame, create_section, and create_text. It also exposes editing operations including set_text_content, set_multiple_text_contents, set_fill_color, set_layout_mode, move_node, resize_node, delete_node, clone_node, and set_parent. Additional tools cover annotations, component-instance overrides, converting prototype reactions into FigJam connectors, and exporting nodes as PNG, JPG, SVG, or PDF.
- A designer using Cursor with an open Figma file needs to replace copy across many text nodes.
- A design-system team needs to extract overrides from one component instance and apply them to several target instances.
- A frontend developer needs the structure of the current selection or a named Figma node before implementing an interface.
- A content operations user needs to scan a large design in chunks and batch-update its text content.
- A designer wants to turn Figma prototype flows into visible FigJam connector lines after retrieving reactions.
What are this agent's strengths and limitations?
- It supports both inspection and direct node operations: creating, moving, resizing, renaming, deleting, and reparenting Figma content.
- Batch text updates, batch annotations, and batch deletion address repetitive design-maintenance work.
- It includes component-instance override propagation and a path from prototype reactions to FigJam connectors.
- Its MCP server, Figma plugin, and WebSocket server form an explicit, separated communication architecture.
- The workflow depends on Figma, its plugin, and a WebSocket channel, so it is not a standalone general-purpose design automation tool.
- Cursor has documented setup, while Claude Code and Codex are named targets without corresponding configuration instructions.
- It requires Bun, shell usage, and a locally running WebSocket service, adding desktop setup overhead.
- Image export is documented as having limited support and currently returns base64 as text.
- Windows with WSL requires changing the hostname setting in
src/socket.ts.
How do you install or deploy this agent?
Install Bun with curl -fsSL https://bun.sh/install | bash. From the repository, run bun setup; this installs the MCP server into Cursor's active project, then start the WebSocket server with bun socket. Install the Figma Community plugin, or in Figma choose Plugins > Development > New Plugin > Link existing plugin and select src/cursor_mcp_plugin/manifest.json. The documented Cursor MCP configuration is {"mcpServers":{"TalkToFigma":{"command":"bunx","args":["cursor-talk-to-figma-mcp@latest"]}}}. The supplied documentation does not identify an API key or other credential requirement.
How do you use this agent?
Run bun socket, enable the TalkToFigma MCP server in Cursor, open a Figma file, and run the Cursor MCP Plugin. Call join_channel so the plugin connects to the WebSocket server, then use get_document_info and get_selection to establish context. Invoke the relevant read or edit tools—for example, scan with scan_text_nodes, update with set_multiple_text_contents, and verify with get_node_info. Large-design scans support chunking parameters, and callers need to handle exceptions because commands can throw errors.
How does this agent compare with similar options?
Cursor is the only client with a complete documented installation and MCP configuration path. Claude Code and Codex are named as integration targets, but the supplied usage instructions do not describe their configuration differences.
FAQ
Does it require an API key?
Can I use only the MCP server without the Figma plugin?
join_channel for MCP tools to communicate with Figma.What can it modify in Figma?
Is image export ready for direct downstream use?
export_node_as_image as limited support and says images currently return as base64 text.