Skip to content
Back to search

figma

Plugin that includes the Figma MCP server and Skills for common workflows

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 17 Nov 2026. Its scripts were only partly scanned.

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/figma/mcp-server-guide 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/figma/mcp-server-guide'

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/figma-mcp-server-guide/badge.svg)](/listings/figma-mcp-server-guide)

HTML

<a href="/listings/figma-mcp-server-guide"><img src="/api/listings/figma-mcp-server-guide/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.

Connect to the Figma MCP server

Different MCP clients require slightly different setups. Follow the instructions below for your specific client to connect to the Figma MCP server.

VS Code

1. Use the shortcut `⌘ Shift P` to search for `MCP:Add Server`. 2. Select `HTTP`. 3. Paste the server url `https://mcp.figma.com/mcp` in the search bar. Then hit `Enter`. 4. When you're prompted for a server ID, enter `figma`. 5. Select whether you want to add this server globally or only for the current workspace. Once confirmed, you'll see a configuration like this in your `mcp.json` file:

{
  "servers": {
    "figma": {
      "type": "http",
      "url": "https://mcp.figma.com/mcp"
    }
  }
}

6. Open the chat toolbar using `⌥⌘B` or `⌃⌘I` and switch to **Agent** mode. 7. With the chat open, type in `#get_design_context` to confirm that the Figma MCP server tools are available. If no tools are listed, restart VS Code.

