What can you do with this server?

This server provides programmatic control of a running Figma desktop application through a local WebSocket bridge, without needing the Figma REST API or Personal Access Tokens. * Check connection health (figma_health): Verify the local bridge and Figma Development plugin are connected and responsive. * Execute arbitrary JavaScript (figma_exec): Run any Plugin API code in the Figma plugin main thread, with full access to the figma global object for inspecting, creating, modifying, or querying document elements. Supports asynchronous operations and returns JSON-serializable data. * Get selection information (figma_selection_info): Retrieve a summary of the current page and selected nodes, including IDs, names, types, and bounding boxes. This approach bypasses Figma REST API rate limits and the need for personal access tokens.

Which integrations are available for this server?

Provides tools to interact with the Figma desktop app via a plugin, allowing execution of arbitrary Plugin-API JavaScript in the main thread, retrieving health status, and summarizing current page and selection bounds.

How do I use figma-meta-mcp?

1. Click on "Deploy Server". 2. Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state. 3. In the chat, type @ followed by the MCP server name and your instructions, e.g., "@figma-meta-mcp run JavaScript to list all frames on the current page" That's it! The server will respond to your query, and you can continue using it as needed. Here is a step-by-step guide with screenshots.

figma-meta-mcp

Lightweight Figma MCP in the same mental model as ae-meta-mcp (ae_exec) and CocosMetaMCP (cocosmcp_exec): the Cursor agent runs JavaScript inside a running Figma via figma_exec.

Cursor Agent  ──stdio MCP──▶  Node (MCP + bridge :3851)
                                   ▲
                                   │ WebSocket /plugin
                              Figma Development plugin (UI + main)
                                   │
                              figma.* Plugin API

This path does not use the Figma REST API + Personal Access Token, so it avoids the Viewer-seat REST monthly rate limits. You need the Figma desktop app and the local Development plugin panel open.

Repo: shinjiyu/figma_mcp

Tools (MVP)

Tool	Description
`figma_health`	Bridge up? Plugin WebSocket connected?
`figma_exec`	Run arbitrary Plugin-API JS in the main thread; return JSON
`figma_selection_info`	Summarize current page + selection bounds

Related MCP server: Figma Bridge MCP

Requirements

Windows / macOS / Linux
Node.js >= 18
Figma desktop app
Cursor (or any MCP client)

Install

git clone https://github.com/shinjiyu/figma_mcp.git
cd figma_mcp
npm install

Wire Cursor

npm run setup:cursor

Paste the printed snippet into ~/.cursor/mcp.json, then toggle figma-meta-mcp off/on under Cursor Settings → MCP.

Example:

{
  "mcpServers": {
    "figma-meta-mcp": {
      "command": "node",
      "args": ["D:/workspace/figma_mcp/mcp/index.mjs"],
      "env": {
        "FIGMA_MCP_PORT": "3851"
      }
    }
  }
}

Import the Figma plugin

Start Cursor so MCP (and the bridge on 127.0.0.1:3851) is running.
Open your design file in the Figma desktop app.
Menu: Plugins → Development → Import plugin from manifest…
Select plugin/manifest.json from this repo.
Run Plugins → Development → figma-meta-mcp and keep the panel open.

The panel should show Connected · plugin channel ready.

Verify

figma_health → { ok: true, pluginConnected: true }
figma_selection_info → current page + selection
figma_exec:

return {
  file: figma.root.name,
  page: figma.currentPage.name,
  count: figma.currentPage.children.length,
};

Writing `figma_exec` code

Runs in the plugin main thread with global figma.
Write an async body; use return for the payload.
Return plain JSON (id / name / type / x / y / width / height). Live node proxies are auto-shrunk when possible, but prefer mapping yourself.
Need document bytes for a node? await figma.getNodeByIdAsync(id) (dynamic-page).

See skills/figma-plugin-api/SKILL.md.

Layout

mcp/      stdio MCP server (index, core, context)
bridge/   HTTP + WebSocket host used by the plugin UI
plugin/   Figma Development plugin (manifest, code.js, ui.html)
scripts/  setup-cursor.mjs
skills/   agent notes for Plugin API
examples/ cursor-mcp.json

Env

Variable	Default	Meaning
`FIGMA_MCP_PORT`	`3851`	Bridge listen port
`FIGMA_MCP_HOST`	(unset)	Default: bind loopback only (`127.0.0.1` + `::1`). Set only to override.
`FIGMA_MCP_CORS_ORIGINS`	Figma + `null` + localhost	Comma-separated Origin allowlist (not `*`)
`FIGMA_MCP_EXEC_TIMEOUT_MS`	`30000`	Per-job timeout

