Skip to main content
Glama
Sign In
figma-unlimited-mcp

figma-unlimited-mcp

by AlexZai007
OverviewSchemaSourceRelated ServersDiscussionsAdmin
TypeScript
Local

npx figma-unlimited-mcp install

This is what happens next

Related MCP server: figma-opencode-mcp

The problem

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

Seat

Starter

Professional

Organization

Enterprise

View, Collab

up to 6 / month

up to 6 / month

up to 6 / month

up to 6 / month

Dev, Full

up to 6 / month

200 / day, 10 / min

200 / day, 15 / min

600 / day, 20 / min

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.

Tool

What it does

get_board_info

File, page, node counts, content bounds, viewport, selection

list_nodes · get_node · find_nodes · get_selection

Read the board

export_image

Render to PNG, so the agent can see what it made

create_demo_board

The whole demo board — one call, ~200 nodes

create_diagram

A laid-out, connected diagram in one call

create_stickies · create_shapes · create_texts

Core FigJam content

create_sections · create_tables · create_code_blocks

Structure and detail

create_connectors

Wire existing nodes together

update_nodes · arrange_nodes · delete_nodes

Edit what is already there

focus_view

Scroll the user's viewport onto the result

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.

Available Tools

19 tools
arrange_nodesMove, resize or reparent nodesA

Set absolute position, size, or parent container for existing nodes. Use it to tidy a board after generating content, or to move nodes into a section.

Inputs: items (required).

create_code_blocksCreate code blocksA

Add syntax-highlighted code blocks. Useful for putting a snippet, schema or config next to the diagram that explains it.

Inputs: items (required).

create_connectorsConnect nodes with arrowsA

Draw connectors between existing nodes. Both endpoints must be ids of nodes that already exist — create the shapes first, then connect them.

Inputs: items (required).

create_demo_boardBuild the demo boardA

Build a complete architecture review board in one call: a system architecture diagram, a request lifecycle, an incident runbook, a service catalog table, config snippets, review stickies and a legend — about 200 nodes, in well under a second.

Use it to show what this server can do, or to check that a fresh install actually works. Pass mode "clean" to remove it again; everything it creates is tagged, so nothing else on the board is touched.

Inputs: mode.

create_diagramCreate a laid-out, connected diagramA

Build a complete flowchart or graph in one call: nodes are placed with a layered layout, then wired together with connectors. This is the preferred tool for any multi-node diagram — it avoids the overlapping shapes you get from placing nodes by hand.

Refer to nodes by your own key strings; edges use those same keys.

Inputs: nodes (required), x, y, edges, +5 more.

create_sectionsCreate sectionsA

Add named sections — the FigJam equivalent of a labelled swimlane or column. Pass a section id as parentId on other create tools to place content inside it.

Inputs: items (required).

create_shapesCreate shapes with textA

Add FigJam shapes that carry a text label — the building block for flowcharts and architecture diagrams. For a whole diagram at once, prefer create_diagram, which also lays the shapes out and connects them.

Inputs: items (required).

create_stickiesCreate sticky notesA

Add one or more sticky notes. Stickies are the native FigJam unit for ideas, votes and retro items — prefer them over text nodes for anything a human might want to drag around.

Inputs: items (required).

create_tablesCreate tablesA

Add a FigJam table and fill its cells. Pass cells as an array of rows, each row an array of strings; the first row reads as the header.

Inputs: items (required).

create_textsCreate text nodesA

Add free-floating text. Good for board titles, column headers and annotations; use stickies for content the user will rearrange.

Inputs: items (required).

delete_nodesDelete nodesA
Destructive

Permanently remove nodes from the board. This is destructive and the user cannot undo it from your side — confirm with them before deleting anything you did not create yourself in this session.

Inputs: nodeIds (required).

export_imageExport a PNG of the boardA
Read-only

Render the page, a selection, or specific nodes to a PNG and return it as an image. This is how you visually check your own work — look at the result and fix layout problems before telling the user you are done.

Inputs: scale, nodeIds, maxDimension.

find_nodesFind nodes by textA
Read-only

Search the current page for nodes whose text or name contains a substring (case-insensitive). Cheaper than listing a large board.

Inputs: query (required), limit, types.

focus_viewScroll the user's viewA

Scroll and zoom the user's Figma viewport onto specific nodes, and optionally select them. Call this after building something so the user is looking at it when you report back.

Inputs: select, nodeIds.

get_board_infoGet board infoA
Read-only

Describe the connected FigJam board: file name, current page, node counts by type, content bounds, the user's viewport and selection. Call this first — it confirms the plugin is connected and tells you where there is free space to place new content.

Inputs: no named parameters.

get_nodeGet nodes by idA
Read-only

Fetch full details for specific nodes, including text, fills, geometry and connector endpoints.

Inputs: nodeIds (required), depth.

get_selectionGet selectionA
Read-only

Return the nodes the user currently has selected in Figma. Use this when the user says "this", "these", or "the selected ones".

Inputs: no named parameters.

list_nodesList nodesA
Read-only

List nodes on the current page, or inside a specific container. Returns id, type, name, text, position and size for each. Use this to understand an existing board before editing it.

Inputs: depth, limit, types, parentId.

update_nodesUpdate existing nodesA

Change text, colour, name or lock state on nodes that already exist. Only the fields you pass are touched; everything else is left alone.

Inputs: items (required).

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 across 19 tools

    Disambiguation5/5

    Each tool targets a distinct action and resource type, from creation tools like create_stickies and create_tables to query tools like list_nodes and find_nodes. The descriptions clearly separate similar operations, e.g., create_diagram vs. create_shapes + create_connectors, and update_nodes vs. arrange_nodes.

    Naming Consistency5/5

    All tool names follow a consistent verb_noun pattern with lowercase and underscores (create_*, get_*, list_*, update_nodes, arrange_nodes, focus_view). No mixed conventions or vague verbs are present.

    Tool Count4/5

    At 19 tools, the set is slightly above the typical 3-15 well-scoped range, but the breadth is justified by the many content types FigJam supports (stickies, shapes, tables, code blocks, etc.). Each tool has a clear role, so the count feels reasonable rather than bloated.

    Completeness5/5

    The tool surface covers the full lifecycle for FigJam content: read (list_nodes, get_node, get_board_info, find_nodes), create (all create_* tools), update (update_nodes, arrange_nodes), delete, plus export and viewport focus. The create_demo_board tool even provides a ready-made showcase, indicating a thorough understanding of the domain.

    Maintenance

    ActivityNo data
    ResponsivenessOutdated data

    Resources

    Related MCP Connectors

    Related MCP Servers

    • figma-mcp-write-server

      oO
      A
      license
      Not graded
      quality
      D
      maintenance
      An MCP server that provides write access to Figma through the Plugin API, enabling AI agents to create, modify, and manage Figma designs programmatically.
      23
      MIT

    • figma-mcp-rust

      alvinindra
      A
      license
      Not graded
      quality
      B
      maintenance
      An MCP server that enables AI tools to read and write Figma designs via a plugin bridge, bypassing the Figma REST API and rate limits.
      78
      MIT