Announcing CIMD support for MCP Client registration
Learn more

Figma MCP server: setup, seats, rate limits and your own agent

Diagram: Claude Code, Cursor and Codex connect to Figma's MCP server, while a product's agent reaches Figma per user through Scalekit
Nityashree Yadunath
Product Marketing Manager

The Figma MCP server is Figma's official MCP server. The recommended remote server runs at https://mcp.figma.com/mcp, signs you in with your Figma account through OAuth and acts as you, so it only reaches files you already have access to. Only clients listed in the Figma MCP catalog, such as Claude Code, Cursor and Codex, can connect to it.

For one person in one editor, setup is a plugin install or a single command. The harder questions are which seat you need, how many tool calls your plan allows, and how your own product's agent reaches Figma for many users, which calls for a different design from single-user MCP integrations.

TL;DR

  • Figma runs two servers. The remote server at https://mcp.figma.com/mcp offers the broadest set of features, including writing to the canvas. The desktop server at http://127.0.0.1:3845/mcp runs inside the Figma desktop app, needs a Dev or Full seat on a Professional, Education, Organization, Government or Enterprise plan, and cannot write to the canvas.
  • Your plan and seat set how often you can call it. View and Collab seats get up to 20 tool calls per month, and the Starter plan allows 20 per month. Full and Dev seats get up to 200 per day on Professional and Organization plans and up to 600 per day on Enterprise.
  • Your own product's agent is not a catalog client, so it reaches Figma through the REST API with an OAuth app, one authorization per user. Scalekit AgentKit runs that OAuth flow, stores each user's tokens and serves the Figma tools from one MCP server URL.

What the Figma MCP server does

The server gives an agent structured design context from the Figma layers you point it at, such as frames, components, layout and variables, and your agent writes the final code. It follows your design system's conventions only if you share them through Code Connect, variables, rules or your prompts.

Its tools fall into a few groups:

  • Design to code. get_design_context is the main tool. It returns design context and code for a layer or selection, as React and Tailwind by default or in the framework you ask for. get_metadata returns a lightweight outline for large designs, and get_screenshot lets the agent see the design.
  • Write to Figma. use_figma creates, edits and inspects content in Figma Design, FigJam and Figma Slides files by running code through the Figma Plugin API. generate_figma_design captures live web UI as design layers, and generate_diagram builds FigJam diagrams from a description or Mermaid syntax.
  • Design systems and account. search_design_system finds existing components, variables and styles, add_code_connect_map maps a Figma component to its code component, and whoami returns your email, plans and seat on each plan.

Writing to the canvas is in beta. Figma describes it as free during the beta period and says it will eventually become a usage-based paid feature. It needs edit access to the file, a Professional, Education, Organization or Enterprise plan, and a supported client on the remote server.

Remote server or desktop server

Server
Where it runs
Who can use it
Writes to the canvas
Remote
Figma's hosted endpoint; no desktop app needed
Clients in the Figma MCP catalog
Yes, plus sending live UI to Figma
Desktop
Locally, through the Figma desktop app
Dev or Full seat on a Professional, Education, Organization, Government or Enterprise plan
No

Figma recommends the remote server for most users. The desktop server is intended for specific organization and enterprise needs, and it is the only option on Figma for Government. The remote server works from links: right-click a frame or layer, choose Copy link to selection and paste the link into your prompt. Prompting with your current selection works only with the desktop server.

How the remote server authenticates

The remote server uses the HTTP transport and OAuth. A request without a token gets a 401 whose WWW-Authenticate header points to the server's protected resource metadata, which names https://api.figma.com as the authorization server and mcp:connect as the only scope. Supported clients run the browser sign-in for you, using the authorization code grant with PKCE. Developers who want to connect a new client can join Figma's waitlist.

For Claude, Figma also supports enterprise-managed authorization through Okta Cross App Access: members sign in once through Okta instead of each signing in to Figma separately.

Plans, seats and rate limits

Figma's rate limits page sets tool-call limits by plan and seat. Per-minute limits apply in addition to the daily or monthly limits.

Seat
Starter
Professional
Organization
Enterprise
View, Collab
Up to 20 per month
Up to 20 per month
Up to 20 per month
Up to 20 per month
Full, Dev
Starter plan limit: 20 per month
Up to 200 per day, 10 per minute
Up to 200 per day, 15 per minute
Up to 600 per day, 20 per minute

