Figma MCP: Read and Write Figma from Claude Code and Codex

Orange halftone illustration of the Figma logo inside a selection frame, with arrows pointing both ways to a code window

Figma MCP connects Figma to AI agents like Claude Code and Codex. It reads designs as code, and since March 2026 it can build designs on the Figma canvas too. We tested both directions on one file before writing this: every height and vertical position matched Figma exactly, and text was within about 2px.

Connect Figma MCP in 3 steps

  1. Install it. In Claude Code, run claude plugin install figma@claude-plugins-official. In the Codex CLI, run codex mcp add figma --url https://mcp.figma.com/mcp, or install Figma from Plugins in the Codex app. The plugins include Figma’s skills, which teach the agent how to use the tools; the CLI server command doesn’t.

  2. Sign in. In Claude Code, restart, type /plugin, select figma under Installed and allow access in the browser. In Codex, follow the sign-in prompt, or run codex mcp login figma if it doesn’t appear.

  3. Check it, read-only. Paste a link to a Figma frame and ask: “Describe this frame without changing anything.” Try writing on a draft file before the agent touches a production library.

Important: Write to canvas is in beta. Let the agent write in a draft or a duplicate file first, and keep production libraries read-only until you trust what it builds.

Last verified: November 14, 2026, against Figma’s developer docs and Help Center.

What is Figma MCP?

Figma MCP is Figma’s official MCP server. It lets AI agents like Claude Code and Codex read designs from Figma, write designs into Figma, and connect designs to your codebase. MCP (Model Context Protocol) is the open standard these agents use to work with outside tools.

It launched in beta in June 2025 as the Dev Mode MCP server, became generally available in October 2025, and opened the canvas to agents on March 24, 2026. There are two versions: a remote server at https://mcp.figma.com/mcp that Figma recommends for most people, and a desktop server that runs through the Figma app. Only the remote server can write.

Diagram titled One agent, both directions: Figma, an AI agent such as Claude Code or Codex, and your code, with use_figma building on the canvas, get_design_context returning code, the agent writing code with your components, generate_figma_design capturing a page into Figma, and Code Connect linking Figma components to code components
One agent works both ways: it reads designs as code and builds designs on the canvas. Diagram: Rango

What you want

What it does

Main tool

Who can use it

Design to code

Returns code for a frame, a screenshot of it, and the names of the variables it uses

get_design_context

All plans (Starter: 20 calls a month)

Build in Figma

Creates frames, components, variants, variables and auto layout on the canvas

use_figma

Professional, Education, Organization or Enterprise, in beta

Code to Figma

Sends a running web page into Figma as editable layers

generate_figma_design

Starter and up, in supported clients

Your real components

Maps Figma components to the components in your codebase

Code Connect

Professional plan and up, with a Full or Dev seat

Screenshot from Figma’s launch post of a product page design selected in Figma, next to the React and Tailwind code the MCP server generated for it
Design to code in Figma’s own launch example: the selected design on the left, the code it returned on the right. Image: Figma

How to connect Figma MCP, step by step

Figma recommends the remote server for most people. It runs at https://mcp.figma.com/mcp, needs no desktop app, signs you in with your Figma account, and is the only version that can write to the canvas.

Connect Figma MCP to Claude Code

The plugin installs the server and Figma’s skills together. Adding only the server is quicker but skips the skills.

Option A: install the plugin (includes Figma’s skills, recommended)

claude plugin install figma@claude-plugins-official

Option B: add only the server (no skills; --scope user makes it available in every project)

claude mcp add --scope user --transport http figma https://mcp.figma.com/mcp

Restart Claude Code. With the plugin, type /plugin, open Installed, select figma, press Enter twice and click Allow access in the browser. With the server only, run /mcp, select figma, then Authenticate.

Note: on a machine where nobody has opened Claude Code yet, add Anthropic’s official marketplace first with claude plugin marketplace add anthropics/claude-plugins-official (Claude Code docs).

Connect Figma MCP to Codex

In the Codex app, open Plugins, click + next to Figma, install it and allow access. The app plugin includes Figma’s skills. In the Codex CLI, add the server instead:

1. Add the server (no skills)

codex mcp add figma --url https://mcp.figma.com/mcp

2. Sign in (only if the browser sign-in doesn’t open on its own)

codex mcp login figma

Connect other tools

  • Gemini CLI: run gemini extensions install https://github.com/figma/mcp-server-guide, then type /mcp auth figma inside Gemini CLI.

  • VS Code with GitHub Copilot: add a server of type http with the URL https://mcp.figma.com/mcp, then click Start and allow access.

  • Claude Desktop: connect through the Figma connector.

