figma-unlimited-mcp

npx figma-unlimited-mcp install

This is what happens next

Related MCP server: figma-mcp-write-server

The problem

Figma's official MCP server is rate limited by plan and seat:

On a Starter plan that is six tool calls a month, and a Full seat does not help. Nor does reaching for a personal access token and the REST API — Figma applies the same cap there: requests for a file's contents on a Starter plan are limited to six per month, even if you hold a Full seat on a different plan.

Six calls is not enough to look at a board once, let alone iterate on one.

The fix

A Figma plugin runs inside your desktop app, in your own session. The Plugin API it uses is the same code path as editing by hand: no per-plan quota, no daily cap, no per-minute limit.

This puts an MCP server in front of that plugin. Your agent gets 19 tools for reading and writing FigJam, and none of them count against anything.

It is not a way around a paywall. A plugin can only ever do what you, the signed-in user, are already allowed to do on that board.

Quick start

npx figma-unlimited-mcp install registers the server with Claude Code, prints the config block for every other MCP client, and puts the plugin at a permanent path — ~/.figma-unlimited-mcp/plugin/ — before opening it in Finder.

That path matters. Figma stores the location of an imported plugin and reads it on every run, so pointing it inside npm's cache would break the plugin the moment that cache is pruned or you upgrade. Kept in your home directory, upgrading just refreshes the files in place and there is nothing to re-import.

Then, in the Figma desktop app:

1. Open a FigJam board

2. Plugins → Development → Import plugin from manifest… and pick the file it showed you

3. Run Plugins → Development → Figma Unlimited MCP, leave the window open

That is the whole setup, and step 2 only ever happens once. Importing a plugin is a GUI action — Figma ships no CLI for it, so no installer can do it for you.

Prefer to wire it up by hand? --print shows every step without changing anything.

Using Claude Desktop, Cursor, VS Code or Windsurf — or something did not work? docs/INSTALL.md has the config path for each client, the verification checklist, and what to do when the panel stays on Waiting for agent.

See it work

Ask your agent for the demo and it calls create_demo_board once — a system architecture diagram, a request lifecycle, an incident runbook, a service catalog, config snippets, eighteen review notes and a legend:

Say "clean up the demo" to remove it. Everything it creates is tagged, so nothing else on the board is touched.

It doubles as a check that a fresh install works end to end.

What you can ask for

Map our checkout flow on this board: cart, address, payment, confirmation. Mark the payment step red, it is the one that fails.

The agent calls create_diagram once and gets a laid-out, connected flowchart — layered, ordered to minimise crossing edges, with each shape sized to its label. Then it calls export_image to look at its own work, and focus_view to put it on your screen.

Full parameter reference: docs/TOOLS.md.

How it works

┌──────────────┐   MCP over stdio   ┌──────────────────┐
│  Your agent  │ ─────────────────► │  figma-unlimited │
│ (Claude, …)  │ ◄───────────────── │      -mcp        │
└──────────────┘                    └────────┬─────────┘
                                             │ WebSocket
                                             │ localhost:3055
                                    ┌────────▼─────────┐
                                    │  ui.html (iframe)│  ← the only part of a
                                    └────────┬─────────┘    plugin allowed to
                                             │ postMessage   open a socket
                                    ┌────────▼─────────┐
                                    │ code.js (sandbox)│
                                    │  Figma Plugin API│
                                    └──────────────────┘

One process serves both ends: MCP on stdio for the agent, a loopback WebSocket for the plugin. Nothing listens on a public interface and nothing leaves your machine.

The split inside the plugin is not a design choice — Figma's sandbox has no fetch and no WebSocket, and only the sandbox can touch figma.*. docs/ARCHITECTURE.md has the rest, including why layout is computed in Node rather than in the plugin.

Requirements

• Figma desktop app. Locally developed plugins load their manifest from disk; the browser build cannot.

• Node.js 18.17+

• A FigJam board you can edit. A View or Collab seat can read but not write — that is Figma's permission model, not a limit of this tool.

Limitations

Stated plainly, because finding these out later is worse:

• The plugin window must stay open for the whole session. Closing it ends the session — the socket lives in that iframe.

• Figma desktop only.

• One board at a time. A second plugin window takes over the bridge and the first is released.

• FigJam only. Figma Design and Slides are on the roadmap.

• Port 3055 is fixed by the plugin manifest. Changing it means editing the manifest and rebuilding, because Figma validates outbound connections against that allowlist.

Security

• The bridge binds loopback only — 127.0.0.1 and ::1, never a routable interface.

• Any local process could connect to that port and drive your board. If that matters on your machine, start the server with --token <secret> and enter the same secret in the plugin's Advanced drawer.

• The plugin's networkAccess allowlist contains nothing but ws://localhost:3055, so Figma itself blocks it from reaching anywhere else.

• delete_nodes is irreversible from the agent's side, and marked destructive in its schema so clients can prompt first.

More in SECURITY.md.

Development

git clone https://github.com/alexzai007/figma-unlimited-mcp.git
cd figma-unlimited-mcp
npm install
npm run verify        # typecheck + build + tests

Import plugin/manifest.json from your clone instead of the published one. After changing plugin code, run npm run build:plugin and re-run the plugin in Figma — it picks up a new bundle when it is run, not while the window is open.

npm run smoke -- --write   # exercise every tool against a real board
npm run demo               # build the demo board from a terminal
curl localhost:3055/health # is the plugin attached?

The test suite mocks Figma, because Figma cannot run in CI; npm run smoke covers the other half. See CONTRIBUTING.md.

Building on this with an agent? AGENTS.md is written for them.