> [!NOTE] > You must have [GitHub Copilot](https://github.com/features/copilot) enabled on your account to use MCP in VS Code. > > For more information, see [VS Code's official documentation](https://code.visualstudio.com/docs/copilot/chat/mcp-servers).

Cursor

The recommended way to set up the Figma MCP server in Cursor is by installing the Figma Plugin, which includes MCP server settings as well as Agent Skills for common workflows.

Install the plugin by typing the following command in Cursor's agent chat:

/add-plugin figma

The plugin includes:

- MCP server configuration for the Figma MCP server - Skills for implementing designs, connecting components via Code Connect, and creating design system rules - Rules for proper asset handling from the Figma MCP server

<details> <summary>Manual setup</summary>

1. Open **Cursor → Settings → Cursor Settings**. 2. Go to the **MCP** tab. 3. Click **+ Add new global MCP server**. 4. Enter the following configuration and save:

{
  "mcpServers": {
    "figma": {
      "url": "https://mcp.figma.com/mcp"
    }
  }
}

For more information, see [Cursor's official documentation](https://docs.cursor.com/context/model-context-protocol).

</details>

Claude Code

The recommended way to set up the Figma MCP server in Claude Code is by installing the Figma Plugin, which includes MCP server settings as well as Agent Skills for common workflows.

Run the following command to install the plugin from Anthropic's official plugin marketplace.

claude plugin install figma@claude-plugins-official

Learn more about Anthropic's [Claude Code Plugins](https://claude.com/blog/claude-code-plugins) and [Agent Skills](https://claude.com/blog/skills).

<details> <summary>Manual setup</summary>

1. Open your terminal and run:

claude mcp add --transport http figma https://mcp.figma.com/mcp

2. Use the following commands to check MCP settings and manage servers:

- List all configured servers

  claude mcp list

- Get details for a specific server

  claude mcp get my-server

- Remove a server

  claude mcp remove my-server

For more information, see [Anthropic's official documentation](https://docs.anthropic.com/en/docs/agents-and-tools/claude-code/tutorials#set-up-model-context-protocol-mcp).

</details>

Gemini CLI

Install the Figma extension for Gemini CLI by running the following command:

gemini extensions install https://github.com/figma/mcp-server-guide

Once installed, authenticate with Figma by running `gemini` and then executing the following command within the CLI:

/mcp auth figma

To uninstall the extension:

gemini extensions uninstall figma

Other editors

Other code editors and tools that support Streamable HTTP can also connect to the Figma MCP server.

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.

.claude-plugin/plugin.json · Manifest · 8 lines
  1. {
  2. "name": "figma",
  3. "description": "Plugin that includes the Figma MCP server and Skills for common workflows",
  4. "version": "2.2.211",
  5. "author": {
  6. "name": "Figma"
  7. }
  8. }
README.md · README · 385 lines
  1. # Figma MCP Server Guide
  2. The Figma MCP server brings Figma directly into your workflow by providing important design information and context to AI agents generating code from Figma design files.
  3. > [!NOTE]
  4. > Rate limits apply to Figma MCP server tools that read data from Figma. Some tools, such as those that write to Figma files, are exempt from the rate limits.
  5. > <br><br>
  6. > Users on the Starter plan or with View or Collab seats on paid plans will be limited to up to 6 tool calls per month.
  7. > <br><br>
  8. > Users with a [Dev or Full seat](https://help.figma.com/hc/en-us/articles/27468498501527-Updates-to-Figma-s-pricing-seats-and-billing-experience#h_01JCPBM8X2MBEXTABDM92HWZG4) on the [Professional, Organization, or Enterprise plans](https://help.figma.com/hc/en-us/articles/360040328273-Figma-plans-and-features) have per minute rate limits, which follow the same limits as the Tier 1 [Figma REST API](https://developers.figma.com/docs/rest-api/rate-limits/). As with Figma’s REST API, Figma reserves the right to change rate limits.
  9. For the complete set of Figma MCP server docs, see our [developer documentation](https://developers.figma.com/docs/figma-mcp-server/). By using the Figma MCP server and the related resources (including these skills), you agree to the [Figma Developer Terms](https://www.figma.com/legal/developer-terms/). These skills are currently available as a Beta feature.
  10. ## Features
  11. - **Write to the canvas** (remote server only): Create and modify native Figma content directly from your MCP client. With the right skills, agents can build and update frames, components, variables, and auto layout in your Figma files using your design system as the source of truth.
  12. **Note:** We're quickly improving how Figma supports AI agents. The write to canvas feature will eventually be a usage-based paid feature, but is currently available for free during the beta period.
  13. - **Generate placeholder images**: When source, captured, or library images are unavailable, agents can use `generate_image` after asking permission and disclosing Figma AI credit usage. Generated images are uploaded with `upload_assets` and applied to the design.
  14. - **Generate code from selected frames**
  15. Select a Figma frame and turn it into code. Great for product teams building new flows or iterating on app features.
  16. - **Extract design context**
  17. Pull in variables, components, and layout data directly into your IDE. This is especially useful for design systems and component-based workflows.
  18. - **Code smarter with Code Connect**
  19. Boost output quality by reusing your actual components. Code Connect keeps your generated code consistent with your codebase.
  20. [Learn more about Code Connect →](https://help.figma.com/hc/en-us/articles/23920389749655-Code-Connect)
  21. - **Generate Figma designs from web pages** *(rolling out)*
  22. Capture, import, or convert a web page into a Figma design directly from your AI coding agent.
  23. ## Installation & Setup
  24. ### Connect to the Figma MCP server
  25. Different MCP clients require slightly different setups. Follow the instructions below for your specific client to connect to the Figma MCP server.
  26. #### VS Code
  27. 1. Use the shortcut `⌘ Shift P` to search for `MCP:Add Server`.
  28. 2. Select `HTTP`.
  29. 3. Paste the server url `https://mcp.figma.com/mcp` in the search bar. Then hit `Enter`.
  30. 4. When you're prompted for a server ID, enter `figma`.
  31. 5. Select whether you want to add this server globally or only for the current workspace. Once confirmed, you'll see a configuration like this in your `mcp.json` file:
  32. ```json
  33. {
  34. "servers": {
  35. "figma": {
  36. "type": "http",
  37. "url": "https://mcp.figma.com/mcp"
  38. }
  39. }
  40. }
  41. ```
  42. 6. Open the chat toolbar using `⌥⌘B` or `⌃⌘I` and switch to **Agent** mode.
  43. 7. With the chat open, type in `#get_design_context` to confirm that the Figma MCP server tools are available. If no tools are listed, restart VS Code.
  44. > [!NOTE]
  45. > You must have [GitHub Copilot](https://github.com/features/copilot) enabled on your account to use MCP in VS Code.
  46. >
  47. > For more information, see [VS Code's official documentation](https://code.visualstudio.com/docs/copilot/chat/mcp-servers).
  48. #### Cursor
  49. The recommended way to set up the Figma MCP server in Cursor is by installing the Figma Plugin, which includes MCP server settings as well as Agent Skills for common workflows.
  50. Install the plugin by typing the following command in Cursor's agent chat:
  51. ```
  52. /add-plugin figma
  53. ```
  54. The plugin includes:
  55. - MCP server configuration for the Figma MCP server
  56. - Skills for implementing designs, connecting components via Code Connect, and creating design system rules
  57. - Rules for proper asset handling from the Figma MCP server
  58. <details>
  59. <summary>Manual setup</summary>
  60. 1. Open **Cursor → Settings → Cursor Settings**.
  61. 2. Go to the **MCP** tab.
  62. 3. Click **+ Add new global MCP server**.
  63. 4. Enter the following configuration and save:
  64. ```json
  65. {
  66. "mcpServers": {
  67. "figma": {
  68. "url": "https://mcp.figma.com/mcp"
  69. }
  70. }
  71. }
  72. ```
  73. For more information, see [Cursor's official documentation](https://docs.cursor.com/context/model-context-protocol).
  74. </details>
  75. #### Claude Code
  76. The recommended way to set up the Figma MCP server in Claude Code is by installing the Figma Plugin, which includes MCP server settings as well as Agent Skills for common workflows.
  77. Run the following command to install the plugin from Anthropic's official plugin marketplace.
  78. ```bash
  79. claude plugin install figma@claude-plugins-official
  80. ```
  81. Learn more about Anthropic's [Claude Code Plugins](https://claude.com/blog/claude-code-plugins) and [Agent Skills](https://claude.com/blog/skills).
  82. <details>
  83. <summary>Manual setup</summary>
  84. 1. Open your terminal and run:
  85. ```bash
  86. claude mcp add --transport http figma https://mcp.figma.com/mcp
  87. ```
  88. 2. Use the following commands to check MCP settings and manage servers:
  89. - List all configured servers
  90. ```bash
  91. claude mcp list
  92. ```
  93. - Get details for a specific server
  94. ```bash
  95. claude mcp get my-server
  96. ```
  97. - Remove a server
  98. ```bash
  99. claude mcp remove my-server
  100. ```
  101. For more information, see [Anthropic's official documentation](https://docs.anthropic.com/en/docs/agents-and-tools/claude-code/tutorials#set-up-model-context-protocol-mcp).
  102. </details>
  103. #### Gemini CLI
  104. Install the Figma extension for Gemini CLI by running the following command:
  105. ```bash
  106. gemini extensions install https://github.com/figma/mcp-server-guide
  107. ```
  108. Once installed, authenticate with Figma by running `gemini` and then executing the following command within the CLI:
  109. ```
  110. /mcp auth figma
  111. ```
  112. To uninstall the extension:
  113. ```bash
  114. gemini extensions uninstall figma
  115. ```
  116. #### Other editors
  117. Other code editors and tools that support Streamable HTTP can also connect to the Figma MCP server.
  118. If you're using a different editor or tool, check its documentation to confirm it supports Streamable HTTP based communication. If it does, you can manually add the Figma MCP server using this configuration:
  119. ```json
  120. {
  121. "mcpServers": {
  122. "figma": {
  123. "url": "https://mcp.figma.com/mcp"
  124. }
  125. }
  126. }
  127. ```
  128. ## Prompting your MCP client
  129. The Figma MCP server introduces a set of tools that help LLMs translate designs in Figma. Once connected, you can prompt your MCP client to access a specific design node.
  130. To provide Figma design context to your AI client:
  131. 1. Copy the link to a frame or layer in Figma.
  132. 2. Prompt your client to help you implement the design at the selected URL.
  133. <img src="https://help.figma.com/hc/article_attachments/34049303807895" width="300" />
  134. > [!NOTE]
  135. > Your client won't be able to navigate to the selected URL, but it will extract the node-id that is required for the MCP server to identify which object to return information about.
  136. ## Tools and skills
  137. Figma maintains a list of tools provided by the Figma MCP server in the [developer documentation](https://developers.figma.com/docs/figma-mcp-server/tools-and-prompts/).
  138. You can also learn more about the skills included with the Figma plugin for [supported agents](https://help.figma.com/hc/en-us/articles/32132100833559#h_01K25F7RBRZKCATVJHNXCS6KXW) in the [Figma Help Center](https://help.figma.com/hc/en-us/articles/39166810751895). Depending on the agent, you may also see the terms `connector`, `extension`, or `power`; these include the same set of skills.
  139. This repo also contains standalone workflow skills that are not bundled with the Figma plugin:
  140. - [`workflow-skills/video-interaction-mapper`](workflow-skills/video-interaction-mapper): Turns UI recordings into annotated Figma storyboards
  141. - [`workflow-skills/generate-project-plan`](workflow-skills/generate-project-plan): Turn a PRD (plus optional codebase grounding) into a FigJam project plan board
  142. # MCP best practices
  143. The quality of the generated code depends on several factors. Some controlled by you, and some by the tools you're using. Here are some suggestions for clean, consistent output.
  144. ## Structure your Figma file for better code
  145. Provide the best context for your design intent, so the MCP and your AI assistant can generate code that's clear, consistent, and aligned with your system.
  146. - **Use components** for anything reused (buttons, cards, inputs, etc.)
  147. - **Link components to your codebase** via Code Connect. This is the best way to get consistent component reuse in code. Without it, the model is guessing.
  148. - **Use variables** for spacing, color, radius, and typography.
  149. - **Name layers semantically** (e.g. `CardContainer`, not `Group 5`)
  150. - **Use Auto layout** to communicate responsive intent.
  151. > [!TIP]
  152. > Resize the frame in Figma to check that it behaves as expected before generating code.
  153. - **Use annotations and dev resources** to convey design intent that's hard to capture from visuals alone, like how something should behave, align, or respond.
  154. ## Write effective prompts to guide the AI
  155. MCP gives your AI assistant structured Figma data, but your prompt drives the result. Good prompts can:
  156. - Align the result with your framework or styling system
  157. - Follow file structure and naming conventions
  158. - Add code to specific paths (e.g. `src/components/ui`)
  159. - Add or modify code in existing files instead of creating new ones
  160. - Follow specific layout systems (e.g. grid, flexbox, absolute)
  161. **Examples:**
  162. - "Generate iOS SwiftUI code from this frame"
  163. - "Use Chakra UI for this layout"
  164. - "Use `src/components/ui` components"
  165. - "Add this to `src/components/marketing/PricingCard.tsx`"
  166. - "Use our `Stack` layout component"
  167. Think of prompts like a brief to a teammate. Clear intent leads to better results.
  168. ## Trigger specific tools when needed
  169. The MCP supports different tools, and each one provides your AI assistant with a different kind of structured context. Sometimes, the assistant doesn't automatically pick the right one, especially as more tools become available. If results are off, try being explicit in your prompt.
  170. - **get_design_context** provides a structured **React + Tailwind** representation of your Figma selection. This is a starting point that your AI assistant can translate into any framework or code style, depending on your prompt.
  171. - **get_variable_defs** extracts the variables and styles used in your selection (color, spacing, typography, etc). This helps the model reference your tokens directly in the generated code.
  172. For example, if you're getting raw code instead of tokens, try something like:
  173. - "Get the variable names and values used in this frame."
  174. ## Add custom rules
  175. Set project-level guidance to keep output consistent—just like onboarding notes for a new developer. These are things like:
  176. - Preferred layout primitives
  177. - File organization
  178. - Naming patterns
  179. - What not to hardcode
  180. You can provide this in whatever format your MCP client uses for instruction files.
  181. **Examples:**
  182. #### Ensure consistently good output
  183. ```yaml
  184. ## Figma MCP Integration Rules
  185. These rules define how to translate Figma inputs into code for this project and must be followed for every Figma-driven change.
  186. ### Required flow (do not skip)
  187. 1. Run get_design_context first to fetch the structured representation for the exact node(s).
  188. 2. If the response is too large or truncated, run get_metadata to get the high‑level node map and then re‑fetch only the required node(s) with get_design_context.
  189. 3. Run get_screenshot for a visual reference of the node variant being implemented.
  190. 4. Only after you have both get_design_context and get_screenshot, download any assets needed and start implementation.
  191. 5. Translate the output (usually React + Tailwind) into this project's conventions, styles and framework. Reuse the project's color tokens, components, and typography wherever possible.
  192. 6. Validate against Figma for 1:1 look and behavior before marking complete.
  193. ### Implementation rules
  194. - Treat the Figma MCP output (React + Tailwind) as a representation of design and behavior, not as final code style.
  195. - Replace Tailwind utility classes with the project's preferred utilities/design‑system tokens when applicable.
  196. - Reuse existing components (e.g., buttons, inputs, typography, icon wrappers) instead of duplicating functionality.
  197. - Use the project's color system, typography scale, and spacing tokens consistently.
  198. - Respect existing routing, state management, and data‑fetch patterns already adopted in the repo.
  199. - Strive for 1:1 visual parity with the Figma design. When conflicts arise, prefer design‑system tokens and adjust spacing or sizes minimally to match visuals.
  200. - Validate the final UI against the Figma screenshot for both look and behavior.
  201. ```
  202. #### Cursor
  203. ```yaml
  204. ---
  205. description: Figma MCP server rules
  206. globs:
  207. alwaysApply: true
  208. ---
  209. - The Figma MCP server provides an assets endpoint which can serve image and SVG assets
  210. - IMPORTANT: If the Figma MCP server returns a localhost source for an image or an SVG, use that image or SVG source directly
  211. - IMPORTANT: DO NOT import/add new icon packages, all the assets should be in the Figma payload
  212. - IMPORTANT: do NOT use or create placeholders if a localhost source is provided
  213. ```
  214. #### Claude Code
  215. ```markdown
  216. # MCP Servers
  217. ## Figma MCP server rules
  218. - The Figma MCP server provides an assets endpoint which can serve image and SVG assets
  219. - IMPORTANT: If the Figma MCP server returns a localhost source for an image or an SVG, use that image or SVG source directly
  220. - IMPORTANT: DO NOT import/add new icon packages, all the assets should be in the Figma payload
  221. - IMPORTANT: do NOT use or create placeholders if a localhost source is provided
  222. ```
  223. #### General quality rules
  224. ```
  225. - IMPORTANT: Always use components from `/path_to_your_design_system` when possible
  226. - Prioritize Figma fidelity to match designs exactly
  227. - Avoid hardcoded values, use design tokens from Figma where available
  228. - Follow WCAG requirements for accessibility
  229. - Add component documentation
  230. - Place UI components in `/path_to_your_design_system`; avoid inline styles unless truly necessary
  231. ```
  232. Adding these once can dramatically reduce the need for repetitive prompting and ensures that teammates or agents consistently follow the same expectations.
  233. Be sure to check your IDE or MCP client's documentation for how to structure rules, and experiment to find what works best for your team. Clear, consistent guidance often leads to better, more reusable code with less back-and-forth.
  234. ### Break down large selections
  235. Break screens into smaller parts (like components or logical chunks) for faster, more reliable results.
  236. Large selections can slow the tools down, cause errors, or result in incomplete responses, especially when there's too much context for the model to process. Instead:
  237. 1. Generate code for smaller sections or individual components (e.g. Card, Header, Sidebar)
  238. 2. If it feels slow or stuck, reduce your selection size
  239. This helps keep the context manageable and results more predictable, both for you and for the model.
  240. If something in the output doesn't look quite right, it usually helps to revisit the basics: how the Figma file is structured, how the prompt is written, and what context is being sent. Following the best practices above can make a big difference, and often leads to more consistent, reusable code.
  241. ## Bringing Make context to your agent
  242. The Make + MCP integration makes it easier to take prototypes from **design to production**. By connecting Make projects directly to your agent via MCP, you can extract resources and reuse them in your codebase. This reduces friction when extending prototypes into real applications, and ensures that design intent is faithfully carried through to implementation.
  243. With this integration, you can:
  244. - **Fetch project context** directly from Make (individual files or the whole project)
  245. - **Prompt to use existing code components** instead of starting from scratch
  246. - **Extend prototypes with real data** to validate and productionize designs faster
  247. ### How it works
  248. > [!NOTE]
  249. > This integration leverages the MCP **resources capability**, which allows your agent to fetch context directly from Make projects. It is available only on clients that support MCP resources.
  250. #### Steps to fetch resources from Make
  251. 1. **Prompt your agent to fetch context** by providing a valid Make link
  252. 2. **Receive a list of available files** from your Make project
  253. 3. **Download the files you want to fetch** when prompted
  254. ### Example workflow
  255. **Goal:** Implement a popup component in your production codebase that matches the design and behavior defined in Make.
  256. 1. Share your Make project link with your agent.
  257. 2. Prompt the agent: _"I want to get the popup component behavior and styles from this Make file and implement it using my popup component."_
  258. Your agent will fetch the relevant context from Make and guide you in extending your existing popup component with the prototype's functionality and styles.
  259. # Icon Guidelines
  260. See the [Figma Brand Usage Guidelines](https://www.figma.com/using-the-figma-brand) for displaying any icons contained in this repo.

Version history

  • v2.2.21111/17/2026

  • v2.2.20811/14/2026

  • v2.2.20711/13/2026

  • v2.2.19311/11/2026

  • v2.2.17410/29/2026

Ratings and comments

Sign in to rate this skill.

Sign in

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