Important: if you set up both the desktop and the remote server, your agent may load only the desktop tools and lose write access. Remove the desktop entry, for example with claude mcp remove figma-desktop.

Note: only clients in Figma’s MCP catalog can connect. If your client can’t connect, check that it is listed there.

We tested read and write on one file

We wanted to know two things: can an agent build something in Figma that a designer would recognize as properly made, and does the code it reads back actually match? We used Claude Code with Figma’s plugin on November 14, 2026, in a new draft file on our Figma Professional plan with a Full seat.

Write. We asked for a small reconciliation panel: three AI-proposed payment matches, a confidence label on each, and an approve button. In a single tool call, the agent created a set of 15 variables for colors, spacing and corner radius, built a reusable Match row component with four text properties, and composed a 560 by 371 pixel panel from three instances of it. Every fill and border was bound to a variable, and so were the main spacing and corner radius values. A few small ones, like the tight gaps inside text groups, the button padding and the pill radius, stayed as fixed numbers. Every container used auto layout. Its first attempt failed on one unsupported call, wrote nothing, and the retry worked.

Diagram titled One prompt, native Figma layers: the reconciliation review panel an AI agent built in Figma, beside a list of what it created: 15 variables, 1 component with 4 text properties, 3 instances, and auto layout in every container
What the agent built in Figma: variables, a component and auto layout, not a flat picture. Diagram: Rango

