Skip to main content
Glama

About · Setup · Skills · Tools · Plugin · FAQ · Contributing

npm CI License: MIT

About

Figwright connects an MCP server to a Figma plugin over a local WebSocket relay, so an AI agent (Claude Code, Cursor, Codex, or any other MCP client) can work with Figma instead of just looking at it.

It works in both directions:

Read: turn a Figma selection into framework-aware code, grounded on faithful, de-duplicated design context (layout, typography, variables, components).

Write: author and edit the canvas directly, from frames and text to auto-layout, styles, variables, components, whole screens.

Everything runs on your machine: the server, the relay, and the plugin. Your designs are never sent anywhere.

Related MCP server: Talk to Figma MCP

Why Figwright

  • Not gated: the official Dev Mode MCP is behind a paid Dev Mode seat. Figwright runs on the free tier.

  • Bidirectional: not read-only. 135 tools span reading and writing the canvas, so an agent can both implement designs and build them.

  • Provider-first codegen: Figwright detects your real stack (framework + styling system) and reuses your existing components, tokens, and icons, instead of emitting generic markup you have to rewrite.

  • One agent per file: several agents can work at once, each claiming its own open Figma file. Switching tabs no longer sends one agent's edits into another's design — see working across files.

  • Open & extensible: the read/write workflows ship as installable skills you can adopt or fork.

Setup

You need an MCP client (Claude Code, Cursor, …), Node.js 20.19+ or 22.12+, and Figma. The free Figma tier is enough, though the desktop app is needed to import the plugin. The server runs via npx as its own process, so its Node version is independent of the one your project builds with; Node 18/21 and 22.0–22.11 are not supported.

1. Add the server to your MCP client

For Claude Code, add this to your .mcp.json (other clients use the same shape):

{
  "mcpServers": {
    "figwright": {
      "command": "npx",
      "args": ["-y", "@figwright/mcp@latest"]
    }
  }
}

npx fetches and runs the published server, so no global install is needed.

2. Install the Figma plugin

The plugin isn't on the Figma Community marketplace yet, so install it from the latest release:

  1. Download the plugin zip from the latest GitHub Release and unzip it.

  2. In the Figma desktop app: Menu → Plugins → Development → Import plugin from manifest… and pick the unzipped manifest.json.

3. Connect

Open the Figwright plugin in Figma (Plugins → Development → Figwright). It connects to the local server automatically and shows Connected. Ask your agent to run ping to confirm the link.

4. (Optional) Install the skills

The skills make agents reach for Figwright at the right moment and follow the grounded workflows:

npx skills add awdr74100/figwright/skills

5. Try it

With a frame selected in Figma, prompt your agent:

Code this Figma selection as a React component.

or, the other direction:

Build a pricing section in Figma from this spec.

Updating

Each release ships the server and the plugin together, so update both. The skills are optional and update the same way you installed them.

1. Restart the server. With the @latest config above there is nothing to install, because every launch fetches the newest release. A session that is already open keeps the server it started with, so new tools don't appear until you restart it: in Claude Code, run /mcp, pick figwright and choose Reconnect (or restart Claude Code); in other clients, restart the client. Do this in each client you use Figwright from.

If you installed the package instead of using @latest (see the FAQ), update it before restarting: npm i -D @figwright/mcp@latest, or npm i -g @figwright/mcp@latest for a global install.

2. Replace the plugin. Download the zip from the latest release, unzip it, and copy its manifest.json and dist into the folder you imported the plugin from, replacing the old ones. Figma runs a development plugin straight from that folder, so you don't import it again. Close the plugin and run it again.

3. Update the skills. Run npx skills update. Agent sessions you start after that use the new version.

To confirm, open the plugin's Debug tab: it lists the server and plugin versions side by side. If the plugin is still too old for the server, the panel header says so, and so does every tool result (see the FAQ).

Skills

Agent skills orchestrate Figwright's tools. They are model-invoked: your agent loads one automatically when the task matches its description.

Skill

What it does

figma‑codegen

Turn a Figma selection into framework-aware code, grounded on your stack and existing components.

figma‑build

Build a Figma design from code or a description, reusing the file's existing components and styles.

Install across any supported agent with the skills CLI:

npx skills add awdr74100/figwright/skills      # both
npx skills add https://github.com/awdr74100/figwright/tree/main/skills/figma-codegen  # one
NOTE

Skills need the@figwright/mcp server connected. On their own they have no tools to drive.

Tools

Figwright exposes 135 MCP tools in three groups:

  • Read: selection, document and node inspection, styles, variables, components, fonts, prototype reactions and flows, motion (animation) state, screenshots, original image-fill assets, PDF export, and video export of animated frames (MP4 / GIF / WebM); plus list_files / use_file for working across more than one open Figma file at once.

  • Write: create and edit frames, text, shapes (lines, polygons, stars, boolean operations, flattening), auto-layout, alignment and distribution, effects, images (as a new layer or into an existing layer's fill), styles, variables (including importing a team library's variables and styles, and switching a frame to a mode such as Dark), components (including authoring their boolean/text/instance-swap properties), pages, prototype reactions and flows, Motion animations (keyframes, animation-style presets, timelines), and Figma Draw (vector paths drawn and edited point by point from any SVG path data, outlined strokes, repeat groups, text on a path, brush / dynamic / variable-width strokes, pattern fills); plus a batch tool to apply many edits at once.

  • Grounding: get_design_context for faithful, de-duplicated design context, and component_map / token_map / icon_map, which join Figma data to your codebase so codegen reuses what you already have; plus design_diff, which reports what changed in a design against a saved baseline so you update only the affected code.

TIP

Your MCP client lists every tool at connect time, which is always the authoritative, up-to-date catalog.

Plugin

The Figma-side plugin isn't a black box. It shows every call as it happens, lets you inspect the exact payload sent to the model, and surfaces its own connection health.

And it follows your Figma theme, light or dark.

The window is yours to arrange. Drag the bottom-right corner to resize it. A taller panel keeps more of the log in view, and the size is remembered next time you open it. Or put it away: Run in background, in the panel header right under Figma's own ✕, hides the panel while the connection stays live, so a long-running agent keeps working. Run the plugin again to bring it back. The ✕ above it closes the plugin instead, connection and all.

How it works

Your MCP client launches the @figwright/mcp server and talks to it over stdio. The server relays each tool call over a local WebSocket to the Figwright plugin, which carries it out through Figma's Plugin API. Every agent runs its own server process; the processes elect a leader that holds the plugin connections, and the rest forward to it. The plugin runs in every file you open it in, so several agents can each work in their own file at once, and the whole path is built to ride out dropped sockets, leader handovers and long reads:

┌─────────────────────────────────────────────────────────────────────┐
│ MCP CLIENTS  ·  each agent's client launches its own server         │
│ Claude Code · Cursor · Claude · any MCP-capable client              │
└─────────────────────────────────────────────────────────────────────┘
                                   │  MCP protocol over stdio
                                   ▼
┌─────────────────────────────────────────────────────────────────────┐
│ @figwright/mcp  ·  the server processes elect one leader            │
│                                                                     │
│ LEADER   (holds every plugin connection)                            │
│    • WebSocket relay on 127.0.0.1:3055, Host- and Origin-checked    │
│    • routes each agent to the file it claimed with use_file,        │
│      otherwise to the file the user was last active in              │
│    • session resume: a dropped plugin has 30 s to reconnect, and    │
│      calls bound for it wait instead of failing                     │
│    • "busy ≠ dead" heartbeat: a busy plugin isn't taken for dead    │
│    • endpoints:  /ws (plugins) · /ping (health) · /rpc (followers)  │
│                  /abdicate (hand over to a newer build)             │
│                                                                     │
│ FOLLOWERS                                                           │
│    • forward tool calls to the leader over HTTP /rpc                │
│    • retry a call caught in a leader handover                       │
│    • take over automatically if the leader exits, and ask an older  │
│      leader to step down once it goes idle                          │
└─────────────────────────────────────────────────────────────────────┘
                                   │  local WebSocket · msgpack (binary)
                                   ▼
