M
MCP Directory CURATED DIRECTORY
911 MCP servers indexed
中文
← Back to directory
F

Figma MCP Server

Community
Community MCP server that lets AI agents read and write Figma designs via a companion plugin.
How to install ↓ Compare GitHub source repository ↗
Category
Collaboration #42 of 55
Stars
★ 175 Popular
Transport
stdio (local process) · Streamable HTTP
Runtime
Node.js
Credentials
No credential needed
License
Apache-2.0
Last commit
44FMRS · D

An early-stage (v0.1.0) community Figma MCP server that bridges a local WebSocket-connected plugin to provide read-write Figma access the official read-only server lacks, though its tool list is undocumented and setup requires manually building and loading both the server and the plugin.

Strongest · Security and permissions 11/20 Weakest · Reliability 7/20

Reliability
7/20
Security and permissions
11/20
Maintenance
10/20
Documentation
9/20
Setup experience
7/20
Why each score
Reliability 7/20
This is a static-only review; no CI workflow or committed tests were found, so there is no verifiable execution evidence. The manifest declares two npm package entries (stdio and streamable-http), but the README only documents the Express + socket.io based streamable-http architecture and says nothing about the stdio transport, an inconsistency between manifest and docs. The Tools section is explicitly marked 'TBD', so declared tools cannot be checked against real behavior. The architecture depends on a separate Figma plugin bridged over WebSockets, adding a long chain of failure points; timeouts are mentioned but error-handling detail is thin, and the package is at an early 0.1.0 version. Per the static calibration rule, reliability cannot exceed 12 without CI+test evidence, and the issues above justify a low score within that ceiling.
Security and permissions 11/20
The plugin grants write/modify access to the user's Figma design document, a real-effect capability, but the documentation does not describe any confirmation step for destructive or irreversible design changes, nor a fine-grained permission scope — the only stated mitigation is manually 'turning off tools you don't need.' No authentication is documented for the local streamable-http endpoint (localhost:38450/mcp). On the positive side, the README's Security section explicitly discloses the local-only scope and warns that network exposure is at the user's own risk, which is reasonably transparent; no credential theft, malware, or identity fabrication was found (not a red-line case). Overall, main risks are disclosed but confirmation and least-privilege scoping remain incomplete.
Maintenance 10/20
The repository is active and not archived, uses the Apache-2.0 license, and shows some community traction (170 stars, 3 open issues). However the version is only 0.1.0, and no release history, changelog, or dependency-update practice is evidenced. The security reporting channel is limited to 'file a GitHub issue,' with no dedicated SECURITY.md or response process described. Given the limited evidence, maintenance activity can only be rated moderate.
Documentation 9/20
Documentation covers install, plugin build, server startup, and architecture (including diagrams and a sequence chart) reasonably well, and the Security section discloses scope. However, the Tools section is explicitly 'TBD', leaving tool parameters, limits, and usage entirely undocumented — a significant gap. There is also no troubleshooting section, and the text contains several typos (e.g., 'Imprort Plugin'), indicating the docs are still immature.
Setup experience 7/20
Setup is manual and multi-step: clone the repo, build the Figma plugin locally, import it into Figma in developer mode, separately start the MCP server via npm, and manually configure the client for the streamable-http endpoint — no mainstream client config example (e.g., claude_desktop_config.json) is given. The README states the plugin has not yet been accepted by Figma's official reviewers, so marketplace installation is unavailable. Although the manifest lists npm packages, the README does not document installing/connecting via the published npm package directly, a disconnect between the two. Per the static calibration rule, setup is further capped without verifiable execution evidence, and the manual, fragile flow itself warrants a low score.

Static review · not runListed 2026-08-26

Read the FMRS scoring method →

Fit and risk

What it can accessUses the network

Best for

  • Developers or designers who need AI agents to write to Figma documents, not just read them
  • Users comfortable running a local Node.js server and manually loading a developer-mode plugin

Not for

  • Users who only need read-only access and prefer an officially supported solution
  • Users unable to run local services or install developer-mode plugins
  • Multi-user network or production deployments, given the explicit local-only security stance