Read. We then asked Figma MCP for the code. It returned React with Tailwind classes, plus a screenshot of the frame as the target. The Match row came back as its own component with props for the vendor, the source, the amount and the confidence, because it was a component in Figma. Colors, and the spacing and radius values bound to variables, came back as the Figma variable names with a fallback value, such as var(--color/border,#e7e6e3), so they can map straight onto your own tokens.

The check. We ran that code unchanged in Chrome, except for mapping Figma’s internal font names to the web Inter font, and compared it with Figma’s own render at the same size:

  • All 36 elements in the Figma frame were in the code.

  • Every height and every vertical position matched exactly.

  • Horizontal positions and widths were off by at most 2.2px, all from text measuring slightly differently.

  • At twice the resolution (a 1120 by 742 pixel card, rendered with Google Fonts’ Inter 4), 4.2% of pixels differed by more than 32 of 255 levels. 98% of those were inside text, along the edges of letters, where Figma and Chrome draw fonts slightly differently. The rest were on the card’s rounded corners. None were on borders, fills, button shapes or spacing.

Diagram titled Every height matched, text within 2.2px: the same review panel rendered by Figma and by the browser from Figma MCP code, side by side, with 36 of 36 elements present, 0px off on heights and vertical positions, and at most 2.2px off on boxes sized by text
Figma’s render beside the browser running the code Figma MCP returned. Diagram: Rango
Diagram titled The difference is in the letters: the review panel with differing pixels marked in red along letter edges; 4.2% of pixels differ by more than 32 of 255 levels, 98% of those inside text, and none on borders, fills, button shapes or spacing
The pixels that differ between the two renders, in red. Diagram: Rango

Note: this was one clean demo file, not a client project. The returned code is a starting point: Figma says plainly that its job is to give your agent design context, not production-ready code. The agent still has to fit it into your stack, wire up states and data, and use your real components.

What tripped us up in the test

1. One unsupported call stopped the first build

The agent tried to switch on tabular numbers for the amounts using setRangeOpenTypeFeatures, which wasn’t supported in our test. The run stopped and wrote nothing to the file.

Fix: drop or fix the failing call and retry. If the error says a retry isn’t safe without reading the canvas, check what changed first. Figma’s figma-use skill tells the agent to follow that signal.

2. Figma’s font names don’t exist on the web

The returned code names fonts the way Figma does internally, such as Inter:Medium. A browser can’t find that font, so the text falls back to the default.

Fix: map Figma’s font names to your real font family in your CSS or Tailwind theme. The weights are already in the code.

3. Text measured slightly wider or narrower

Text boxes came back within 2.2px of Figma, but most weren’t exact. Figma and the browser lay out the same font a little differently, and switching to an older build of Inter brought the worst case down to 1.5px.

Fix: test with the exact font files you ship, and don’t chase differences of a pixel or two in text width.

Why the code matches the design

Figma’s docs don’t promise pixel-perfect output. Its own line is that the right code is “aligned to design intent, not just pixels.” The accuracy comes from what Figma sends the agent:

  • A screenshot as the target. Figma found that a screenshot combined with its code output works better than either on its own. Figma’s design-to-code skill tells the agent to check its result against that screenshot.

  • Variable names, not guessed colors. The agent gets the exact token a layer uses, so it can reach for your --color-border instead of eyeballing a hex value.

  • Components can come back as components. In our test, the Figma Match row returned as a React component with vendor, source, amount and confidence props.

  • Code Connect for your real components. Code Connect adds snippets from your real components to what the agent receives, which helps it reuse your Button instead of writing another one. In Figma’s internal test of 27 tasks, it cut median task time by 19.6% and token use by 29.5%.

  • Auto layout maps to flexbox. In our test, every auto layout frame came back as a flex container with the same gaps and padding.

That last point is the catch. The output is only as good as the file. Figma’s own advice is to use variables for spacing, color, radius and type, components for anything reused, auto layout everywhere, and clear layer names. A file built that way reads cleanly. A file of loose rectangles reads like loose rectangles.

Illustration from Figma of a Figma Button component whose text, disabled and background properties are wired through Code Connect to the label, isDisabled and backgroundColor props of a Button.tsx code component
Code Connect maps a Figma component’s properties to your code component’s props. Image: Figma

Why we moved back to Figma from Paper

In July, we told website designers they couldn’t skip Paper. Its canvas is built on real HTML and CSS, Claude Code could read and write it over MCP, and two landing pages shipped that way. That article was scoped to websites, and it said then that Figma is the standard for product design.

The workflow was simple: design in Paper, have Claude Code read the frames over MCP and build them in Next.js, push the code to GitHub, have Codex review it, then ship.

We design in Figma again. Paper didn’t get worse, and we still like it. Figma’s MCP server now covers what we went to Paper for. Only the design step changed: we design in Figma, and Claude Code reads the frames over Figma MCP and builds them. After that, one of us reviews every AI draft, and every change goes to a preview first.

Three things changed:

  • Agents build with your design system. When Figma MCP writes, it searches your libraries first and builds with the components, variables and styles already there. When a team’s design system lives in Figma, the agent works with what its designers already use.

  • One tool for product and website. We design web apps and websites. Working in one tool means one set of components and tokens, and no second copy to keep in sync.

  • Figma kept shipping. Write to canvas was a few months old and in beta when we wrote about Paper. Since then Figma has made its MCP tools faster and lighter on tokens, added new tools, and kept updating the skills that guide the agent. The timeline below shows how fast it moved.

Figma’s launch image for write to canvas: a terminal over a Figma file shows an agent asked to build a new component set from a button.tsx file, loading Figma’s skills and reporting a Button created with 72 variants
Figma’s launch image for write to canvas in March 2026: an agent builds a component set from a code file. Image: Figma

If you already work in Paper and it works for you, keep going. Our point is narrower: Figma now does the part that sent us to Paper, so for our client work we design in Figma again.

How Figma MCP got better since 2025

Figma MCP started as a read-only bridge for developers. Within ten months it could write to the canvas too, and it has kept growing since:

Write to canvas was the step that mattered most for us. It covers the part that sent us to Paper, and the updates since the summer are what brought us back.

How designers, founders and product managers use it

Figma MCP means something different depending on who is asking.

For designers

Agents now build inside your files with your components, so your design system decides the quality of what they make. Variables, components, auto layout and clear layer names aren’t housekeeping anymore. They are what the agent reads.

  • Draft screens from your library. Ask for a first version of a screen, or a few layout options, built only from your components, then refine by hand.

  • Clean up files. Let the agent find detached instances, hardcoded colors and frames without auto layout.

  • Hand off with Code Connect. Map your components to the ones in code, so developers’ agents reuse the real thing.

Build three layout options for this onboarding screen using only components and variables from our library. Put them side by side and don't detach anything.

Verify: spacing and colors use library variables, reused components stay linked instances, and nothing was detached.

For founders and non-designers

You don’t need to know Figma well to get value from it, but you do need something good to build from.

  • Ask what a design does. Paste a frame link and ask for a plain-language description, or ask the agent to build that screen in your app.

  • Bring your running product into Figma. Code to canvas captures a page of your app as layers, so a designer can start from what already exists. It works on the free Starter plan too, with a supported client such as Claude Code or Codex.

  • Know when to bring in a designer. An agent can create components and variables from scratch, as it did in our test. A designer still needs to decide whether that system fits your product and is easy to keep up.

Reading works on the free Starter plan with 20 calls a month. Building in Figma with an agent needs a Professional plan or higher.

Capture the pricing page of our app at localhost:3000/pricing into this Figma file, then describe what you would change to make the plans easier to compare.

Verify: the capture comes in as flat layers, so treat it as a starting point, not a design system.

For product managers

Figma MCP helps most with the work around the design: flows, specs and checking what shipped.

  • Turn a spec into a flow. generate_diagram creates a FigJam diagram from a description, so a PRD becomes a user flow the team can comment on.

  • Write tickets from frames. Ask the agent to describe a frame’s states, fields and edge cases as acceptance criteria, with open questions listed separately.

  • Compare the build with the design. Capture the live page into Figma next to the original and look for gaps before release.

Turn this PRD into a FigJam user flow with one step per screen and the error states as branches: [paste the PRD]

Verify: walk through each step against the spec, and add anything the agent had to guess.

Figma MCP plans and rate limits

  • Reading works on every plan. Starter plans, and View or Collab seats on any plan, get up to 20 calls a month. A Full or Dev seat gets up to 200 a day on Professional, Education and Organization plans, and up to 600 a day on Enterprise, with a per-minute cap on top.

  • Writing needs a Professional, Education, Organization or Enterprise plan, and the remote server. You need a Full seat to write outside your own drafts. A Dev seat can write only in its drafts.

  • Write to canvas is in beta and free for now. Figma says it will eventually become a usage-based paid feature. No price or date has been announced.

  • Write tools don’t count toward the rate limits. Tools that read from Figma do, with a few exceptions such as whoami.

  • Some tools use Figma AI credits, such as generating images. Most don’t.

Check Figma’s rate limits page before you plan around these numbers, because Figma says it can change them at any time.

Set it up safely

Important: an agent with write access can change shared components and libraries. Give it a draft or a duplicate until you have reviewed a few of its builds.

  • Write on a draft or a duplicate first. Figma’s own advice while write to canvas is in beta. Output may need review and cleanup.

  • Give the agent the right seat. A Dev seat writes only in drafts. Writing into a shared library needs a Full seat and edit access to that file.

  • Keep frames small. Large selections slow the tools down or return incomplete results. Ask for the outline first with get_metadata, then work section by section.

  • Download assets. Image links in the returned code are temporary. Save the files into your project.

  • Expect some variation. The same prompt can produce different results. Review what the agent built before it reaches a shared file.

  • Check with your admin. Claude and Codex admins can block plugin installs, so ask before you roll this out to a team.

Prompts that work

1. Build a frame in your app

Build this frame in our Next.js app using our existing components and CSS variables: [Figma frame link]

Verify: compare the page with the Figma screenshot at the same width, and check the agent reused your components instead of writing new ones.

2. Design a screen from your library

Create a billing settings page in this file using components and variables from our design system. Don't detach any instances.

Verify: select a few layers and check they are linked instances from your library, not detached copies.

3. Map your tokens

List every variable this frame uses and map each one to our Tailwind theme. Flag any raw hex values.

Verify: every Figma variable has a match in your theme, and no raw hex values are left.

4. Send a live page to Figma

Capture localhost:3000/pricing into this Figma file.

Verify: captured pages arrive as flat layers, so rebuild anything you want to reuse as a component.

5. Audit a page, no changes

List detached instances, hardcoded colors and frames without auto layout on this page. Don't change anything.

Verify: spot-check a few results in Figma before you fix anything in bulk.

6. Draw the flow in FigJam

Turn this onboarding flow into a FigJam diagram.

Verify: the steps and labels match the real product.

What still needs a designer or developer

  • Decisions. The agent builds what you describe. Deciding what the screen should do, and for whom, is still the job.

  • Production code. States, data, accessibility, performance and tests come after the first render.

  • Images and fonts. use_figma can’t add new images on its own, and only fonts uploaded to your Figma account work.

  • A clean file. Variables, components and auto layout are what make the output match. If the file isn’t built that way, start there.

  • Code Connect setup. Mapping your components takes some work up front, and the components must be published first.

FAQ

What is Figma MCP?

Figma MCP is Figma’s official MCP server. It lets AI agents like Claude Code and Codex read designs from Figma as code, write designs into Figma, and connect Figma components to your codebase through Code Connect.

How do I connect Figma MCP to Claude Code?

Run claude plugin install figma@claude-plugins-official, restart Claude Code, open /plugin, select figma and sign in. The plugin includes Figma’s skills. You can also add only the server with claude mcp add --transport http figma https://mcp.figma.com/mcp, which skips the skills.

Does Figma MCP work with Codex?

Yes. In the Codex CLI, run codex mcp add figma --url https://mcp.figma.com/mcp and sign in to Figma when prompted. In the Codex app, install the Figma plugin, which also adds Figma’s skills.

Is Figma MCP read only, or can it write to the canvas?

It can write. Since March 24, 2026, the use_figma tool lets agents create and edit frames, components, variants, variables and auto layout in Figma files. It is in beta, works only with the remote server, and needs a Professional, Education, Organization or Enterprise plan.

Do I need Dev Mode or a Full seat?

Not to read. The remote server works on every plan, and View or Collab seats get 20 calls a month. A Dev or Full seat raises the limit to 200 calls a day on Professional plans. To write outside your own drafts you need a Full seat; a Dev seat can write only in its drafts.

Is Figma MCP free?

Reading is available on every plan, with a limit of 20 calls a month on Starter plans and View or Collab seats. Write to canvas is free during its beta on Professional, Education, Organization and Enterprise plans, and Figma says it will become a usage-based paid feature.

What is the difference between the remote and desktop Figma MCP server?

The remote server runs at mcp.figma.com/mcp, needs no desktop app, has the most features and is the only one that can write to the canvas. The desktop server runs through the Figma app for specific organization needs and can read but not write.

Why can’t my agent find use_figma?

Usually because it is connected to the desktop server, which can’t write, or to both servers and loaded the desktop tools. Connect the remote server at mcp.figma.com/mcp and remove the desktop entry. Writing also needs a Professional, Education, Organization or Enterprise plan. If your client can’t connect at all, check that it is in Figma’s MCP catalog, because only listed clients can connect.

Is the code from Figma MCP production-ready?

No. Figma describes it as design context for your agent, not production-ready code. In our test the layout matched closely, but the agent still has to fit the code into your stack, use your components, and add states, data and accessibility.

Does Figma MCP use my design system?

Yes, when it writes. It searches your connected libraries first and builds with your existing components, variables and styles. When it reads, it returns your variable names, and Code Connect lets it point to your real code components.

What is the difference between write to canvas and code to canvas?

Write to canvas (use_figma) builds native Figma content with your components, variables and auto layout. Code to canvas (generate_figma_design) captures a running web page as flat layers with no link to your components, though it can bind matching variables.

Is it safe to use Figma MCP on production files?

Figma advises testing write to canvas on a duplicate or a draft file first, because the feature is in beta and output may need cleanup. Agents can only reach files you already have access to, so give them a seat and file access that match the job.

Can Figma MCP produce pixel-perfect code?

It can come very close if the file uses variables, components and auto layout. In our test every height and vertical position matched exactly and text was within about 2px. Figma itself frames the goal as matching design intent, not just pixels.

Does Figma have its own CLI for MCP?

No. You connect Figma MCP from your agent’s CLI, such as Claude Code, Codex or Gemini CLI. The command line tool Figma does offer here is the Code Connect CLI, which publishes component mappings.

Can a non-designer use Figma MCP?

Yes. You can ask an agent to describe a frame, build it in your app, or capture your running product into Figma as layers. Reading works on the free Starter plan with 20 calls a month, and building in Figma needs a Professional plan or higher. Results are much better when there is a design system to build from.

How do product managers use Figma MCP?

To turn specs into FigJam user flows, describe frames as acceptance criteria for tickets, and compare a live page with its design by capturing it into Figma. It helps with the work around the design rather than replacing the designer.

Will Figma MCP replace designers?

No. It builds what you describe, and the quality depends on the design system it builds from. Deciding what a screen should do, and setting up the components and variables an agent reads, is still a designer’s job.

Figma MCP or Paper MCP?

Both let agents read and write their canvas. We use Figma MCP because the agent can build with a team’s existing Figma components and variables. If your team works in Paper and it fits, it is a reasonable choice.

Where Rango fits

We are an AI-native design and engineering team. We design in Figma and build with Claude Code and Codex, on Webflow, Framer and Next.js.

  • Files agents can build from. We set up variables, components and auto layout so design-to-code output lands close to the design.

  • Design and build in one team. The same people design the screens and ship the front end, for web apps and Next.js websites.

  • AI with people in charge. Agents do the repetitive work, and one of us reviews every AI draft before it ships.

If you run Webflow or Framer instead, our guides to Webflow MCP and Framer MCP cover those. If you want your Figma files set up for agents, or a website built from them, book a call.

Figma files your agents can build from.

We set up variables, components and auto layout so design to code lands close to the design. Then we design and ship the code with Claude Code and Codex.

Book a call

Sagar Ludhiyani

Sagar Ludhiyani

Founder

Founder

Published On

Share on