┌─────────────────────────────────────────────────────────────────────┐
│ FIGMA  (desktop or browser)  ·  one plugin per file it's open in    │
│                                                                     │
│ ┌─────────────────────────────────────────────────────────────────┐ │
│ │ Figwright plugin                                                │ │
│ │   • UI (Vue 3 iframe): WebSocket client, heartbeat, reconnect   │ │
│ │   • sandbox: executes Figma Plugin API calls                    │ │
│ │       – replays a retried write instead of applying it twice    │ │
│ │       – long reads yield every ~40 ms to keep Figma responsive  │ │
│ └─────────────────────────────────────────────────────────────────┘ │
│                                                                     │
│              │ Figma Plugin API                                     │
│              ▼                                                      │
│            Canvas                                                   │
└─────────────────────────────────────────────────────────────────────┘

By design Figwright is provider-first: rather than a fixed compiler pipeline, the tools surface honest design context and let the model generate code that matches your codebase. The figma-codegen skill encodes this approach.

Security

Figwright runs entirely on your machine: your client launches the server over stdio, the server relays to the plugin over a WebSocket on 127.0.0.1:3055, and nothing is sent anywhere else. The plugin uses only Figma's public Plugin API, so it reaches the file you have open and nothing beyond it.

Loopback is not on its own a boundary, since a web page you visit can still reach a local port, so the relay gates every request on two headers a page cannot forge: Host, which must name loopback (this is what stops DNS rebinding), and Origin, which admits the plugin's sandboxed handshake and refuses browsers everywhere else. The leader's HTTP endpoints additionally require a media type that cannot be sent without a CORS preflight. See MCP Security Best Practices for the wider picture, and SECURITY.md for Figwright's threat model, what is in and out of scope, and how to report a vulnerability privately.

Figwright is not a substitute for reviewing what your agent does. Its write tools change your Figma file and its export tools write files to paths the agent chooses; an agent acting on a malicious design or a prompt-injected instruction can misuse both. Your MCP client's tool-approval controls are the boundary that matters.

FAQ

Both come down to how your MCP client launches the server: it spawns the command directly, not through your interactive shell, so it inherits none of what your shell sets up. That bites hardest when Node is managed by a version manager (fnm, nvm, asdf, volta, mise), since those configure PATH and npm from shell hooks that only run in a real terminal. It is not specific to Figwright; it affects any npx-launched MCP server. There are two symptoms, with two different fixes.

command not found: the client can't find npx / node on its PATH.

  • Use an absolute path. In a normal terminal run which npx (or which node) and use that full path as command:

    {
      "mcpServers": {
        "figwright": {
          "command": "/Users/you/.local/share/fnm/node-versions/v26.x.x/installation/bin/npx",
          "args": ["-y", "@figwright/mcp@latest"]
        }
      }
    }
  • Or pass PATH through env. If your client supports a per-server env, add your version manager's bin directory to env.PATH.

-32000 / "Connection closed" / it just never connects: npx runs, but the server exits before the handshake.