Education plans have the same limits as Full and Dev seats on the Professional plan. Two details change how you budget:

  • The limits apply to tools that read data from Figma. Some tools are exempt, including tools that write to Figma files such as add_code_connect_map, create_new_file and generate_figma_design, and whoami.
  • Actions that use Figma AI credits, such as generating images with generate_image or sending prompts to Figma Make, do not count toward MCP rate limits. They use credits instead.

Seat type also decides what an agent can write. Writing to files outside your drafts needs a Full seat. With a Dev seat, the agent can write in your drafts and has read-only access to other files. If a file cannot be accessed, ask the agent to run whoami and check that the account it shows belongs to the plan that owns the file.

Add the Figma MCP server to Claude Code

Figma recommends its Claude Code plugin, which includes the server settings and Figma's skills for common workflows:

claude plugin install figma@claude-plugins-official

Restart Claude Code if it is running, type /plugin, open the Installed tab, select the figma server and press Enter to sign in. If the install fails, your organization may have blocked plugins; add the server by hand instead:

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

Leave out --scope user to add it to the current project only. Start a new session, type /mcp, select figma and choose Authenticate to finish the sign-in in your browser. A manual install does not include Figma's skills, such as figma-use, which helps the agent call use_figma reliably when writing to the canvas.

Claude Code limits MCP tool output to 25,000 tokens by default. If get_design_context fails on a large frame because its response exceeds the maximum allowed tokens, select a smaller part of the design or raise the limit before starting Claude Code:

export MAX_MCP_OUTPUT_TOKENS=50000

Add it to Cursor

The Figma plugin for Cursor bundles the server, skills for implementing designs and Code Connect, and rules for handling assets. Open chat, enter /add-plugin figma, add the plugin, then click Connect next to Figma in Cursor's MCP settings and allow access. To add the server by hand, put this entry in ~/.cursor/mcp.json for every project or .cursor/mcp.json for one project, then click Connect to sign in:

{ "mcpServers": { "figma": { "url": "https://mcp.figma.com/mcp" } } }

If Figma tool calls start failing in Cursor, the usual cause is an expired or corrupted sign-in token: run Clear All MCP Tokens from the command palette and sign in again.

Add it to Codex

In the Codex app, open Plugins, add Figma and allow access. In the Codex CLI, add the remote server from your terminal and sign in when prompted:

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

The CLI route does not install Figma's skills. Here is the same server in ~/.codex/config.toml, set to prompt for any tool the server does not mark read-only:

[mcp_servers.figma] url = "https://mcp.figma.com/mcp" default_tools_approval_mode = "writes"

Run codex mcp login figma to sign in again. If Figma tools are missing in Codex, ask your Codex administrator to check that third-party plugins are allowed and the Figma tools are approved.

VS Code and other clients

In VS Code, run MCP: Open User Configuration, paste this into mcp.json, click Start above the server name and allow access:

{ "inputs": [], "servers": { "figma": { "url": "https://mcp.figma.com/mcp", "type": "http" } } }

Any other client in the catalog connects the same way: add an HTTP server with the URL https://mcp.figma.com/mcp and sign in when prompted.

Using the desktop server

Open the Figma desktop app, switch a Design file to Dev Mode with nothing selected, and click Enable desktop MCP server in the right sidebar. Then add the local address to your client:

claude mcp add --transport http figma-desktop http://127.0.0.1:3845/mcp

If use_figma or generate_figma_design is missing after you set up the remote server, the most common cause is an old desktop entry: the two servers have similar tool names, so the client may never load the remote-only tools. Remove the local entry and restart the client:

claude mcp list claude mcp remove figma-desktop

Official, self-hosted or managed: which to use

Option
Runs on
Credential
Better fit when
Figma's official server
Figma's infrastructure, or the Figma desktop app
Your own Figma sign-in from a catalog client
People work from Claude Code, Cursor, Codex, VS Code or another catalog client
Self-hosted community server
Your machine, over stdio
A personal access token in an environment variable
Your client is not in the catalog, or you want to reshape design data for the model
Managed per-user server
The vendor's infrastructure
Each end user's Figma OAuth tokens, stored and refreshed by the vendor
Your product's agent works in many users' Figma files

