figma-mcp-express

# figma-mcp-express

![Figma MCP Express hero: the fast lane for AI agents into Figma](assets/figma-mcp-express-hero.png)

[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE)
[![Go](https://img.shields.io/badge/Go-1.21+-blue.svg)](https://go.dev)
[![npm](https://img.shields.io/npm/v/figma-mcp-express.svg)](https://www.npmjs.com/package/figma-mcp-express)
[![Works with Claude Code](https://img.shields.io/badge/Claude%20Code-compatible-8A2BE2?logo=anthropic)](https://claude.ai/code)
[![Works with Codex](https://img.shields.io/badge/Codex-compatible-000000)](https://github.com/openai/codex)

Enhanced fork of [vkhanhqui/figma-mcp-go](https://github.com/vkhanhqui/figma-mcp-go).

---

**Fast, quota-free, agent-ready Figma MCP.** Give AI agents direct read/write access to Figma through a local Desktop plugin, with batch execution, multi-file routing, and stable concurrent sessions that are not capped by Figma's official MCP server tool-call limits.

> **Claude Code, Codex, and other coding agents** that can use the local filesystem is **recommended.** Unlike cloud-only MCPs, figma-mcp-express uses the filesystem to optimize the performance and stability.

If you are building design migration, audit, or handoff agents, give it a try.

| Promise         | What it means in practice                                                                                                                                  |
| --------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **Fast**        | Build with fewer LLM ↔ plugin round-trips by batching dependent operations into one call.                                                                  |
| **Quota-free**  | Plugin-side work is not capped by Figma's official MCP server limits, such as 6 calls/month for View/Collab seats or 200-600 calls/day for Dev/Full seats. |
| **Agent-ready** | Multiple agents can share a session safely through channel routing, reconnects, read dedup, and a hardened request queue.                                  |

### Why this fork exists

| Compared with        | What blocks real automation                                                                                                                                  | What figma-mcp-express adds                                                                                               |
| -------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------- |
| Official Figma MCP   | Seat-based MCP server limits: View/Collab seats get up to 6 calls/month, while Dev/Full seats get daily and per-minute caps.                                 | Local plugin-side read/write access for open files without those official MCP tool-call quotas.                           |
| Plain figma-mcp-go   | Single-connection assumptions, no batching, no parallel agents, weaker library automation, and reconnect flapping under multi-file or long-running sessions. | Multi-file channels, batch ops, library tooling, response spill-to-disk, reconnect safety, and concurrent agent handling. |
| Manual Figma cleanup | Repetitive token binding, component replacement, audits, and design-to-code extraction.                                                                      | Agent workflows that can scan, modify, verify, and report across large files.                                             |

---

## Who this is for

- **Coding agents (Claude Code, Codex)** — the primary target. Skills ship with the server and load from the local filesystem, so the agent has structured guidance without burning context on docs. Spill-to-disk keeps large Figma reads out of the context window entirely.
- Design systems teams migrating products to a new component library or token system
- Product designers cleaning up large production files without doing every replacement by hand
- Frontend engineers who need better design-to-code context than screenshots and comments
- Teams experimenting with multi-agent workflows for audits, migrations, and handoff generation

### Before / After

| Situation                                | Without figma-mcp-express                                             | With figma-mcp-express                                                                       |
| ---------------------------------------- | --------------------------------------------------------------------- | -------------------------------------------------------------------------------------------- |
| Official Figma MCP on a restricted seat  | You hit seat-based call caps quickly and have to ration automation.   | Normal plugin-side work is not capped by the official MCP server limits.                     |
| Moving a product to a new design library | Designers swap components and fix spacing one screen at a time.       | An agent can inspect the old file, map the new library, and migrate frames in bulk.          |
| Large file audit                         | The model gets flooded with raw node data or times out on huge reads. | Large reads spill to disk and the agent can inspect only the relevant slice.                 |
| Parallel work                            | Multiple agents easily collide or queue uselessly on the same file.   | The bridge isolates channels, coordinates queueing, and supports safer multi-agent sessions. |

### Example prompts

```text
Migrate these 120 product frames to the new library. Keep the new library's UX patterns, spacing rules, and component variants consistent.
```

```text
Scan this file for detached buttons, hardcoded spacing, and off-system color usage. Group the findings by severity and suggest the cleanest replacement path.
```

```text
Turn this React settings page into a Figma review artifact using the correct library components, token bindings, and dark-mode variables.
```

```text
Read this design system file and generate a DESIGN.md with token scale, text styles, component inventory, and obvious consistency gaps.
```

```text
Open the product file and the source library at the same time. Compare their components, then replace outdated instances page by page without touching unaffected areas.
```

---

## Use cases

**For designers**

- Automate dull work — find detached components, rebind hardcoded values to tokens, fix deviations from the design system at scale
- Library swap — migrate a file from one design system to another: remap component keys, rebind tokens, update variants in bulk
- Frame and layout setup — scaffold auto layout, bind spacing variables, pin color modes — Claude handles the structural work while you focus on designing
- Design audit — scan for raw values, off-system components, token gaps, and repeated visuals that could become reusable local components

**For developers**

- Prompt → Figma — generate a Figma counterpart for an existing component or page for design review, using the correct library variants
- Code handoff — extract token names, auto layout spec, and component references per frame, ready to implement without guessing
- Learn a file — generate a DESIGN.md (token scale, text styles, color modes, component inventory) from any Figma file

**For creators**

- Prompt → Figma — describe a screen and have Claude build it end-to-end with real library components and bound tokens
- Stitch → Figma — take a [Stitch](https://stitch.withgoogle.com) wireframe draft and re-render it in Figma with the correct components, spacing tokens, and variable modes
- Pattern report — scan a file for what's there, what's reusable, and what's inconsistent before you start building

---

## Capabilities

| Track     | Capability                     | Why it matters                                                                                                           |
| --------- | ------------------------------ | ------------------------------------------------------------------------------------------------------------------------ |
| Speed     | Fewer back-and-forth steps     | The agent can do several related Figma actions in one go, so building or editing a screen feels much faster.             |
| Speed     | Large reads stay manageable    | Big files do not dump huge walls of data into the model at once, so the agent can stay focused on the part that matters. |
| Free      | No official MCP quota limits   | You are not blocked by the official Figma MCP server's monthly or daily call caps for normal plugin-side work.           |
| Access    | Direct Figma editing           | The agent works on the open Figma file itself, not a disconnected copy or a limited export.                              |
| Access    | Uses your real design system   | It can work with your actual components, variables, and styles instead of rebuilding everything from raw shapes.         |
| Access    | Can inspect shared libraries   | It can still look up published library assets when the plugin cannot run inside that file.                               |
| Stability | Multiple files stay separate   | Working on one file does not knock another file offline or mix their state together.                                     |
| Stability | Safe under parallel agent work | Multiple agents can share the same session without stepping on each other as easily.                                     |
| Stability | Better recovery from drops     | If the connection breaks or the MCP client restarts, the system is designed to recover without forcing a full restart.   |
| Scale     | Handles large production files | Big design files stay usable instead of freezing the plugin during long reads or scans.                                  |
| Hando