npx … @latest re-resolves the package from the registry on every launch. In a directly-spawned environment that step can fail or stall (empty or different npm config, a corporate proxy or private registry that is not configured there, or no network), so the process dies before MCP connects and the client reports the connection as closed. (A missing node for the binary's shebang lands here too.)

The fix is to install the package so launch needs no registry fetch:

  • As a project dependency, the quickest unblock. Install it, then drop @latest from your config. The @latest tag is what forces the registry round-trip; without it, npx uses the copy already in node_modules (a project-scoped config like Claude Code's .mcp.json runs from your project root):

    pnpm add -D @figwright/mcp   # or: npm i -D @figwright/mcp
    {
      "mcpServers": {
        "figwright": {
          "command": "npx",
          "args": ["-y", "@figwright/mcp"]
        }
      }
    }
  • Or globally, pinned to the binary. Install once, then point command straight at it, with no npx and no per-launch resolution. Use the absolute path from which figwright-mcp:

    npm i -g @figwright/mcp
    which figwright-mcp
    {
      "mcpServers": {
        "figwright": {
          "command": "/absolute/path/to/figwright-mcp"
        }
      }
    }

The server is launched by your MCP client, so it only runs while that client is open. Check that:

  • your MCP client is running and has Figwright configured (try a ping);

  • the plugin is open in the same Figma app on the same machine (the relay is local-only, 127.0.0.1);

  • nothing is blocking local loopback connections (some firewall / security tools do).

The plugin's Debug tab lists both versions side by side, so a mismatch is visible in one place.

Mostly you don't need to look. The two halves update through different channels — the server re-resolves itself on every launch via npx @latest, while the plugin is a zip you imported by hand and then stop thinking about — so drifting apart is the normal state here rather than an edge case. It is also a silent one: a handler that predates an argument ignores it without erroring, so a write can report success having done only part of what was asked. When your plugin is old enough for that, the panel says so and tells you how to update (Updating has the steps), and every tool result tells your agent the result is unverified.

It stays quiet on a difference that cannot bite — a plugin a version behind a server that changed no arguments is fine — so when the warning does appear it is worth acting on.

No. Figwright talks to Figma through a plugin, so the free tier is enough. No Dev Mode seat or paid tier required.

It runs in both, with less available than in Figma Design, because those editors give plugins less rather than because Figwright holds anything back.

  • Figma Design: everything.

  • Dev Mode (Inspect panel): reads and exports only. Figma makes plugins read-only there, so screenshots, PDF export and every inspection tool work, while every write fails: nodes, pages, variables and styles alike. That suits the codegen direction; use Design mode to build. (The panel's own window controls — resize and Run in background — aren't there either: Figma owns that frame.)

  • FigJam: frames, sections, shapes and text work; components, variables, styles and Motion don't exist in that editor, so the tools for them don't apply.

get_metadata reports the editor (editorType / mode), and any tool that fails because of the editor says so in its error, so an agent can re-plan rather than retry.

Yes. Several MCP servers can share a single plugin via leader/follower election: one leads, the others follow, with a graceful handoff if the leader goes away.

Yes, once each agent claims its file.

By default calls follow whichever file you last touched, so switching tabs switches what the agent sees — the right behaviour for one agent, and the wrong one for two, since the agent whose file isn't in front would silently get the other file's nodes. Whenever more than one file is open and an agent hasn't claimed one, every result it gets says so, so it can claim one before building anything on the wrong file.

list_files shows every file that currently has the plugin open, and use_file claims one for that agent:

> use the marketing site file
  → use_file({ fileName: "Marketing Site" })

The claim belongs to that agent's own server process, so it never affects the other agent, it survives closing and reopening the plugin panel, and calls keep reaching the file even while its tab sits in the background. That process is also the unit: one per MCP client, so the agents have to be separate clients — two editors, or two terminals. Everything inside one of them, subagents included, shares a server and therefore shares a claim. If two open files share a name (x and a second x), use_file refuses the name and asks for the sessionId that list_files prints, rather than guessing. Release it with use_file({ release: true }) to go back to following the foreground file.

Contributing

Contributions are welcome. See CONTRIBUTING.md for how to get set up and open a pull request, and AGENTS.md for the architecture, repo layout, tech stack, and conventions.

What's in the name

figwright follows the -wright tradition, an old English word for a maker or craftsman: a playwright writes plays, a shipwright builds ships, a wheelwright, wheels. The name is a nod to Playwright, which automates the browser. Where Playwright drives the browser, Figwright drives Figma, a maker of designs that both reads the canvas and crafts work back onto it.

License

MIT © Roya

Available Tools

112 tools
add_component_propertyA

Declare a component property on a component (or its variant set): BOOLEAN (show/hide a layer), TEXT (editable text), or INSTANCE_SWAP (swappable nested instance). The property starts inert — attach it to a layer with bind_component_property (BOOLEAN→visible, TEXT→characters, INSTANCE_SWAP→mainComponent) for it to do anything. defaultValue must match the type (boolean / string / a component key string); preferredValues (INSTANCE_SWAP only) pre-populates the swap menu. VARIANT properties come from combine_as_variants, not here. Returns { ok, componentId, propertyId, name } — pass propertyId to bind / edit / delete / set_instance_properties.

Inputs: name (required), type (required), componentId (required), defaultValue (required), +1 more.

add_pageA

Create a new page (optionally named). Returns { ok, nodeId, name, type }.

Inputs: name.

add_variable_modeA

Add a mode (e.g. "Dark") to a variable collection. Returns { ok, modeId, name }. Mode count is gated by the file's Figma plan (Starter allows 1 per collection) — when the plan blocks a new mode this fails with guidance: fall back to a paired collection (e.g. "Color/Dark") holding the same variable names with that theme's values.

Inputs: name (required), collectionId (required).

analyze_projectA
Read-only

Detect the local project profile (framework, language, styling system, component file extensions, svg handling) by reading manifests and config — the foundation scan_components / component_map switch on. Optional standalone probe: those tools run detection internally and return the same profile, so call this only to inspect detection in isolation (no Figma, no file scan). Runs on the server filesystem. rootDir defaults to the server cwd. Detects Tailwind v3 (config file) and v4 (CSS-first @import/@theme) and reports tailwindVersion; detects svg loader (svgr / vite-svg-loader / …) → svg.mode component vs url + an import hint.

Inputs: rootDir.

apply_animation_styleA

Apply a Figma Motion animation-style preset to a node (get styleIds from get_motion_styles). config tunes it: duration (seconds), timelineOffset (seconds — the lever for staggered entrances: give each node index * step), and preset-specific props. Returns { ok, nodeId, appliedStyleId } — keep appliedStyleId to remove exactly this instance later. To stagger a whole row in one atomic, undoable call, drive N apply_animation_style ops through batch with increasing timelineOffset. Motion is a Figma-Design-only beta feature.

Inputs: nodeId (required), styleId (required), config.

apply_manual_keyframe_trackA

Set a hand-authored Figma Motion keyframe track on a node for one field — e.g. TRANSLATION_X, OPACITY, ROTATION, SCALE_XY, or an indexed fills / strokes / effects item. field selects what to animate; track carries an optional baseValue plus keyframes (each with timelinePosition in seconds, a typed value, and optional easing). Replaces any existing track on that field. Returns { ok, nodeId }. Motion is a Figma-Design-only beta feature.

Inputs: field (required), track (required), nodeId (required).

apply_style_to_nodeA

Bind a shared style to a node. field selects which slot the style applies to: fill / stroke / effect / grid / text. Returns { ok, nodeId }.

Inputs: field (required), nodeId (required), styleId (required).

batchA

Apply multiple invertible write ops atomically (all-or-nothing with rollback). ops is an ordered list of { tool, params } where tool is an invertible write (e.g. set_fills, rename_node, move_nodes, create_frame). Destructive ops (delete_*, ungroup_nodes, …) are rejected. Returns { ok, results } with one result per op in order.

Inputs: ops (required).

batch_rename_nodesA

Rename many nodes at once from a [{ nodeId, name }] list. Missing nodes are skipped. Returns { ok, affected }.

Inputs: renames (required).

bind_component_propertyA

Attach a declared component property (from add_component_property) to a sublayer field so it drives that layer: field "visible" for a BOOLEAN, "characters" for a TEXT (the node must be a TEXT node), "mainComponent" for an INSTANCE_SWAP (the node must be an INSTANCE). The same property can be bound to several layers (call once per layer). Pass propertyId: null to remove the binding on that field. The property's type must match the field and it must exist on the containing component. Returns { ok, nodeId }.

Inputs: field (required), nodeId (required), propertyId (required).

bind_variable_to_nodeA

Bind a variable to a node field (e.g. width, height, characters, itemSpacing, topLeftRadius, or cornerRadius to bind all four corners at once), or unbind by passing variableId: null. The variable's resolvedType must match the field's type. To bind a fill or stroke color use bind_variable_to_paint instead; get bindable variable ids from get_variable_defs. Returns { ok, nodeId }.

Inputs: field (required), nodeId (required), variableId (required).

bind_variable_to_paintA

Bind a COLOR variable to a SOLID fill or stroke paint (the design-token way to colour a node) — or unbind by passing variableId: null. Figma stores fill/stroke colour bindings on the paint, not the node, so this is separate from bind_variable_to_node (which covers scalar fields like width / padding / radius). target is fills (default) or strokes; index selects which paint (default 0). The paint at that index must be SOLID. Returns { ok, nodeId }.

Inputs: nodeId (required), variableId (required), index, target.

clone_nodeA

Duplicate a node — including its full subtree — and place the copy as a sibling right after the original under the same parent. Cloning a component instance keeps it an instance; to make a fresh instance of a component use create_instance instead. Returns { ok, nodeId, name, type } for the copy.

Inputs: nodeId (required).

combine_as_variantsA

Combine two or more existing COMPONENT nodes into a single COMPONENT_SET (a variant set). Name each component with Figma variant syntax (e.g. "Size=Small", "Size=Large") beforehand so the set derives its properties. The components are reparented into the new set under parentId (default: the first component's current parent). Returns { ok, nodeId, name, type }.

Inputs: nodeIds (required), name, parentId.

component_mapA
Read-only

Map the Figma component instances in a selection/subtree to existing local code components, so they can be reused instead of regenerated. Joins the grounded Figma component names (and their variant axes) against an AST scan of the project; an explicit docs/figma-component-map.md row (FigmaName | code/path) overrides the fuzzy match — this file is the durable record a verified mapping is written back to, so the next run reuses it instead of re-guessing. A row whose target no longer resolves (deleted/renamed) is reported in staleOverrides and degrades to the fuzzy result rather than a phantom import. Each distinct component is mapped once with all its instance ids. A mapped candidate also reports matchedProps (Figma axes the component already has) and unmatchedProps (axes it lacks → component-extension TODOs). Returns { mappings (candidate + confidence + status high/medium/low/unmapped), unmapped, staleOverrides, profile }.

Inputs: nodeId, rootDir, threshold.

create_componentA

Create a reusable main component. Pass fromNodeId to convert an existing node into a component (e.g. a frame of vectors from import_svg, or a built layout) — it keeps the node's position and parent unless parentId is given; omit fromNodeId to create an empty component to build into. Then create_instance the result to reuse it. Optionally sized / named / positioned and placed under a parent (default: current page). Returns { ok, nodeId, name, type }.

Inputs: x, y, name, width, +3 more.

create_effect_styleA

Create a local effect style. Shadows (DROP_SHADOW / INNER_SHADOW) need color + offset; blurs (LAYER_BLUR / BACKGROUND_BLUR) need radius. Returns { ok, styleId, name }.

Inputs: name (required), effects (required), description.

create_ellipseA

Create an ellipse (a circle when width equals height), optionally sized/named/positioned under a parent (default: current page). To turn it into a pie, arc, or ring afterwards use set_arc. Returns { ok, nodeId, name, type }.

Inputs: x, y, name, width, +2 more.

create_frameA

Create a frame — the primary container for UI and the only node that hosts auto-layout — optionally sized/positioned and appended to a parent (default: current page). Enable auto-layout afterwards with set_auto_layout; for a canvas-level grouping container use create_section instead. Returns { ok, nodeId, name, type }.

Inputs: x, y, name, width, +2 more.

create_grid_styleA

Create a reusable local layout-grid style for aligning content. Each grid pattern is GRID (uniform squares via sectionSize) or ROWS / COLUMNS (count + gutterSize + alignment). Apply it to frames with apply_style_to_node. Returns { ok, styleId, name }.

Inputs: name (required), grids (required), description.

create_instanceA

Instantiate a component. Provide componentId (a local COMPONENT node) or componentKey (a published component imported via the API). Optionally name / position / parent the instance. Returns { ok, nodeId, name, type } for the new instance.

Inputs: x, y, name, parentId, +2 more.

create_paint_styleA

Create a reusable local paint (color) style from SOLID or gradient paints (same shape as set_fills); use slashes in the name for folder grouping. Apply it to nodes with apply_style_to_node, or edit it later with update_paint_style. Returns { ok, styleId, name }.

Inputs: name (required), paints (required), description.

create_rectangleA

Create a rectangle, optionally sized/positioned and appended to a parent (default: current page). Useful for solid shapes, dividers, and color blocks; for a container that holds other layers use create_frame, and for placed bitmaps use import_image. Returns { ok, nodeId, name, type }.

Inputs: x, y, name, width, +2 more.

create_sectionA

Create a section: a canvas-level container for grouping and labelling regions of a page (e.g. flows or screen sets). Sections sit on a page or nest inside another section, but not inside a frame; for a UI container or auto-layout use create_frame instead. Returns { ok, nodeId, name, type }.

Inputs: x, y, name, width, +2 more.

create_textA

Create a new TEXT node with the given characters (default font loaded automatically), optionally sized/positioned and appended to a parent (default: current page). To change the text of an existing node use set_text; for font, size, or color use set_text_properties. Returns { ok, nodeId, name, type }.

Inputs: characters (required), x, y, fontSize, +1 more.

create_text_styleA

Create a reusable local text style (a typography token) that can be applied to TEXT nodes with apply_style_to_node. The font is loaded before assignment. lineHeight unit is AUTO / PIXELS / PERCENT (AUTO omits value); letterSpacing unit is PIXELS / PERCENT. For one-off formatting of a single node use set_text_properties instead. Returns { ok, styleId, name }.

Inputs: name (required), fontName, fontSize, lineHeight, +2 more.

create_variableA

Create a variable in a collection with resolvedType BOOLEAN / FLOAT / STRING / COLOR. The variable starts empty — set per-mode values with set_variable_value, then attach it with bind_variable_to_node or bind_variable_to_paint. EASING and TIMING variables cannot be created by plugins at all — Figma rejects it; they can only be made in the Figma UI. Returns { ok, variableId, name }.

Inputs: name (required), collectionId (required), resolvedType (required).

create_variable_collectionA

Create a variable collection. Figma auto-creates a default mode. Returns { ok, collectionId, defaultModeId, name }.

Inputs: name (required).

delete_component_propertyA
Destructive

Remove a BOOLEAN / TEXT / INSTANCE_SWAP property from a component and every sublayer reference to it. VARIANT properties are the variant-set structure — delete their variants instead; this refuses a VARIANT. Get current property ids from get_component_api. Returns { ok, componentId, propertyId, name }.

Inputs: propertyId (required), componentId (required).

delete_nodesA
Destructive

Permanently delete nodes by id; missing or non-removable nodes are skipped. To hide nodes reversibly instead of deleting them, use set_visible(false). Returns { ok, affected } — the ids actually removed.

Inputs: nodeIds (required).

delete_pageA
Destructive

Delete a page by id. The current page and the last remaining page cannot be deleted. Returns { ok, nodeId }.

Inputs: pageId (required).

delete_styleA
Destructive

Delete a local style (paint / text / effect / grid) by id. Returns { ok, styleId, name }.

Inputs: styleId (required).

delete_variableA
Destructive

Delete a single variable by id; any node or paint bound to it reverts to its raw value. To delete an entire collection and all its variables use delete_variable_collection. Returns { ok, variableId, name }.

Inputs: variableId (required).

delete_variable_collectionA
Destructive

Delete a variable collection by id, removing the collection and every variable and mode in it; bindings to those variables revert to their raw values. To delete a single variable instead, use delete_variable. Returns { ok, collectionId, name }.

Inputs: collectionId (required).

design_diffA
Read-only

Diff a Figma node against a saved baseline of itself, so after a design changes you edit only the affected code instead of regenerating. First call on a node saves a baseline (its get_design_context, full detail) under .figwright/snapshots/ and returns status 'baseline-created'; a later call returns status 'diff' with the per-node, per-property changes (added / removed / changed nodes; fills, layout/padding, text, token bindings — resolved to readable values, not opaque ids) or 'no-changes'. Pass update:true to accept the current design as the new baseline (re-snapshot). nodeId defaults to the selection; rootDir defaults to the server cwd. The baseline is a plain file the tool writes under the project — committing it (so teammates share the baseline) or gitignoring it is your call; the tool never changes git. It never mutates Figma. Scope by a component / section nodeId, the same unit codegen works on.

Inputs: nodeId, update, rootDir.

detach_instanceA
Destructive

Detach a component instance into a plain frame, permanently breaking its link to the main component; the frame keeps its current appearance and its layers become directly editable. To switch an instance to a different component instead of detaching, use swap_component. Returns { ok, nodeId, name, type } for the resulting frame.

Inputs: instanceId (required).

edit_component_propertyA

Change an existing component property: rename it, change its defaultValue, or (INSTANCE_SWAP only) change its preferredValues. Supply at least one. Renaming returns a new propertyId (the #id suffix is kept but the name part changes), so use the returned propertyId for later calls; existing bindings keep working. Get current property ids from get_component_api. Returns { ok, componentId, propertyId, name }.

Inputs: propertyId (required), componentId (required), name, defaultValue, +1 more.

export_pdfA
Read-only

Export a node (or the current page) to a single-page vector PDF file on disk. Figma's plugin API renders one PDF page per node and cannot paginate a page into one-frame-per-page or merge multiple nodes into a multi-page file. Pass a frame / section / component id for a vector PDF of that node; omit nodeId for the current page (large pages can be slow). For raster output (PNG/JPG) use save_screenshots instead. Returns { nodeId, path, empty? }; path is null if the target is missing or not exportable, and empty:true means it rendered a blank PDF.

Inputs: outPath (required), nodeId.

export_videoA
Read-only

Export an animated Figma top-level frame to an MP4 / WebM / GIF file on disk. Pass any node in the frame (or the frame itself) — its enclosing top-level frame is encoded across the animation's duration. Requires the Figma Design editor and a frame with animated content (Smart Animate / Motion keyframes); a static frame, a nested frame, or FigJam / Dev Mode yields path:null with a reason (and, when reason is failed, Figma’s own message in error). Encoding is a heavy render — call it on its own, not concurrently with other tool calls, or the render can fail. Returns { nodeId, format, path, reason?, error? }.

Inputs: format (required), nodeId (required), outPath (required), fps, +3 more.

find_replace_textA

Replace a substring across all TEXT nodes under a scope. Without root the whole current page is searched; matching is case-insensitive unless caseSensitive is true. Fonts are loaded before each edit. Returns { ok, affected } — the text node ids changed.

Inputs: find (required), replace (required), root, caseSensitive.

get_annotationsA
Read-only

Return Dev Mode annotations as { annotations: [{ nodeId, nodeName, annotations }] }. With nodeId, returns that node's annotations; without it, scans the current page for all annotated nodes.

Inputs: nodeId.

get_component_apiA
Read-only

Return a component's full property API — the prop contract behind its instances. Pass a COMPONENT, COMPONENT_SET, or INSTANCE id (an instance resolves to its main component / set). Returns { id, name, type, properties } where properties maps each property name to { type (VARIANT|BOOLEAN|TEXT|INSTANCE_SWAP|SLOT), defaultValue, variantOptions?, preferredValues?, description? }. Property names come back verbatim for set_instance_properties: VARIANT by bare name (e.g. "Size"), BOOLEAN/TEXT/INSTANCE_SWAP suffixed with #id (e.g. "Label#2:0"). Unlike get_local_components (a subtree inventory), this targets one component and is safe on large files.

Inputs: nodeId (required).

get_design_contextA
Read-only

Get a depth-limited, token-efficient node tree — the main design-grounding read; prefer it over get_document / get_node for anything large. Starts from nodeId (a pasted Figma URL also works), else the current selection; errors when neither is available. detail: minimal (id/name/type) / compact (+ geometry) / full (+ styling, layout, text and design-system tokens resolved to names plus a deduped globalVars style table). Defaults to full with dedupeComponents true — the code-generation view; pass detail: compact explicitly for a cheap structure scan. An over-budget full result degrades gracefully: first to the compact structure of the same tree (note attached), then to a sectionPlan. depth limits child levels (omit or 0 = unlimited; cut nodes are flagged truncated). dedupeComponents collapses repeated instances of an already-expanded main component (flagged deduped); a deduped instance still carries textOverrides ({ name, characters } — the visible text it actually renders) and propertyOverrides (its per-instance visual diffs), so per-instance content survives without re-expanding the collapsed subtree. A tree too large to return whole comes back as a sectionPlan instead ({ sections: [{ nodeId, name, nodes, … }] } + a note): do not retry unscoped — call again per section nodeId at detail full and build section by section. On a full result, raw color values that exactly equal a project design token are annotated in projectTokens ({ '#6266F0': { ref, name, matchedBy: ['value'] } }, or { matchedBy, candidates: [...] } when several tokens share the value). matchedBy: ['value'] marks every entry as name-blind value-equality evidence — a hypothesis to verify, not a resolved binding: emit the ref only when the token fits the context semantically, keep the raw value otherwise, and let a bound Figma variable win over a raw-value match.

Inputs: depth, detail, nodeId, dedupeComponents.

get_documentA
Read-only

Return the full node tree (recursive children) of the active Figma page, with base geometry, rotation, opacity, cornerRadius, and fills enrichment.

Inputs: no named parameters.

get_fontsA
Read-only

Return every font used on the current page as { fonts: [{ fontName, count }] }, sorted by usage frequency (descending). Mixed-font text contributes one count per styled segment.

Inputs: no named parameters.

get_local_componentsA
Read-only

Return the components and component sets within a node subtree (or the current selection) as { components, componentSets }. Scans a subtree, not the whole document — pass nodeId, or select the frames to scan. Components carry their variantProperties (when part of a set); component sets carry their variantGroupProperties (available values per axis) and the ids of their variant components.

Inputs: nodeId.

get_metadataA
Read-only

Return file metadata: fileName, current page, all page references, and which editor the file is open in (editorType / mode) — "dev" is read-only and "figjam" has no components, variables or styles.

Inputs: no named parameters.

get_motion_stylesA
Read-only

List the file's available Figma Motion animation-style presets — the templates you apply with apply_animation_style. Returns { styles: [{ styleId, name, description?, props? }] }; the styleId is what apply_animation_style takes and props lists a preset’s tunable keys. Motion is a beta feature, only available in the Figma Design editor.

Inputs: no named parameters.

get_nodeA
Read-only

Return one node by id with its full recursive subtree at maximum fidelity — every serialized field (geometry, paints, effects, auto-layout, text with per-run segments, style/variable ids, mainComponent), no depth limit, no deduplication. Best for inspecting a single component or a node you are about to modify; for exploring or grounding anything large, prefer get_design_context (depth-limited, deduped, tokens resolved to names). Returns { node }, null when the id matches nothing.

Inputs: nodeId (required).

get_node_motionA
Read-only

Read a node's Figma Motion (animation) state: applied animation styles, all keyframe animations, manual keyframe tracks, and the timelines it belongs to. Call it before editing to discover styleIds / timelineIds and existing keyframes. Returns { nodeId, motion: { animationStyles, animations, manualKeyframeTracks, timelines } }, with motion: null when the node supports no Motion. Also returns playheadPosition — the editor's Motion playhead in seconds, present only in the Figma Design editor with an active timeline. Use it as a keyframe timelinePosition when the user means "here", i.e. wherever they have scrubbed to.

Inputs: nodeId (required).

get_nodes_infoA
Read-only

Return multiple Figma nodes by id. Output preserves input order; missing ids slot null.

Inputs: nodeIds (required).

get_pagesA
Read-only

Return id+name of every page in the active Figma file.

Inputs: no named parameters.

get_reactionsA
Read-only

Return the prototype reactions on a node as { nodeId, reactions: [{ trigger, actions }] }. Each reaction pairs an interaction trigger (click, hover, timeout…) with its actions (navigate to node, open URL, back/close…).

Inputs: nodeId (required).

get_screenshotA
Read-only

Export nodes as images the model can see, one image block per node: { images: [{ nodeId, format, base64, width?, height?, scale?, recovered?, empty? }] }. format is PNG (default) / JPG / SVG. scale applies to raster formats; when omitted, each node is auto-fitted to a legible size (long edge into ~512–2576px: oversized frames scale down, tiny icons scale up ≤4x) — pass an explicit scale to force one. An explicit scale is capped so the long edge stays within 2576px, the most a vision model resolves: past that the model sees the identical pixels, so the extra bytes buy no detail — use save_screenshots when you need a full-res file on disk. Past 20 nodes in one call the whole batch drops to a 2000px long edge, which is what providers require of many-image requests; ask for fewer nodes when you need the detail. A batch is also capped by total size, not just resolution: a full-page frame is ~2.4MB, so 3–4 of them fill one response. Past that the remaining nodes come back labelled but not inlined, with a note naming them — re-request those ids in a follow-up call, or use save_screenshots for many nodes at once. Each raster label reports the exported width×height px and the scale, the anchor for mapping raster px back to design px. base64 is null for missing or non-exportable nodes. Nodes that are fully clipped or off-canvas (carousels, masks, off-screen states) are auto-recovered at their intrinsic bounds and flagged recovered:true. empty:true means the node genuinely renders nothing even unclipped (hidden / no content) so the export is blank.

Inputs: nodeIds (required), scale, format.

get_selectionA
Read-only

Return the current selection on the active Figma page: { pageId, pageName, nodes }, where each node is a full flat serialization — geometry, fills/strokes/effects, text properties, style/variable ids, mainComponent — without children. The zero-argument "what is the user looking at" call: use it to identify the selected node ids (and page), then walk deeper with get_design_context or get_node. An empty nodes array means nothing is selected.

Inputs: no named parameters.

get_stylesA
Read-only

Return the document's local styles grouped as { paints, texts, effects, grids }. Paint styles carry their paints; text styles carry fontName / fontSize / lineHeight / letterSpacing; effect styles carry their effects; grid styles carry their layout grids.

Inputs: no named parameters.

get_variable_defsA
Read-only

Return the document's local variables as { collections, variables }. Each collection lists its modes and defaultModeId; each variable lists its resolvedType and valuesByMode (primitives, RGBA colors, { type: "VARIABLE_ALIAS", id } references to other variables, or — for an EASING variable — an easing curve { type, easingFunctionCubicBezier?, easingFunctionSpring? }).

Inputs: no named parameters.

get_viewportA
Read-only

Return the current page viewport as { center, zoom, bounds } — the on-screen center point, zoom level (1.0 = 100%), and visible bounds rect.

Inputs: no named parameters.

group_nodesA

Group nodes under their shared parent. nodeIds must be a non-empty list. Returns { ok, nodeId, name, type } for the new group.

Inputs: nodeIds (required), name.

icon_mapA
Read-only

Map the Figma icon nodes in a selection/subtree to the project's existing .svg files, so codegen reuses the designer-curated asset instead of re-exporting a duplicate. Joins the grounded Figma icon names against the repo svg files (gitignore-aware scan), name-based and near-exact (a wrong icon is a silent visual bug, so unsure matches fall through to a fresh export rather than mis-reuse). Each match reports the file path, the color contract read from the file (currentColor / fixed / multi-color), and how to recolor it in this project (currentColor → text-{token}, gated on the svg mode since currentColor dies through an ). It does not fabricate the import line — compose it from the file path and profile.svg (importHint gives the loader form: svgr ?react / vite-svg-loader ?component / { ReactComponent } / url <img>), mirroring the project's existing imports for the alias/relative path. Unmatched icons are returned in unmapped; iconLibraries lists any installed icon component library (lucide / heroicons / iconify) as the alternative to a fresh export. rootDir defaults to the server cwd. Returns { mappings, unmapped, iconLibraries, profile }.

Inputs: nodeId, rootDir, threshold.

import_imageA

Import a raster image (PNG / JPG / GIF) and place it as a rectangle with an IMAGE fill. Provide data (base64-encoded image bytes) or url. The rectangle defaults to the image size unless width/height are given. scaleMode is FILL / FIT / CROP / TILE (default FILL). For vector SVG (logos / icons) use import_svg instead. Returns { ok, nodeId, name, type }.

Inputs: x, y, url, data, +5 more.

import_svgA

Import an SVG and place it as editable vector nodes (a FRAME of VECTOR paths) via createNodeFromSvg — use this for vector logos, brand marks, and icons. Provide the SVG's raw markup string (read it from the project asset, or inline it). The frame defaults to the SVG intrinsic size unless width/height are given. For raster photos (PNG / JPG) use import_image instead; when a matching icon component already exists, create_instance it rather than re-pasting the SVG. Returns { ok, nodeId, name, type }.

Inputs: svg (required), x, y, name, +3 more.

list_filesA
Read-only

Return the files reachable from the plugin as { files: [{ fileKey, fileName, currentPage }] }. A plugin only sees its host document, so this is a single-element list describing the current file.

Inputs: no named parameters.

lock_nodesA

Lock nodes so they can't be selected or edited on the canvas (e.g. backgrounds); locking a parent also locks its descendants. Locked nodes still render and export — this only affects canvas interaction and is reversed by unlock_nodes. Returns { ok, affected } with the ids actually locked.

Inputs: nodeIds (required).

move_nodesA

Translate nodes by (dx, dy). Nodes without a position are skipped. Returns { ok, affected }.

Inputs: nodeIds (required), dx, dy.

pingA
Read-only

Health check. Returns server info plus, when a plugin is connected, end-to-end info from the Figma sandbox. On a follower it also reports the leader’s version and build, and warns (versionSkew / buildSkew) when a stale older server still owns the plugin.

Inputs: no named parameters.

remove_animation_styleA
Destructive

Remove an applied Figma Motion animation style from a node. Pass animationStyleId (the appliedStyleId returned by apply_animation_style, or read from get_node_motion) to remove one; omit it to remove all applied styles on the node. Returns { ok, nodeId }.

Inputs: nodeId (required), animationStyleId.

remove_manual_keyframe_trackA
Destructive

Remove the manual Figma Motion keyframe track for a given field on a node. field selects the same target as apply_manual_keyframe_track (a node PROPERTY or an indexed fills/strokes/effects item). Returns { ok, nodeId }.

Inputs: field (required), nodeId (required).

remove_reactionsA
Destructive

Clear every prototype reaction from a node (equivalent to set_reactions with an empty array). Use this to strip interactivity; to replace reactions with new ones use set_reactions. Returns { ok, nodeId }.

Inputs: nodeId (required).

rename_nodeA

Rename a single canvas node's layer name; does not affect a component's name elsewhere or its instances. To rename a document page use rename_page; to rename many nodes by pattern use batch_rename_nodes. Returns { ok, nodeId }.

Inputs: name (required), nodeId (required).

rename_pageA

Rename a Figma page (a top-level page/tab in the document) by id. Affects only the page name; its node id and contents are unchanged. To rename a layer/node on the canvas use rename_node instead. Returns { ok, nodeId }.

Inputs: name (required), pageId (required).

rename_variableA

Rename a variable (e.g. "color/primary" → "color/brand"); use slashes in the name for folder grouping in the Variables panel. The variable id is unchanged, so existing bindings keep working. Returns { ok, variableId, name }.

Inputs: name (required), variableId (required).

reorder_nodesA

Reorder nodes within their current parent by inserting each at index (0 = bottom of the z-order). Detached nodes are skipped. Returns { ok, affected }.

Inputs: index (required), nodeIds (required).

reparent_nodesA

Move nodes into a different parent, optionally inserting at index (default: appended last). On-screen positions may shift because coordinates become relative to the new parent; nodes that no longer exist are skipped. To reorder within the current parent use reorder_nodes; to wrap nodes in a new frame/group use group_nodes. Returns { ok, affected }.

Inputs: nodeIds (required), newParentId (required), index.

resize_nodesA

Resize nodes to the given width × height (positive). Non-resizable nodes are skipped. Returns { ok, affected }.

Inputs: width (required), height (required), nodeIds (required).

rotate_nodesA

Set absolute rotation (degrees) on nodes. Nodes without rotation are skipped. Returns { ok, affected }.

Inputs: nodeIds (required), rotation (required).

save_image_fillsA
Read-only

Extract the ORIGINAL image bytes behind each node's IMAGE fills and write them to disk under outDir — the source asset exactly as uploaded (no mask, clip, crop, scale, or effects applied), unlike save_screenshots / get_screenshot which re-render the composited node. Returns { nodes: [{ nodeId, images: [{ index, imageHash, format, path, width?, height?, scaleMode? }], mixed? }] }. index is the fill position in node.fills; width/height are the image intrinsic size; scaleMode is how the fill is displayed (FILL / FIT / CROP / TILE); format is sniffed from the bytes (PNG / JPG / GIF / WEBP, or BIN if unrecognized). Identical images (same imageHash reused across nodes) are fetched once and share one file named by hash. path is null when the fill image can't be resolved; images:[] means the node has no image fill; mixed:true means the node's fills are per-text-range and were not enumerated. For a rendered/composited raster use save_screenshots; for a vector node use export_pdf.

Inputs: outDir (required), nodeIds (required).

save_screenshotsA
Read-only

Export nodes and write them to disk under outDir: { saved: [{ nodeId, format, path, recovered?, empty? }] }. format is PNG (default) / JPG / SVG; scale applies to raster formats (default 1). path is null for missing or non-exportable nodes. Nodes that are fully clipped or off-canvas (e.g. a carousel's edge items) are auto-recovered at their intrinsic bounds and flagged recovered:true. empty:true means the node genuinely renders nothing even unclipped (hidden / no content) so the file is blank. Files are named after a sanitized node id.

Inputs: outDir (required), nodeIds (required), scale, format.

scan_componentsA
Read-only

Scan the local project for existing UI components so they can be reused instead of regenerated. Runs on the server filesystem, not in Figma. Identifies components by AST signature (exported, PascalCase, function-ish) rather than by folder layout, so any structure works. React (.tsx/.jsx) is parsed for name + props; Vue/Svelte derive the name from the file and parse props from the block (defineProps / export let / $props). extensions defaults to the detected profile's; rootDir defaults to the server cwd. Returns { components, profile }.

Inputs: rootDir, extensions.

scan_nodes_by_typesA
Read-only

Return a flat list of every node whose type is in types, searched recursively through a subtree scoped by root (a node id) or the current page by default. Use this to collect nodes by kind (e.g. all TEXT or COMPONENT nodes); to search by name or characters use search_nodes, and for a styled tree snapshot use get_design_context. Returns a flat array of matching nodes.

Inputs: types (required), root.

scan_text_nodesA
Read-only

Return every TEXT node within a subtree, each with its characters / fontSize / fontName. Scope with root (a node id); defaults to the current page.

Inputs: root.

search_nodesA
Read-only

Search the node tree by case-insensitive name substring and/or exact node type. At least one of name or type is required. Scope to a subtree with root (a node id); defaults to the current page. Returns a flat array of matching nodes.

Inputs: name, root, type.

set_arcA

Turn an ellipse into a pie slice / gauge or a ring / donut by setting its arc data. startingAngle / endingAngle are in radians and carve out the visible wedge (a full circle is 0 → 2π ≈ 6.28319; a half is π ≈ 3.14159); innerRadius is 0–1 of the radius (0 = a solid disc, > 0 = a ring with a hole, e.g. 0.6 for a donut or progress ring). Only ellipses have arc data. Pass any subset — omitted fields keep their current value. At least one is required. Returns { ok, nodeId }.

Inputs: nodeId (required), endingAngle, innerRadius, startingAngle.

set_auto_layoutA

Configure a frame's auto layout. layoutMode NONE disables it; HORIZONTAL/VERTICAL enable flex (padding / itemSpacing / alignment / wrap, plus counterAxisSpacing / counterAxisAlignContent for the wrapped cross axis — the CSS row-gap / align-content — and itemReverseZIndex / strokesIncludedInLayout for paint order and stroke-in-layout); GRID enables CSS-Grid-style layout (padding / gridRowCount / gridColumnCount / gridRowGap / gridColumnGap). Returns { ok, nodeId }.

Inputs: nodeId (required), layoutMode (required), gridRowGap, layoutWrap, +14 more.

set_blend_modeA

Set how a node composites with the layers beneath it (NORMAL, MULTIPLY, SCREEN, OVERLAY, DARKEN, LIGHTEN, COLOR_DODGE, etc.). PASS_THROUGH is only meaningful on groups/frames (lets children blend with content outside the group). Affects compositing only, not the node's own fills — use set_fills or set_opacity for those. Returns { ok, nodeId }.

Inputs: nodeId (required), blendMode (required).

set_constraintsA

Set how a node responds when its parent frame is resized, via horizontal and vertical constraints: MIN pins to the left/top, MAX to the right/bottom, CENTER keeps it centered, STRETCH pins both edges (grows with the parent), and SCALE resizes proportionally. Constraints apply inside plain frames only — auto-layout frames position children by layout rules and ignore them. Returns { ok, nodeId }.

Inputs: nodeId (required), vertical (required), horizontal (required).

set_corner_radiusA

Set a node's corner radius. Pass radius for a uniform radius, and/or per-corner topLeftRadius / topRightRadius / bottomRightRadius / bottomLeftRadius (for nodes that support individual corners, e.g. a card rounded only on top, a tab or a chat bubble). A per-corner value overrides radius for that corner. At least one of radius or a corner is required. Returns { ok, nodeId }.

Inputs: nodeId (required), radius, topLeftRadius, topRightRadius, +2 more.

set_effectsA

Set a node's effects. Shadows (DROP_SHADOW / INNER_SHADOW) need color + offset; blurs need radius. Returns { ok, nodeId }.

Inputs: nodeId (required), effects (required).

set_fillsA

Set a node's fills. SOLID: { type:'SOLID', color:{r,g,b} } (0–1). Gradient: { type:'GRADIENT_LINEAR'|…, gradientStops:[{position,color:{r,g,b,a}}], gradientTransform } (round-trips get_node output). Returns { ok, nodeId }.

Inputs: fills (required), nodeId (required).

set_instance_propertiesA

Set an instance's component properties (variant / boolean / text / instance-swap). Keys are the property names from get_component_api, used verbatim: VARIANT by bare name (e.g. "Size": "Large"), BOOLEAN/TEXT/INSTANCE_SWAP suffixed with #id (e.g. "Label#2:0": "Sign in", "Disabled#1:2": true). An INSTANCE_SWAP value is the target component node id. Unspecified properties keep their value; SLOT properties are not settable. Returns { ok, nodeId }.

Inputs: instanceId (required), properties (required).

set_layout_gridsA

Set a frame's own layout grids — the responsive column/row scaffold laid over it (the 12-column grid, the 8pt baseline), distinct from auto-layout (set_auto_layout arranges children). Each grid is COLUMNS / ROWS (count + gutterSize + alignment, e.g. a 12-col grid) or GRID (uniform squares via sectionSize, a baseline). Replaces the frame's grids with the array given; pass [] to clear them. Only frames (and components/instances) carry layout grids. Returns { ok, nodeId }.

Inputs: grids (required), nodeId (required).

set_layout_propsA

Set a node's auto-layout sizing and child properties. layoutSizingHorizontal / layoutSizingVertical (HUG = shrink to fit children, FILL = stretch to fill the auto-layout parent, FIXED = keep the current size) are the preferred way to size a frame to its content (HUG) or make a child fill its container (FILL) — reach for these instead of guessing pixel sizes with resize_nodes. layoutAlign (STRETCH = fill the counter axis, INHERIT = default) and layoutGrow (1 = fill the primary axis, 0 = hug) are the older per-axis equivalents. layoutPositioning (ABSOLUTE = ignore the flow and position freely, AUTO = participate in layout). minWidth / maxWidth / minHeight / maxHeight set responsive size bounds (→ min-w / max-w); pass null to clear a bound. Bounds apply to auto-layout frames and their direct children. HUG needs an auto-layout frame (or text); FILL needs an auto-layout parent. Any field may be omitted to leave it unchanged. Returns { ok, nodeId }.

Inputs: nodeId (required), maxWidth, minWidth, maxHeight, +6 more.

set_maskA

Set whether a node is a mask — a mask clips its later siblings to its own shape. Pass isMask true/false, and optionally maskType (ALPHA / LUMINANCE / GEOMETRY) when enabling. Returns { ok, nodeId }.

Inputs: isMask (required), nodeId (required), maskType.

set_opacityA

Set a node's layer opacity from 0 (transparent) to 1 (opaque); this multiplies with any fill or stroke alpha. Opacity 0 still renders, exports, and hit-tests — to exclude a node from rendering use set_visible(false), and to remove it use delete_nodes. Returns { ok, nodeId }.

Inputs: nodeId (required), opacity (required).

set_positionA

Set a node's exact position (x / y), relative to its parent — for a top-level node these are canvas coordinates; for an absolutely-positioned child they are relative to its auto-layout parent. Use this to place an overlay / badge / pinned element at a known spot, or to position a top-level frame on the canvas; to nudge by a delta instead use move_nodes. A node that sits in-flow inside an auto-layout frame is positioned by the layout — set layoutPositioning ABSOLUTE (set_layout_props) first to place it freely. Either coordinate may be omitted to leave it unchanged. Returns { ok, nodeId }.

Inputs: nodeId (required), x, y.

set_reactionsA

Replace all of a node's prototype reactions — this overwrites existing reactions rather than appending. Each reaction pairs a trigger (e.g. { type: 'ON_CLICK' }) with an actions array (e.g. { type: 'NODE', destinationId, navigation, transition }). Best used to round-trip get_reactions output; to clear all reactions instead use remove_reactions. Returns { ok, nodeId }.

Inputs: nodeId (required), reactions (required).

set_strokesA

Set a node's strokes (SOLID or gradient paints, same shape as set_fills) plus optional strokeWeight, strokeAlign (INSIDE / OUTSIDE / CENTER), dashPattern (dashes), and per-side weights (strokeTopWeight / strokeRightWeight / strokeBottomWeight / strokeLeftWeight — for nodes that support individual stroke weights, e.g. a border-bottom-only divider). A per-side weight overrides strokeWeight for that side. Any field may be omitted to leave it unchanged. Returns { ok, nodeId }.

Inputs: nodeId (required), strokes (required), dashPattern, strokeAlign, +5 more.

set_textA

Replace the entire text content of a TEXT node; the plugin loads the node's current fonts first and preserves existing character styling where possible. For formatting (font, size, color, spacing) use set_text_properties, and to substitute text across many nodes use find_replace_text. Returns { ok, nodeId }.

Inputs: nodeId (required), characters (required).

set_text_propertiesA

Set a TEXT node's typography and layout/overflow properties. Typography: fontName ({ family, style }), fontSize, lineHeight, letterSpacing, textCase, textDecoration, paragraphSpacing / paragraphIndent (px between / indenting the paragraphs the text splits into at "\n" — the write half of the same fields get_design_context reads) — these load the required fonts first. Layout/overflow: textTruncation (ellipsis), maxLines (line clamp), textAutoResize. Any field may be omitted to leave it unchanged. maxLines applies when textTruncation is ENDING. Returns { ok, nodeId }.

Inputs: nodeId (required), fontName, fontSize, maxLines, +8 more.

set_text_rangeA

Style character ranges of an existing TEXT node — the write-side mirror of a read segment, for inline rich text (a link inside a sentence, a bold word, a coloured span, a bulleted list, a smaller /mo after a price). Each range gives start/end (char offsets into the node's characters) plus any subset of run properties: fontName / fontSize / fills / textDecoration / textCase / lineHeight / letterSpacing / hyperlink / listOptions / indentation, and design-system bindings textStyleId / fillStyleId / boundVariables. Ranges apply in order (a later range overrides an earlier one on overlap). Fonts are loaded automatically. Set the whole node first with create_text / set_text; use set_text_properties for node-level typography & overflow. Returns { ok, nodeId }.

Inputs: nodeId (required), ranges (required).

set_timeline_durationA

Set the duration (in seconds, must be > 0) of a Figma Motion timeline. Get the timelineId from get_node_motion (a node's timelines). Returns { ok, nodeId }.

Inputs: nodeId (required), duration (required), timelineId (required).

set_variable_code_syntaxA

Declare a variable's code-side token name per platform (codeSyntax) — the write half of the codeSyntax that get_design_context / get_variable_defs surface to codegen as the authoritative name (e.g. WEB: "--color-primary"). Per platform (WEB / ANDROID / iOS): a non-empty string sets the declaration, null removes it, an omitted platform is untouched. When authoring design-system variables from existing code tokens, declare the source token name here so future codegen resolves to the exact token instead of deriving a name. Returns { ok, variableId, name, codeSyntax } with the declarations now in effect.

Inputs: codeSyntax (required), variableId (required).

set_variable_valueA

Set a variable's value for one mode (modeId comes from the variable's collection). value must match the variable resolvedType: a boolean, a number (FLOAT), a string, a color { r, g, b, a } (0–1), or an alias { type: "VARIABLE_ALIAS", id } pointing at another variable. EASING and TIMING variables are read-only to plugins — Figma rejects editing them, so read them with get_variable_defs and change them in the Figma UI instead. Create the variable first with create_variable. Returns { ok, variableId, name }.

Inputs: value (required), modeId (required), variableId (required).

set_visibleA

Show or hide a node by toggling its visible flag. A hidden node stays in the layer tree but is excluded from rendering and exports, and its descendants are hidden with it; the change is fully reversible. To remove a node use delete_nodes; to dim one while keeping it visible and exported use set_opacity. Returns { ok, nodeId }.

Inputs: nodeId (required), visible (required).

swap_componentA

Swap an instance's main component. Provide componentKey (published component, imported via the API) or componentId (a local COMPONENT node). Returns { ok, nodeId } (the instance id).

Inputs: instanceId (required), componentId, componentKey.

token_mapA
Read-only

Map the document's Figma variables — and its shared paint styles (single solid color styles, the design-token mechanism of pre-variables files; such rows carry source: 'style') — to the project's design tokens, so generated code references existing tokens instead of hard-coded values. Joins the grounded Figma names + values against tokens parsed from the project CSS (Tailwind v4 @theme or :root custom properties); the match is name-based with an exact color value-match as confirmation. When several project tokens share the exact same color value and the name cannot pick one, the mapping is capped below 'high' and candidate.ambiguousWith lists the other same-value tokens — verify that pick semantically instead of trusting it blindly. On a Tailwind project a variable that hits a framework built-in scale (spacing/N, line-height/N, weight/*) is reported as status 'framework-builtin' with { builtin: { scale, step } } rather than unmapped — it has no @theme token but the utility (p-4 / gap-4, leading-7, font-bold) is still usable. A variable in a multi-mode collection whose value differs per mode (a Light/Dark theme) carries figmaModes (mode name → value per theme; figmaValue is only the default mode), and the result lists themedCollections — keep such tokens theme-aware (a token that itself switches per theme, or the non-default values wired through the project's dark-mode mechanism), never just the default-mode literal. tokenSource overrides the detected styling config; rootDir defaults to the server cwd. Tailwind v3 JS configs are not yet parsed (pass tokenSource to a CSS file). An explicit docs/figma-token-map.md row (FigmaName | ref) overrides the fuzzy join with matchedBy ["map-file"] — this file is the durable record a verified token mapping is written back to, so the next run reuses it instead of re-guessing an ambiguous or value-only match. A row whose ref no longer resolves to a project token is reported in staleOverrides and degrades to the normal join. Returns { mappings (candidate + confidence + status + matchedBy + builtin), unmapped, staleOverrides, tokenSource, profile }.

Inputs: rootDir, threshold, tokenSource.

ungroup_nodesA
Destructive

Ungroup GROUP nodes by id; non-group nodes are skipped. Returns { ok, affected } — the ids of the children promoted out of the groups.

Inputs: nodeIds (required).

unlock_nodesA

Unlock nodes so they can be selected and edited on the canvas again — the inverse of lock_nodes. Ids that no longer exist are skipped. Returns { ok, affected } with the ids actually unlocked.

Inputs: nodeIds (required).

update_effect_styleA

Update an existing effect style by id. Any of name / effects / description may be omitted to leave unchanged; effects, when given, replaces the whole list. Shadows (DROP_SHADOW / INNER_SHADOW) need color + offset; blurs (LAYER_BLUR / BACKGROUND_BLUR) need radius. Use this to keep a shared style in sync with code instead of creating a duplicate. Returns { ok, styleId, name }.

Inputs: styleId (required), name, effects, description.

update_paint_styleA

Update an existing paint style by id. Any of name / paints / description may be omitted to leave unchanged. Returns { ok, styleId, name }.

Inputs: styleId (required), name, paints, description.

update_text_styleA

Update an existing text style (typography token) by id. Any of name / fontName / fontSize / lineHeight / letterSpacing / description may be omitted to leave unchanged. A new font is loaded before assignment. lineHeight unit is AUTO / PIXELS / PERCENT (AUTO omits value); letterSpacing unit is PIXELS / PERCENT. Use this to keep a shared style in sync with code instead of creating a duplicate. Returns { ok, styleId, name }.

Inputs: styleId (required), name, fontName, fontSize, +3 more.

Tool Schema Changelog

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

Loading tool schema changelog…

    TDQS

    A4.1/5.0

    Scored across 112 tools

    Disambiguation4/5

    Most tools have a clearly distinct target, and descriptions go out of their way to cross-reference near-neighbors (get_node vs get_design_context, set_text vs set_text_properties vs set_text_range, rename_node vs rename_page vs batch_rename_nodes). Still, there is genuine overlap in the read surface: get_document, get_node, get_design_context, get_nodes_info, get_selection, get_metadata, scan_text_nodes, scan_nodes_by_types and search_nodes all read nodes with subtle scope/detail differences that require careful reading to pick among. That is a lot of overlapping retrieval tools in one namespace.

    Naming Consistency5/5

    The verb_noun snake_case convention is followed nearly everywhere (set_fills, create_frame, delete_nodes, bind_variable_to_paint, get_design_context). A couple of compound names (find_replace_text, combine_as_variants) are still readable and in-pattern. No camelCase or style drift.

    Tool Count2/5

    112 tools is a severe mismatch for a single MCP surface. Even with the batch and map tools justified, the read/scan/node-creation/style/variable/motion splits push this far past what an agent can hold in working context, and the count itself creates selection noise independent of any individual description.

    Completeness5/5

    Coverage is exhaustive: creation, mutation, deletion, grouping, variables/modes, styles, prototyping reactions, Motion keyframes, screenshots/exports, project scanning and Figma↔code mapping, plus an atomic batch wrapper. I can't identify a meaningful lifecycle gap for a Figma automation server.

    Maintenance

    ActivityActive
    ResponsivenessOutdated data

    Related MCP Connectors

    Related MCP Servers

    • A
      license
      A
      quality
      D
      maintenance
      Write-side MCP server for Figma — build, edit, and search Figma designs from Claude Code, Cursor, Cline, or any MCP client. Complements Figma's official read-only MCP with 41 tools for tree creation, variables, components, and visual verification.
      41
      3
      MIT
    • A
      license
      B
      quality
      D
      maintenance
      Enables AI agents to directly control Figma Desktop via MCP, supporting UI creation, editing, prototyping, and variable management with over 60 tools.
      65
      1
      MIT
    • A
      license
      Not graded
      quality
      B
      maintenance
      Local MCP server exposing Figma REST API tools to AI agents, enabling file reads, comments, variables, and other resource operations. Works with personal access tokens and integrates with Claude, Cursor, Codex, and more.
      MIT
    • A
      license
      Not graded
      quality
      A
      maintenance
      Enables AI agents to read and write Figma designs through a local WebSocket relay, turning Figma selections into framework-aware code and building/editing designs directly on the canvas. Provides 112 MCP tools for bidirectional design-code workflows with support for any MCP client.
      MIT

    Appeared in Searches