The official server is the right default for anyone working in their own editor. Figma maintains the tools and ships canvas writing and Code Connect, and you only manage a sign-in.

The community server Framelink MCP for Figma is MIT-licensed and published on npm as figma-developer-mcp. It calls Figma's REST API and simplifies the response so only the most relevant layout and styling information reaches the model. It runs with a personal access token, passed as a command-line flag or in the env field. The env form keeps the token out of the arguments:

{ "mcpServers": { "Framelink MCP for Figma": { "command": "npx", "args": ["-y", "figma-developer-mcp", "--stdio"], "env": { "FIGMA_API_KEY": "YOUR-PERSONAL-ACCESS-TOKEN" } } } }

A personal access token acts as the user who generated it, can reach anything that user can, and lasts at most 90 days. Treat any third-party server like other code you run with a credential, and vet it before you install it.

Managed services hold one authorization per end user. Composio lists 52 Figma tools, supports OAuth2 and API keys, and creates an MCP session per user ID. It is the better fit when you already build on Composio and want Figma next to its other toolkits.

Connect your own agent for many users

A product that runs its own agent for its customers reaches Figma through the REST API. Figma recommends an OAuth app when an application acts on behalf of individual Figma users. The REST API reads files, nodes, images, components, styles and version history, posts comments, writes dev resources, manages webhooks, and handles variables on Enterprise plans. Canvas editing through use_figma stays on the MCP server. Figma MCP vs Figma API compares the two surfaces task by task.

Built by hand, the per-user OAuth work looks like this:

  1. Register an OAuth app at figma.com/developers/apps, choose its scopes and add your redirect URLs. A private app serves users in the team or organization you associate it with, with no review. A public app can serve any Figma user after Figma reviews it.
  2. Send each user through the authorization flow and exchange the code at https://api.figma.com/v1/oauth/token within 30 seconds, because authorization codes expire after that.
  3. Store each user's access and refresh tokens encrypted, keyed by your user ID.
  4. Refresh before the access token expires, after 90 days by default. Figma keeps one access token per app for each user, so a refresh makes the previous token stop working and every worker needs the newest one.
  5. Handle 429 responses using the Retry-After header. For OAuth apps, Figma tracks rate limits per user, per plan and per app.
  6. Delete the tokens when the user disconnects.

Per-user OAuth for MCP integrations covers this design and its failure modes in more depth.

With Scalekit AgentKit

AgentKit is an MCP gateway that runs each user's OAuth flow, stores their tokens encrypted with AES-256-GCM under a key per environment, refreshes them and calls tools as that user. Its Figma connector works over Figma's REST API with OAuth 2.0 and your own Figma OAuth app, and lists 54 tools: 43 read, 7 write and 4 destructive. You register the app in the Figma developer portal, paste Scalekit's redirect URI into it, and choose the scopes your agent needs on the connection.

You create a Virtual MCP server once per agent role and choose its tools. All users share its URL. Before each run, your back end mints a session token for one user, and the agent connects with that token. Scalekit checks the token, finds that user's Figma account and calls Figma with it, so your agent never receives the user's Figma token.

Once per agent role: create the server.

