Skip to content
Back to search

figma-mcp-bridge

Figma Plugin & MCP server to bypass API limits

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today

Check it deeper on your machine

It has changed since its scan on 11 Nov 2026.

As a Claude Code plugin, install it and then ask Claude Code:

/plugin marketplace add keithmackay/mackayi/plugin install scanskillsafety@mackayiDo a deep scan of https://github.com/gethopp/figma-mcp-bridge with scanskillsafety

Or from a terminal, clone it and run it:

git clone https://github.com/keithmackay/scanskillsafety-skill ~/.claude/skills/scanskillsafetynode ~/.claude/skills/scanskillsafety/cli.cjs --deep 'https://github.com/gethopp/figma-mcp-bridge'

It checks the exact commit: every file, its packages against OSV (api.osv.dev), how it compares with this page's scan (findsafeskills.com receives the repository's address), and, if you agree, Claude reading every file with your own Claude subscription. It never runs the code.

Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/gethopp--figma-mcp-bridge/badge.svg)](/listings/gethopp--figma-mcp-bridge)

HTML

<a href="/listings/gethopp--figma-mcp-bridge"><img src="/api/listings/gethopp--figma-mcp-bridge/badge.svg" alt="findsafeskills safety rating" /></a>

Install

i

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

1. Add the MCP server to your favourite AI tool

Add the following to your AI tool's MCP configuration (e.g. Cursor, Windsurf, Claude Desktop):

{
  "figma-bridge": {
    "command": "npx",
    "args": ["-y", "@gethopp/figma-mcp-bridge"]
  }
}

That's it — no binaries to download or install.

2. Add the Figma plugin

