Figbridge MCP server

Read from the package source without running it. The installed server may list more.

• apply_tokens

  Bind loose SOLID color fills to matching local color variables (matched by exact hex). Scope is a nodeId or the current selection. Returns { bound, unboundRemaining, availableColorVariables }.

• audit_a11y

  Audit accessibility of an imported Figma frame. Returns WCAG contrast pass/fail counts (AA 4.5 normal / 3.0 large), per-failure list with measured ratio and node text, landmark coverage, and image nodes without descriptive names. Pure deterministic measurement — no LLM.

• audit_interactions

  Discover hover/focus-capable elements on a URL before attempting prototype variant capture. Returns interactive elements plus CSS :hover/:focus selector counts and examples. Use this to decide which components need hover variants.

• audit_mobile

  Render a URL across mobile (375) / tablet (768) / desktop (1280) viewports and report responsive issues: horizontal page scroll, elements overflowing the viewport, touch targets < 44×44 (Fitts), text < 12px (unreadable on phone), and fixed-position traps taller than 50% of viewport. Pure deterministic measurement — no LLM. Run after audit_palette / audit_typography / audit_a11y for the full Pillar

• audit_palette

  Audit color usage in an imported Figma frame. Returns total distinct colors, top-10 by frequency, coverage curve (how many of top-N cover X% of usage), and near-duplicate merge suggestions for consolidation. Pure deterministic measurement — no LLM.

• audit_regression

  Compare a baseline URL and candidate URL to find frontend/UI regressions. Runs deterministic screenshot pixel diffs across desktop/tablet/mobile, visible-text disappearance checks, responsive issue deltas, and CSS-feature drift. Use before/after a frontend change, in CI, or before syncing updated UI into Figma.

• audit_typography

  Audit typography in an imported Figma frame. Returns distinct font sizes / families / styles, the (family, style, size) triplet frequency, and which standard modular scale (1.25 / 1.333 / golden ratio / etc.) the existing sizes best fit. Surfaces a suggested clean scale from the base size.

• audit_whitespace

  Audit spacing rhythm of an imported Figma frame. Returns padding / gap distributions, percentage divisible by 4 / 8 (grid conformance), and off-grid stragglers that break the spacing system.

• bridge_status

  Health check for the Figbridge HTTP bridge and the stored payload. Also reports whether a plugin is currently connected (pluginConnected).

• clone_screen

  Duplicate a frame (screen) inside Figma, optionally renaming it and applying text replacements to every TEXT child. Places the clone to the right of the source. Returns { nodeId, name, textReplacements }.

• delete_nodewrite action

  Delete a Figma node by id, a list of ids, or by exact name. Returns { deleted, errors }. Use this to clean up junk frames between imports.

• demarcate

  Demarcate a page's components — numerically AND visually. Returns the same mathematical layout metrics as measure_layout, plus writes a PNG with every repeated-component group boxed in its own colour (so the component boundaries and the grid are unmistakable). Use to SEE and MEASURE the structure of a mockup or a rendered app in one call.

• describe_screen

  Return a semantic description of a single screen: size, background color, all text content, components used, inferred category, and a one-paragraph natural-language summary. Useful for agents that want to reason about a screen without fetching its full HTML.

