<p align="center">
  <img src="./assets/banner.svg" alt="figma-unlimited-mcp — drive FigJam from your AI agent, through a local plugin rather than Figma's API" width="100%">
</p>

<p align="center">
  <a href="https://www.npmjs.com/package/figma-unlimited-mcp"><img src="https://img.shields.io/npm/v/figma-unlimited-mcp?color=%23111827&label=npm" alt="npm"></a>
  <a href="https://nodejs.org"><img src="https://img.shields.io/badge/node-%E2%89%A518.17-111827" alt="Node 18.17+"></a>
  <a href="https://modelcontextprotocol.io"><img src="https://img.shields.io/badge/MCP-19%20tools-111827" alt="19 MCP tools"></a>
  <a href="./LICENSE"><img src="https://img.shields.io/badge/license-MIT-111827" alt="MIT"></a>
</p>

<p align="center">
  <b><a href="#quick-start">Quick start</a></b> ·
  <b><a href="./docs/INSTALL.md">Full install guide</a></b> ·
  <b><a href="#see-it-work">See it work</a></b> ·
  <b><a href="./docs/TOOLS.md">Tools</a></b> ·
  <b><a href="./docs/ARCHITECTURE.md">Architecture</a></b> ·
  <b><a href="./docs/TROUBLESHOOTING.md">Troubleshooting</a></b>
</p>

---

<p align="center">
  <img src="./assets/install.svg" alt="npx figma-unlimited-mcp install" width="100%">
</p>

```bash
npx figma-unlimited-mcp install
```

<p align="center">
  <sub>Then, in the Figma desktop app: <b>Plugins → Development → Import plugin from manifest…</b><br>
  and pick the file it just opened for you. Once, ever. &nbsp;·&nbsp; <a href="./docs/INSTALL.md">Step-by-step guide</a></sub>
</p>

---

## This is what happens next

<p align="center">
  <img src="./assets/demo.gif" alt="Typing 'use figma unlim run demo' into Claude Code; a full architecture board builds itself in FigJam" width="900">
</p>

<p align="center">
  <sub>Real time, nothing cut. Four words typed into Claude Code — <code>use figma unlim run demo</code> —<br>
  and 196 nodes land on the board in 0.7 seconds.
  <a href="./assets/demo.mp4">Full-quality video</a>.</sub>
</p>

---

## 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](./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*.

<p align="center">
  <img src="./assets/panel.png" alt="The plugin panel, idle and connected" width="720">
</p>

---

## 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:

<p align="center">
  <img src="./assets/demo-board.png" alt="The demo board: six panels of diagrams, tables, code and sticky notes" width="900">
</p>

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](./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](./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](./CHANGELOG.md).
- **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](./SECURITY.md).

---

## Development

```bash
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.

```bash
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](./CONTRIBUTING.md).

**Building on this with an agent?** [AGENTS.md](./AGENTS.md) is written for them.

---

<p align="center">
  <sub>MIT © <a href="https://github.com/AlexZai007">alexzai007</a> · <a href="https://x.com/AlexZai007_best">@AlexZai007_best</a></sub>
</p>