Not in scope (yet)

Official remote Figma MCP OAuth (mcp.figma.com) — use that separately if you want cloud tools
REST PAT wrappers — intentionally avoided for quota reasons
Recipe/promote layer (CocosMetaMCP-style) — add later if needed

License

MIT

Available Tools

3 tools

figma_execA

Execute JavaScript inside the running Figma plugin main thread (like ae_exec / cocosmcp_exec / Blender execute_blender_code). The code runs with access to the global figma Plugin API. Write an async body; the final expression / return value is JSON-serialized back. Prefer plain data (id/name/type/x/y/width/height). Avoid returning live node proxies. Example: return figma.currentPage.selection.map(n => ({ id: n.id, name: n.name, type: n.type }));

Inputs: code (required).

figma_healthA

Check whether the local Figma bridge is up and whether the Development plugin is connected.

Inputs: no named parameters.

figma_selection_infoA

Summarize the current page and selection (id/name/type/bounds).

Inputs: no named parameters.

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

Loading tool schema changelog…

Deploy Server

One endpoint for every MCP toolRayrun runs every MCP server behind one URL and holds the credentials. Each call is decided per client, tool, and argument, then recorded.ray.runAd

TDQS

A4.1/5.0

Scored 2026-08-05 15:35 across 3 tools

Disambiguation5/5

The three tools serve clearly distinct functions: health check, arbitrary code execution, and selection introspection. There is no overlap in purpose, even though figma_selection_info could be replicated via figma_exec; it is presented as a convenience wrapper with a distinct scope.

Naming Consistency4/5

All tool names share the figma_ prefix, but the second part is not uniformly verb_noun. figma_health and figma_selection_info are noun phrases, while figma_exec is a verb. This is a minor inconsistency, but the pattern is still predictable and readable.

Tool Count4/5

Three tools is a small but reasonable set for a bridge server. The health and selection tools handle occasional meta needs, while figma_exec provides the core general-purpose capability. It is slightly on the lean side, but not insufficient.

Completeness5/5

figma_exec offers arbitrary access to the Figma Plugin API, making the tool surface effectively complete for any operation. The other two tools cover operational status and a common convenience need. There are no obvious dead ends or missing core workflows.

Maintenance

ActivityInactive

ResponsivenessOutdated data

Resources

Related MCP Connectors

Figma MCP Server
com.figma.mcp
The Figma MCP server brings Figma design context directly into your AI workflow.
Developer Tools Content Management Systems
32,188
https://mcp.figma.com/mcp
mcp-server
com.niftypm
Nifty's MCP server — exposes tasks, projects, messages, and files as tools for AI agents.
Project Management Communication File Systems
2
https://mcp.niftypm.com/mcp
secureflows-mcpA
io.github.michal-lefler
MCP server for secureFlows: token-free URL builders and integration-linting tools for AI agents.
Code Analysis Developer Tools Security
181
https://www.secure-flows.com/mcp
Flowra
io.github.flowradev
MCP server for your apps' tools and custom tools, plus hosted AI agents and approval-gated workflows
Agent Orchestration Autonomous Agents
11
https://mcp.flowra.dev/mcp

Related MCP Servers

figma-opencode-mcp
Design Tools Developer Tools
laivannha0202
A
license
A
quality
D
maintenance
Local-first MCP server that connects AI coding agents to the currently open Figma file through a local plugin bridge, requiring no Figma API token.
Updated 5 months ago (2026-06-12 15:25 UTC)
8
MIT
Figma Bridge MCP
Design Tools Developer Tools
Halil-KAPLAN
A
license
B
quality
C
maintenance
Local MCP server connecting AI clients to the Figma desktop app for inspecting and editing Figma documents via the Plugin API.
Updated 11 days ago (2026-11-03 12:51 UTC)
16
16 npm
1
MIT
Figma Native MCP
Design Tools Developer Tools
tomasmarekk
A
license
Not graded
quality
C
maintenance
A local MCP server that lets MCP clients inspect and edit the Figma document currently open in the Figma desktop app using a local bridge and development plugin.
Updated 4 months ago (2026-07-16 09:47 UTC)
MIT
localfig
Design Tools Developer Tools
LucasGorgal
A
license
A
quality
C
maintenance
The Figma desktop app as an MCP server. Gives AI agents the full Figma Plugin API on your open file: read, write, tokens, components, exports, undo. Runs locally with no cloud API, no token and no quota.
Updated 2 months ago (2026-09-16 00:04 UTC)
10
75 npm
2
MIT