Download the plugin from the [latest release](https://github.com/gethopp/figma-mcp-bridge/releases) page, then in Figma go to `Plugins > Development > Import plugin from manifest` and select the `manifest.json` file from the `plugin/` folder. The same plugin runs in Figma design files, Dev Mode (read-only), and FigJam boards.

3. Start using it 🎉

Open a Figma file, run the plugin, and start prompting your AI tool. The MCP server will automatically connect to the plugin.

To work across multiple files, just open the plugin in each Figma file. The bridge keeps all connections active and your AI agent can target any of them by `fileKey`.

If you want to know more about how it works, read the [How it works](#how-it-works) section.

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

README.md · README · 312 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

This file has changed since it was scanned, so this is not exactly the text that was scanned, and no line is marked. The findings are listed with the safety scan above.

  1. # Figma MCP Bridge
  2. [![Pairing with Hopp](https://gethopp.app/git/hopp-shield.svg?ref=hopp-repo)](https://gethopp.app)
  3. - [Demo](#demo)
  4. - [Quick Start](#quick-start)
  5. - [Available Tools](#available-tools)
  6. - [Local development](#local-development)
  7. - [Structure](#structure)
  8. - [How it works](#how-it-works)
  9. <br/>
  10. <img src="https://raw.githubusercontent.com/gethopp/figma-mcp-bridge/main/logo.png" alt="Figma MCP Bridge" align="center" />
  11. <br/>
  12. > [!NOTE]
  13. > Requires the Figma desktop app (macOS/Windows). The browser version of Figma does not support importing development plugins.
  14. While other amazing Figma MCP servers like [Figma-Context-MCP](https://github.com/GLips/Figma-Context-MCP/) exist, one issues is the [API limiting](https://github.com/GLips/Figma-Context-MCP/issues/258) for free users.
  15. The limit for free accounts is 6 requests per month, yes **per month**.
  16. Figma MCP Bridge is a solution to this problem. It is a plugin + MCP server that streams live Figma document data to AI tools without hitting Figma API rate limits, so its Figma MCP for the rest of us ✊
  17. It supports **multiple Figma files connected simultaneously**; open the plugin in each file and your AI agent can query any of them by `fileKey`. Single-file setups work exactly as before with no changes required.
  18. It also includes a small, opt-in set of **write tools** for safe agent-driven edits — see [Editing Notes](#editing-notes) below.
  19. ## Demo
  20. [Watch a demo of building a UI in Cursor with Figma MCP Bridge](https://youtu.be/ouygIhFBx0g)
  21. [![Watch the video](https://img.youtube.com/vi/ouygIhFBx0g/maxresdefault.jpg)](https://youtu.be/ouygIhFBx0g)
  22. ## Quick Start
  23. ### 1. Add the MCP server to your favourite AI tool
  24. Add the following to your AI tool's MCP configuration (e.g. Cursor, Windsurf, Claude Desktop):
  25. ```json
  26. {
  27. "figma-bridge": {
  28. "command": "npx",
  29. "args": ["-y", "@gethopp/figma-mcp-bridge"]
  30. }
  31. }
  32. ```
  33. That's it — no binaries to download or install.
  34. ### 2. Add the Figma plugin
  35. Download the plugin from the [latest release](https://github.com/gethopp/figma-mcp-bridge/releases) page, then in Figma go to `Plugins > Development > Import plugin from manifest` and select the `manifest.json` file from the `plugin/` folder. The same plugin runs in Figma design files, Dev Mode (read-only), and FigJam boards.
  36. ### 3. Start using it 🎉
  37. Open a Figma file, run the plugin, and start prompting your AI tool. The MCP server will automatically connect to the plugin.
  38. To work across multiple files, just open the plugin in each Figma file. The bridge keeps all connections active and your AI agent can target any of them by `fileKey`.
  39. If you want to know more about how it works, read the [How it works](#how-it-works) section.
  40. ## Available Tools
  41. | Tool | Description |
  42. | ------------------------------ | -------------------------------------------------------------------------------------------------------- |
  43. | `list_files` | List all connected Figma files (supports multi-file workflows) |
  44. | `get_document` | Get the current Figma page document tree |
  45. | `get_selection` | Get the currently selected nodes in Figma |
  46. | `get_node` | Get a specific Figma node by ID (colon format, e.g. `4029:12345`) |
  47. | `get_prototype_connections` | Read prototype interactions on a node and its descendants |
  48. | `trace_prototype_flow` | Trace prototype navigation between screens |
  49. | `get_styles` | Get all local paint, text, effect, and grid styles |
  50. | `get_metadata` | Get file name, pages, and current page info |
  51. | `get_design_context` | Get a depth-limited tree optimized for understanding design context |
  52. | `get_variable_defs` | Get all variable collections, modes, and values (design tokens) |
  53. | `get_screenshot` | Export nodes as PNG/SVG/JPG/PDF (base64-encoded) |
  54. | `save_screenshots` | Export and save screenshots directly to the local filesystem |
  55. | `get_motion_styles` | List all available animation presets (beta) |
  56. | `get_node_motion` | Read a node's current animation styles and properties (beta) |
  57. | `apply_animation_style` | Apply a preset animation style to a node (beta) |
  58. | `remove_animation_style` | Remove an applied animation style from a node (beta) |
  59. | `apply_manual_keyframe_track` | Apply a manual keyframe track to a node property (beta) |
  60. | `remove_manual_keyframe_track` | Remove a manual keyframe track from a node property (beta) |
  61. | `set_timeline_duration` | Set the duration of a timeline in seconds (beta) |
  62. | `set_node_visibility` | Show or hide specific nodes |
  63. | `set_text_content` | Replace the contents of a text node (TEXT, FigJam sticky, or shape label) |
  64. | `set_text_properties` | Patch font, size, alignment, auto-resize, color, and bounds on text nodes/sublayers |
  65. | `set_node_properties` | Patch common node properties: name, position, size, visibility, opacity, corner radius (single or batch) |
  66. | `set_node_constraints` | Set native Figma constraints (horizontal/vertical) for one or multiple compatible nodes |
  67. | `apply_paint_style` | Link local Figma Paint Styles to fills or strokes (single or batch), preserving the native style ID |
  68. | `set_solid_fill` | Replace a node's fill or stroke with a single solid paint |
  69. | `set_gradient_fill` | Replace a node's fill or stroke with a linear/radial/angular/diamond gradient |
  70. | `set_effects` | Replace a node's effects list (drop/inner shadows, layer/background blurs) |
  71. | `set_stroke_properties` | Patch stroke weight, align, dash pattern, cap, and join |
  72. | `set_auto_layout` | Configure auto-layout direction, padding, gap, alignment, sizing, and wrap (not sections) |
  73. | `create_page` | Create a new page in the document, optionally switching to it |
  74. | `create_frame` | Create a new frame, optionally under a parent |
  75. | `create_section` | Create a section — a named, resizable container (Figma and FigJam) |
  76. | `create_text` | Create a new text node |
  77. | `create_shape` | Create a rectangle, ellipse, or line |
  78. | `create_shape_with_text` | Create a FigJam shape with its own text label (SHAPE_WITH_TEXT), incl. text fill |
  79. | `create_image` | Create an image-backed rectangle from a local path, URL, or data URI |
  80. | `create_svg` | Import raw SVG markup or a workspace-local SVG file as editable vector layers |
  81. | `create_sticky` | Create a sticky note in FigJam |
  82. | `create_connector` | Create a connector between two nodes in FigJam, with attachment anchors |
  83. | `import_html_layers` | Bulk-import an html-figma layer tree (JSON) as frames, text, rectangles, and vectors |
  84. | `duplicate_nodes` | Duplicate nodes in place |
  85. | `duplicate_with_offset` | Duplicate nodes and move each duplicate by a fixed offset |
  86. | `fit_to_content` | Resize a SECTION around its children with optional padding |
  87. | `distribute_horizontally` | Space 3+ nodes with equal horizontal gaps (first/last stay fixed) |
  88. | `distribute_vertically` | Space 3+ nodes with equal vertical gaps (first/last stay fixed) |
  89. | `align_to_grid` | Snap node positions to a grid of the given size |
  90. | `place_below` | Move a node below another with gap and start/center alignment |
  91. | `place_right_of` | Move a node to the right of another with gap and start/center alignment |
  92. | `reparent_nodes` | Move nodes into another parent |
  93. | `group_nodes` | Wrap a list of nodes (sharing a parent) in a new group |
  94. | `ungroup_node` | Ungroup a group or frame — children move up to its parent |
  95. | `set_selection` | Set the page selection to a list of node IDs (works in Dev Mode) |
  96. | `scroll_and_zoom_into_view` | Frame the viewport around the given nodes (works in Dev Mode) |
  97. | `delete_nodes` | Delete nodes with explicit confirmation |
  98. | `run_script` | Run Plugin API JavaScript in the plugin sandbox (opt-in, see Editing Notes) |
  99. All tools accept an optional `fileKey` parameter when multiple Figma files are connected. Use `list_files` to discover connected files and their keys.
  100. ### Prototype Notes
  101. - Prototype tools are read-only and unavailable in FigJam. Set `includePrototype: true` on `get_node` to include the same interactions.
  102. - Reactions are Figma's own trigger and action data, with destinations, variables, and modes resolved to names.
  103. - Flow edges list their enclosing branch `conditions` from outermost to innermost (`null` marks an else branch).
  104. - Observed `AFTER_TIMEOUT` values are in seconds (for example, `0.8` for 800 ms).
  105. ### Editing Notes
  106. - Edit tools work only when the plugin is opened in Figma's design editor (Dev Mode is read-only — they will return a clear error there).
  107. - In **FigJam**, read tools plus the write tools (`set_text_content`, `set_text_properties`, `set_node_properties`, `set_solid_fill`, `create_text`, `create_shape`, `create_shape_with_text`, `create_sticky`, `create_connector`, `create_section`, `duplicate_nodes`, `duplicate_with_offset`, `fit_to_content`, `distribute_horizontally`, `distribute_vertically`, `align_to_grid`, `place_below`, `place_right_of`, `delete_nodes`, ...) are available. Auto-layout and motion/animation tools return a clear error in FigJam.
  108. - `set_text_content` / `set_text_properties` edit a TEXT node's content directly, or the text sublayer of a FigJam STICKY / SHAPE_WITH_TEXT node. Alignment and auto-resize are TEXT-node-only — they return a clear error on stickies and shapes (x/y/width/height still apply to the containing node).
  109. - `set_node_properties` accepts either `nodeId` or a `nodeIds` array to apply the same property changes to several nodes in one call.
  110. - `apply_paint_style` accepts `nodeId` or `nodeIds`, a local `styleId` from `get_styles`, and `target` (`fill` default, or `stroke`). It works in Figma Design only, applies the native style (replacing paints on the selected target), and reports the linked ID; a batch reports successes and per-node errors. `get_node` exposes `styles.fillStyleId` and `styles.strokeStyleId` for independent verification (an empty ID means unlinked; `mixed` means the property has mixed values across the node). It does not import shared libraries or style individual text ranges.
  111. - `set_node_constraints` accepts `nodeId` or `nodeIds` with `horizontal` and/or `vertical` (`MIN`, `MAX`, `CENTER`, `STRETCH`, `SCALE`). `MIN` means Left/Top, `MAX` Right/Bottom, and `STRETCH` Left & Right/Top & Bottom. Unspecified axes are preserved. It requires nodes inside a Figma frame, component, or instance; Auto Layout children must use absolute positioning. It is unavailable in FigJam and Dev Mode. The response reports previous and applied constraints.
  112. - `set_auto_layout` targets frames; SECTION nodes have no auto-layout in Figma's API and return an explicit error.
  113. - `fit_to_content` works on SECTION nodes only (Figma's API exposes no equivalent for other containers): it shifts children so their bounding box starts at `padding` and resizes the section to bbox + 2×padding.
  114. - The current user must have permission to edit the target file.
  115. - `delete_nodes` is intentionally gated behind `confirm: true`.
  116. - `run_script` executes arbitrary JavaScript in the open file, so it is off unless the MCP server runs with `FIGMA_BRIDGE_ENABLE_RUN_SCRIPT=1` (see [Enabling `run_script`](#enabling-run_script)). The code is the body of an async function with `figma` in scope, and its `return` value must be JSON-serializable. Code that calls `.remove()` is rejected unless `allowRemove: true` is passed; this guards against accidental deletions and is not a security boundary. The server stops waiting after 3 minutes, but a script stuck in a loop keeps the plugin busy until it is closed. Works in Figma and FigJam.
  117. - Text edits automatically load the fonts currently used by the target text node before applying the new content.
  118. - New text nodes default to `Inter Regular` unless a font is provided.
  119. - `create_image` reads local paths relative to the MCP server working directory unless you pass an absolute path.
  120. - `create_svg` accepts raw `<svg>` markup or a local SVG path inside the MCP server working directory. SVG payloads are limited to 2 MiB.
  121. - `import_html_layers` takes a JSON file produced by [html-figma](https://github.com/sergcen/html-to-figma)'s browser `htmlToFigma()`. The path resolves relative to the MCP server working directory and must stay inside it, even when absolute. Everything lands inside one wrapper frame, and the response reports `layerCount` against `expectedLayerCount` so partial imports are visible.
  122. - `create_page` returns the new page's ID — pass it as `parentId` to `create_frame` / `create_text` / `create_shape` / `create_image` to author content on that page without switching the editor.
  123. ### Enabling `run_script`
  124. `run_script` is off by default. To turn it on, add `FIGMA_BRIDGE_ENABLE_RUN_SCRIPT` to the server's `env` in your MCP configuration and restart your AI tool:
  125. ```json
  126. {
  127. "figma-bridge": {
  128. "command": "npx",
  129. "args": ["-y", "@gethopp/figma-mcp-bridge"],
  130. "env": {
  131. "FIGMA_BRIDGE_ENABLE_RUN_SCRIPT": "1"
  132. }
  133. }
  134. }
  135. ```
  136. If several AI tools run the bridge at the same time, set the variable in each of their configurations. Only one bridge process talks to Figma at a time, and it rejects `run_script` unless it was started with the variable.
  137. ### What You Can Build
  138. With the current write surface, an agent can build a basic slide deck in a new empty Figma file: create slide frames, style titles and body copy, lay out rectangles/ellipses/lines for cards and dividers, duplicate slide templates, reparent content into the right frame, and adjust common geometry/visual properties — including solid/gradient paints, shadows and blurs, stroke geometry, and auto-layout configuration.
  139. The current version is intentionally limited — no components/instances, no variables/styles authoring, no per-segment text styling, and no vector boolean operations yet.
  140. ## Local development
  141. This repo uses [Bun](https://bun.sh) as its package manager and script runner throughout. Install it first if you don't have it.
  142. #### 1. Clone this repository locally
  143. ```bash
  144. git clone git@github.com:gethopp/figma-mcp-bridge.git
  145. ```
  146. #### 2. Install root tooling
  147. Install the root dependencies once. This runs Husky's `prepare` script, which installs the Git pre-commit hook that formats staged files with Prettier.
  148. ```bash
  149. cd figma-mcp-bridge && bun install
  150. ```
  151. #### 3. Build the server
  152. ```bash
  153. cd server && bun install && bun run build
  154. ```
  155. #### 4. Build the plugin
  156. ```bash
  157. cd plugin && bun install && bun run build
  158. ```
  159. #### 5. Add the MCP server to your favourite AI tool
  160. For local development, add the following to your AI tool's MCP config:
  161. ```json
  162. {
  163. "figma-bridge": {
  164. "command": "node",
  165. "args": ["/path/to/figma-mcp-bridge/server/dist/index.js"]
  166. }
  167. }
  168. ```
  169. ### Code style
  170. The repo is formatted with [Prettier](https://prettier.io) (config in `.prettierrc`). A Husky pre-commit hook runs `lint-staged`, which formats only your staged files, so commits stay formatted automatically. You can also run it manually:
  171. ```bash
  172. bun run format # format the whole repo
  173. bun run format:check # verify formatting without writing (useful in CI)
  174. ```
  175. ## Structure
  176. ```
  177. Figma-MCP-Bridge/
  178. ├── plugin/ # Figma plugin (TypeScript/React)
  179. └── server/ # MCP server (TypeScript/Node.js)
  180. └── src/
  181. ├── index.ts # Entry point
  182. ├── bridge.ts # WebSocket bridge to Figma plugin
  183. ├── leader.ts # Leader: HTTP server + bridge
  184. ├── follower.ts # Follower: proxies to leader via HTTP
  185. ├── node.ts # Dynamic leader/follower role switching
  186. ├── election.ts # Leader election & health monitoring
  187. ├── tools.ts # MCP tool definitions
  188. └── types.ts # Shared types
  189. ```
  190. ## How it works
  191. There are two main components to the Figma MCP Bridge:
  192. ### 1. The Figma Plugin
  193. The Figma plugin is the user interface for the Figma MCP Bridge. You run this inside the Figma file you want to use the MCP server for, and its responsible for getting you all the information you need.
  194. ### 2. The MCP Server
  195. The MCP server is the core of the Figma MCP Bridge. It maintains a registry of WebSocket connections keyed by `fileKey`, so multiple Figma files can be connected simultaneously. The server is responsible for:
  196. - Handling WebSocket connections from one or more Figma plugin instances
  197. - Routing tool calls to the correct file based on `fileKey`
  198. - Forwarding responses back to the AI client
  199. - Handling leader election (as we can have only one WS connection to an MCP server at a time)
  200. The leader listens on `127.0.0.1` only. Its endpoints have no authentication, so other machines on the network must not reach them. If the plugin runs on another host (for example, the MCP server runs in a VM or a container), set `FIGMA_BRIDGE_HOST=0.0.0.0` (or `::`) in the MCP server environment. Use this only on a network that you trust.
  201. ```
  202. ┌─────────────────────────────────────────────────────────────────────────────┐
  203. │ FIGMA (Desktop app) │
  204. │ ┌───────────────────────────────────────────────────────────────────────┐ │
  205. │ │ Figma Plugin │ │
  206. │ │ (TypeScript/React) │ │
  207. │ └───────────────────────────────────────────────────────────────────────┘ │
  208. └─────────────────────────────────────────────────────────────────────────────┘
  209. │
  210. │ WebSocket
  211. │ (ws://localhost:1994/ws)
  212. ▼
  213. ┌─────────────────────────────────────────────────────────────────────────────┐
  214. │ PRIMARY MCP SERVER │
  215. │ (Leader on :1994) │
  216. │ ┌─────────────────────────────────────────────────────────────────────┐ │
  217. │ │ Bridge Endpoints: │ │
  218. │ │ • Manages WebSocket conn • /ws (plugin) │ │
  219. │ │ • Forwards requests to plugin • /ping (health) │ │
  220. │ │ • Routes responses back • /rpc (followers) │ │
  221. │ └─────────────────────────────────────────────────────────────────────┘ │
  222. └─────────────────────────────────────────────────────────────────────────────┘
  223. ▲ ▲
  224. │ HTTP /rpc │ HTTP /rpc
  225. │ POST requests │ POST requests
  226. │ │
  227. ┌─────────────────┴───────────┐ ┌─────────────┴───────────────┐
  228. │ FOLLOWER MCP SERVER 1 │ │ FOLLOWER MCP SERVER 2 │
  229. │ │ │ │
  230. │ • Pings leader /ping │ │ • Pings leader /ping │
  231. │ • Forwards tool calls │ │ • Forwards tool calls │
  232. │ via HTTP /rpc │ │ via HTTP /rpc │
  233. │ • If leader dies → │ │ • If leader dies → │
  234. │ attempts takeover │ │ attempts takeover │
  235. └─────────────────────────────┘ └─────────────────────────────┘
  236. ▲ ▲
  237. │ │
  238. │ MCP Protocol │ MCP Protocol
  239. │ (stdio) │ (stdio)
  240. ▼ ▼
  241. ┌─────────────────────────────┐ ┌─────────────────────────────┐
  242. │ AI Tool / IDE 1 │ │ AI Tool / IDE 2 │
  243. │ (e.g., Cursor) │ │ (e.g., Cursor) │
  244. └─────────────────────────────┘ └─────────────────────────────┘
  245. ```

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.