import os from scalekit import ScalekitClient from scalekit.actions.models.mcp_config import McpConfigConnectionToolMapping actions = ScalekitClient( env_url=os.environ["SCALEKIT_ENVIRONMENT_URL"], client_id=os.environ["SCALEKIT_CLIENT_ID"], client_secret=os.environ["SCALEKIT_CLIENT_SECRET"], ).actions server = actions.mcp.create_config( name="figma-design-review", connection_tool_mappings=[ McpConfigConnectionToolMapping( connection_name="figma", # your Figma connection tools=[ "figma_file_meta_get", "figma_file_nodes_get", "figma_file_comments_list", "figma_file_comment_create", ], ) ], ).config print(server.id, server.mcp_server_url)

Before each run: check the user's account, then mint a token.

from datetime import timedelta user_id = "user_123" # your app's stable ID for this user accounts = actions.mcp.list_mcp_connected_accounts( config_id=server.id, identifier=user_id, include_auth_link=True ) for account in accounts.connected_accounts: if account.connected_account_status != "ACTIVE": print("Send the user this link:", account.authentication_link) session = actions.mcp.create_session_token( mcp_config_id=server.id, identifier=user_id, expiry=timedelta(minutes=30), )

During the run: connect any MCP client with the server URL and the session token as a bearer header. With the Python MCP SDK (version 2):

import asyncio import httpx2 from mcp import Client from mcp.client.streamable_http import streamable_http_client FILE_KEY = "your_file_key" # from figma.com/design/<file_key>/... async def run(): headers = {"Authorization": f"Bearer {session.token}"} async with httpx2.AsyncClient(headers=headers, timeout=30) as http: url = server.mcp_server_url transport = streamable_http_client(url, http_client=http) async with Client(transport) as mcp: tools = await mcp.list_tools() print([tool.name for tool in tools.tools]) result = await mcp.call_tool( "figma_file_comments_list", {"file_key": FILE_KEY} ) print(result.is_error, result.content) asyncio.run(run())

How session tokens behave:

  • A token is bound to one user and one server. Sent to any other server URL, it returns 401.
  • It lasts one hour by default, and you can set anything from 60 seconds to 24 hours.
  • It is short-lived by design and is not refreshed. Mint a new one per run, per chat session, or on a schedule for a long-running host. A new token does not revoke earlier ones.
  • Add access_level="READ_ONLY" and the run sees only the server's read-only tools; a call to figma_file_comment_create or any other write tool is refused before it reaches Figma.

By default, tools/list also includes a connect_account tool, so an agent can fetch an authorization link for a user who has not connected Figma yet. To revoke one user, delete their connected account; their next call fails until they authorize again, and other users keep working:

actions.delete_connected_account( connection_name="figma", identifier=user_id )

Security notes

  • Start with read access. For an agent that only reads, use read-only session tokens and leave write scopes such as file_variables:write and webhooks:write off the Figma connection.
  • Require approval for writes. Agents read layer names, text and comments written by other people, so a hidden instruction in a comment should not be able to change a file without a person approving it. Cursor asks before each MCP tool call by default. In Codex, default_tools_approval_mode = "writes" prompts for tools not marked read-only. In Claude Code, an ask rule such as mcp__figma__* in /permissions makes every call to a manually added figma server wait for you; servers added by a plugin use the plugin-scoped form mcp__plugin_<plugin>_<server>__*.
  • Test canvas writes on a copy. While writing to the canvas is in beta, Figma recommends testing on a duplicate of your library or a draft file and keeping a backup copy.
  • Access never exceeds the user's own. Figma's REST scopes do not override file, team or organization permissions.
  • Know how to revoke. Revoke a personal access token under Settings > Security in Figma; revocations are instant. With Scalekit, deleting a connected account removes one user's access without touching anyone else's.

FAQs

Is the Figma MCP server free?

It is available on Starter, Professional, Education, Organization, Government and Enterprise plans, with tool-call limits set by plan and seat. The Starter plan and View or Collab seats get 20 tool calls per month. Writing to the canvas is free during its beta period and will eventually become a usage-based paid feature.

What are the Figma MCP server rate limits?

Full and Dev seats get up to 200 tool calls per day on Professional and Organization plans and up to 600 per day on Enterprise, with per-minute limits on top. View and Collab seats, and the Starter plan, get 20 per month. Figma may change the limits at any time.

Do I need a Dev seat or a Full seat?

The desktop server needs a Dev or Full seat on a Professional, Education, Organization, Government or Enterprise plan. To write to files outside your drafts, you need a Full seat. A Dev seat can write in your drafts and has read-only access to other files.

How do I add the Figma MCP server to Claude Code?

Run claude plugin install figma@claude-plugins-official, then sign in from the Installed tab of /plugin. Without plugins, run claude mcp add --transport http figma https://mcp.figma.com/mcp, then type /mcp, select figma and choose Authenticate.

Can my own agent or app connect to the Figma MCP server?

Only clients listed in the Figma MCP catalog can connect, and developers of new clients can join Figma's waitlist. A custom agent can use Figma's REST API instead, with an OAuth app that acts on behalf of individual users. Scalekit's Figma connector runs that OAuth flow per user and serves the tools through a Virtual MCP server.

Details checked October 2026.

No items found.
Agent
Auth Quickstart
On this page
Share this article
Agent
Auth Quickstart

Acquire enterprise customers with
‍zero upfront cost.

Every feature unlocked. No hidden fees.