• diff_images

  Compare two image files (any PNGs — Figma exports, mockup screenshots, rendered pages). Returns a raw-pixel score (0-100), a perceptual SSIM score (0-1, tolerant of anti-aliasing / sub-pixel shifts), hotspot diff regions, and writes three legible artifacts to disk that you Read() to SEE the difference: `overlay` (onion-skin — image B with image A at 50% on top), `montage` (A | B | overlay side-by-

• diff_since

  Return history entries captured after the given timestamp (milliseconds since epoch). Each entry includes a 12-char SHA-1 fingerprint of the payload so you can detect real content changes vs re-selections.

• diff_specs

  Fast structured-only diff between two rendered URLs (no screenshots). Extracts a computed-style spec from each and reports a categorized, severity-sorted punch-list of exact field-level differences: copy (text), color (fill/text/stroke), typography (font family/size/weight/…), spacing (layout/gap/padding/align/radius/size), and structure (nodes present on one side only). Use for tight refine loops

• diff_to_source

  Compare an imported Figma frame against the freshly-extracted source URL spec and report per-text-node field-level differences: characters, fontSize, fontFamily, color, plus presence (nodes that exist on one side but not the other). Use after the designer edited a frame to see exactly what diverged from source — the input to generate_patch. Pure deterministic measurement, no LLM.

• export_all_pages

  Export every page's top-level frames in one call. Returns { pageCount, pages: [{ pageId, pageName, frameCount, html, css, tailwindHtml, tokens, cssVars }] }. Use for whole-file handoff; prefer get_agent_bundle for agent-ready output.

• export_app_spec

  Return a complete JSON catalog of the currently open Figma file: every screen, every component (with variants), design tokens, CSS variables, Tailwind config, screens grouped by category, and a per-page flow ordering. Drop this into an agent's context as the authoritative spec for the app.

• export_frame

  Export a Figma frame as PNG. With `outPath`: writes to disk, returns path. Without: returns base64. Use to pull a rendered version of an imported frame back out for visual diff.

• export_node

  Trigger the plugin to export a specific node (by id) without requiring the user to click. Returns the same payload shape as get_current_selection.

• fingerprint_url

  Audit a URL's CSS-feature usage in one call — returns counts of flexbox/grid/gradients/shadows/filters/blends/transforms/pseudo-elements/iframes/etc, plus tag mix and color/font palette. Run BEFORE bigger fidelity pushes to know where the actual coverage gaps are. Returns { totalElements, topTags, displays, positions, features, colors[], fonts[] }.

• generate_patchwrite action

  Turn a diff_to_source result into a minimal patch plan against a local source directory. For text-content changes, finds the exact old string in HTML/JSX/TSX/etc and emits a before/after edit. For color / fontSize / fontFamily changes, surfaces a structured note pointing at candidate CSS files (style swaps usually want a token edit, not a literal replacement). No files are written — the caller dec

• get_agent_bundle

  Build an LLM-ready handoff bundle from the currently selected frames (or current page if nothing selected). Returns a list of files: hierarchy.md, components.json, tokens.json, tokens.css, DESIGN.md, AGENTS.md, ISSUES.md, issues.json, snapshot.json, manifest.json, optional CHANGES.md (if prior snapshot exists), optional responsive.md/json, optional flow.mmd, per-variant .tsx + .stories.tsx, option

• get_current_selection

  Get the most recent Figma selection pushed from the Figbridge plugin, in the requested format.

• get_last_export

  Alias for get_current_selection. Returns the last pushed Figbridge payload.

• get_tokens

  Get only the design-token payload (color + number variables, plus CSS variable file and Tailwind config).

• import_from_codewrite action

  Create a real Figma frame (auto-layout, text, fills, radii — editable layers, not a flattened image) directly from code. Provide ONE of: `spec` (deterministic JSON tree — preferred), `html` (raw HTML string — best-effort element→frame mapping), or `htmlPath` (read file from disk, then parse as html). Top-level spec shape: { name, width?, height?, fill?, layout: 'VERTICAL'|'HORIZONTAL'|'NONE', padd

• import_responsive_set

  Import a URL at multiple viewport widths and optional light/dark color schemes in one call. Creates one Figma frame per width/theme combination, or returns telemetry only with dryRun. This is the multi-viewport capture path for desktop/tablet/mobile and theme sets. Default widths: 1280, 768, 375. Returns { frames: [{ width, colorScheme, nodeId, name, createdCount, telemetry }] }.

• import_url

  Render a URL in headless Chrome (figbridge-managed), walk the DOM with computed styles, and create the resulting frame tree in Figma. The single highest-fidelity path from web → Figma. Returns { nodeId, name, createdCount, warnings }.

• import_url_batch

  Bulk-import multiple URLs using the same website-to-Figma pipeline as import_url/import_responsive_set. Each URL can be imported at one or more widths and optional light/dark themes. Use dryRun first for large batches. Returns { results: [{ url, frames: [...] }] }.

• lint_ds

  Lint the file for design-system violations: unbound colors (SOLID fills not using a variable), non-grid spacing (padding/gap not divisible by 4), orphan components (defined but never instanced), and duplicate names. Returns findings grouped by rule.

• list_assets

  Export bulk assets from the file as base64. kind='icon' scans small vector frames + names like ic-* and exports SVG. kind='image' finds IMAGE-fill nodes and exports PNG@2x. kind='illustration' finds large vectors on 'Illustrations' pages and exports SVG. limit caps the number of assets returned (default 40).

• list_components

  List local components and component sets (with variants) in the currently open Figma file. Returns [{ nodeId, name, kind: 'COMPONENT' | 'COMPONENT_SET', variantCount?, variants? }].

• list_frames

  List the top-level layers on a specific page (or the current page). Returns [{ id, name, type, width, height, hasChildren }]. Use this to walk the file without exporting.

• list_history

  List recent Figma selections that have been pushed (metadata only, newest first).

• list_pages

  List every page in the currently open Figma file: { id, name, frameCount, isCurrent }. Cheap — use this before list_screens / list_frames to orient.

• list_screens

  List every top-level frame (screen) across pages in the currently open Figma file. Each result has { nodeId, name, pageName, width, height, category, orderHint }. Category is inferred from name: splash | onboarding | auth | home | detail | settings | overlay | editor | search | state | commerce | error | other. Requires the Figbridge plugin to be open with Live bridge on.

• map_components

  Index an app's source tree so figbridge understands the codebase it's generating against. Returns the maps that let a mockup-vs-app diff name the file to edit: data-testid / data-component → { file, line }, component-name → file, and :root design tokens (value ↔ var name). Run once to inspect the mapping, or just pass `sourceDir` to match_mockup which builds it internally. Returns { ok, fileCount,

• match_mockup

  Closed visual-diff loop — the grounded feedback signal for making a running app match an HTML mockup. Renders BOTH the mockup and the app, returns (a) per-viewport pixel similarity + hotspot regions and (b) a prioritized, categorized punch-list of exact field-level differences (copy/color/typography/spacing/elevation/icon/structure) with the node path for each. Pass `sourceDir` to make it codebase

• measure_fidelity

  Phase 6 — compute pixel-similarity score between the live URL and a Figma frame export. Returns { score (0-100), diffPercent, regions[] }. The diff regions are the top spots where the import diverges from the live page — feed these back into the extractor for targeted fixes.

• measure_layout

  Mathematical layout metrics for a URL — numbers an agent can reason over directly (more actionable than a screenshot). Returns the inferred GRID (column/row count, column pitch, gutter, cell size, size-regularity) from the dominant repeated component; ALIGNMENT (count of shared vertical/horizontal edge lines + a snap score); SPACING (detected base unit e.g. 8px, the spacing scale, % off-grid); the

• preflight_import

  Check a URL for common website-to-Figma import risks before spending time on a full import: bot-protection/captcha pages, HTTP errors, missing-font risk, low-resolution images, SVG-heavy pages, deep wrapper nesting/auto-layout noise, horizontal scroll, and very tall pages. Run this before import_url/import_responsive_set/import_url_batch.

• probe_url

  Render a URL in headless Chrome and run an arbitrary JS snippet inside the page. Use to inspect the live DOM / computed styles when planning an extraction. Replaces external chrome-devtools-mcp.evaluate_script. Snippet is the async-function body; use `return` for the result. Returns { ok, result }.

• recolor

  Swap SOLID fill/stroke colors across a scope. Scope is 'selection' (default), 'page', 'file', or a specific nodeId. Mapping maps old hex → new hex (case-insensitive, 3- or 6-digit hex, with or without #). Returns { changes, nodesVisited }.

• run_scriptwrite action

  Escape hatch: evaluate an arbitrary JavaScript async-body inside the Figma plugin sandbox. The `figma` plugin API is in scope. Use this when no purpose-built tool exists for what you want — e.g. one-off queries, exotic node manipulations, prototyping a future tool. Body must return a JSON-serializable value (or undefined). Returns { ok, result, error? }. Trust model: bridge binds 127.0.0.1 only, s

• screenshot_url

  Render a URL in headless Chrome and capture a PNG. If `outPath` is given, writes the PNG to disk and returns the path (cheap on agent context). Otherwise returns the base64 bytes. Use for visual diffs against Figma exports.

• select_node

  Select a node in Figma and scroll the viewport to it. Provide either a nodeId (e.g. '1:2') or a name substring. Requires the Figbridge plugin to be open with Live bridge enabled.

• update_from_codewrite action

  Update an existing Figma frame in place from a new spec or HTML — finds the frame by `nodeId` or by exact `name`, removes its children, and rebuilds them from `spec` / `html`. The root frame id stays stable so anything that references it survives the update. If no match found, falls back to creating a fresh frame. Returns { nodeId, name, replacedCount, warnings[] }. Use this for iterative re-impor

• verify_text_fidelity

  After importing a URL, verify that every visible text string from the live page also exists in the Figma frame. Returns { liveCount, specCount, missing[], matchedPct }. Use as a fast sanity check that the extractor didn't drop content.

• visual_diff

  One-call visual reference: take a live Chrome screenshot of `url` AND export the Figma frame at `nodeId`, write both PNGs to `outDir` (default /tmp), and return their paths. Hand the paths to the Read tool to view side-by-side. Replaces the chrome-devtools-mcp + python-decode + manual-write dance.

• Code scan14 source files scanned20/25
• –Live reliabilityno gateway calls yet and no remote to proben/a
• –Tool poisoningtools not inspected (local package is not executed); not countedn/a
• Auth qualitylocal package, no credentials required12/15
• Maintenancelast push 109 days ago8/15
• Maintainer identityregistry namespace matches repository owner; GitHub account older than a year8/10

Safety score

74/100

higher than 43% of 4,460 AI and agents servers

Tools

51

the typical AI and agents server has 6

Tools that change things

10%

typical: 0%. Fewer write tools means less an agent can break

GitHub stars

12

more than 85% of 2,711 AI and agents servers

Downloads a week

55

more than 46% of 1,538 AI and agents servers with a package

Figbridge: common questions

Is Figbridge MCP server safe?

Mostly: it is graded B (74/100). Read the Figbridge safety report

How do I install Figbridge?

It runs on your machine. Copy the Claude Code, Cursor, VS Code or Claude Desktop config from the install section.

Does Figbridge need an API key?

No secret keys are declared. It reads 1 setting from the environment.

Is Figbridge maintained?

The last commit was 147 days ago (2026-06-10). The latest release is v0.4.0.

What can I use instead of Figbridge?

Servers from other publishers that do the same job: Figma Context MCP server, Commonly MCP server and mcptoon MCP server.

How does Figbridge compare with other AI and agents MCP servers?

safety score 74/100 (higher than 43% of 4,460 AI and agents servers); tools 51 (the typical AI and agents server has 6); tools that change things 10% (typical: 0%. Fewer write tools means less an agent can break). Full comparison.