Required permissions

  • Full read/write access to whichever Figma document the plugin is running against
  • A local network port (default 38450) used for WebSocket communication between the MCP server and the Figma plugin

Risks and side effects

  • Early-stage project (v0.1.0), community-maintained rather than officially supported
  • No documented tool list yet (marked TBD in the README), limiting behavioral transparency
  • The author explicitly warns that exposing the server over a network is at the user's own risk
  • The plugin has not yet been approved by Figma and must be sideloaded in developer mode, so the setup process may change

Setup

Before you start

Runtime：Node.js

Other optional settings (1)
TRANSPORT optional Optional environment variable selecting the transport mode, either stdio or streamable-http; no credential or external value needed.
  1. Install Node.js and clone the Antonytm/figma-mcp-server repository.
  2. Build and load the Figma plugin: in the plugin directory run npm i and npm run build, then in Figma use Plugins > Development > Import plugin from manifest to select /plugin/manifest.json, and start the plugin until it shows 'Connected to MCP server'.
  3. Start the MCP server: in the mcp directory run npm i and npm run start; the console should show 'Server listening on http://localhost:38450'.
  4. Configure your AI client to use the Streamable HTTP transport at http://localhost:38450/mcp (or switch to stdio via the TRANSPORT environment variable), and disable any tools you don't need.
claude_desktop_config.json 
{"mcpServers": {"figma": {"url": "http://localhost:38450/mcp"}}}

Shown for Claude Desktop. Other clients may use a different file or key (VS Code uses "servers") — the configurator below converts it.

.vscode/mcp.json
{
  "servers": {
    "figma": {
      "url": "http://localhost:38450/mcp"
    }
  }
}

Goes in your project's .vscode/mcp.json (VS Code uses a "servers" key).

Terminal
claude mcp add --transport http figma http://localhost:38450/mcp

Run it in a terminal; replace any <…> placeholders with your own values first.

Generate and validate client config

Check that it works

Start the Figma plugin and wait for the 'Connected to MCP server' message, then run the MCP server and confirm it prints 'Server listening on http://localhost:38450'. In your client, connect via streamable-http to http://localhost:38450/mcp and check that the server's tools appear in the tool list.

Troubleshooting

  1. Confirm the plugin window shows 'Connected to MCP server' rather than 'Not connected to MCP server'
  2. Confirm the MCP server console prints 'Server listening on http://localhost:38450' and a user-connected log line
  3. Verify the plugin was imported from /plugin/manifest.json and rebuilt with the latest npm run build
  4. Verify the client's configured transport (stdio or streamable-http) matches the TRANSPORT environment variable and how the server is actually running
  5. Check that local port 38450 isn't already in use by another process

Things to try

Once connected, you can ask your AI assistant things like:

  • Implement this design in my current Figma document
  • Change the title text in the selected Figma frame to 'Welcome'
  • Create a new button component in the Figma page
  • List all layers in the current Figma document

Use cases

Ask an AI agent to implement a described design change directly in an open Figma file
Iterate on designs from a chat interface without moving results between Figma Make and the main Figma app
Automate repetitive Figma editing steps as part of a design-to-implementation workflow

Supported clients

Claude DesktopPartial support

Listed from the project's documentation, not tested by this site.

Overview

figma-mcp-server (Apache-2.0, v0.1.0) is an unofficial, community-maintained project built to address a gap in the official Figma MCP server: it only supports read-only tools. This server pairs a local MCP server (Express.js plus a Socket.IO WebSocket layer) with a Figma plugin that must be imported manually in developer mode. The MCP server queues tool calls and dispatches them over WebSocket to the plugin, which performs the requested action inside the currently open Figma document and returns the result; calls that run too long time out. The server supports both stdio and streamable-http transports, with streamable-http defaulting to http://localhost:38450/mcp. The README lists its tool set as 'TBD' — no tools are documented yet. The author states the server runs locally only and does not expose information to the network by design; using it over a network is at the user's own risk. The team is also working on shipping it as an official Figma plugin, but as of the README it has not yet been accepted by Figma's reviewers.

Similar servers

Compare with other MCP servers

Source revision 2fd00295925f Data synced 2026-10-19 Read the FMRS scoring method