Provider REST API

Design

Connect Claude to Figma

Read design files, nodes, components, styles and comments, and render images. Toolspoke puts 12 of its actions behind one MCP endpoint that Claude, Cursor, and Codex all speak.

Connection
Provider REST API
Authentication
Personal access token
Actions exposed
12
Cost per call (typical)
1 credit
Adapter
Maintained by Toolspoke

Connected in three steps

  1. 1

    Install Figma

    Open the marketplace in your workspace, add Figma to the project your agents work in, and it appears on the gateway immediately.

  2. 2

    Connect the credential

    Authenticate with personal access token. Where to get one, and what it has to be able to reach, is the next section.

  3. 3

    Point your agent at the gateway

    Give your client one address, https://toolspoke.com/mcp. Claude Code takes it as a command, Claude and Claude Desktop add it as a custom connector, and Cursor, Codex and VS Code each read it from a config file of their own.

.mcp.json
{
  "mcpServers": {
    "toolspoke": {
      "type": "http",
      "url": "https://toolspoke.com/mcp"
    }
  }
}

One block covers every tool you have installed. Figma shows up in the client as soon as your policy allows it, and so does everything else you install later.

Where the address goes, per client

Claude Code

Run it in your project, then /mcp to sign in

claude mcp add --transport http toolspoke https://toolspoke.com/mcp
Claude and Claude Desktop

Settings, then Connectors, then Add custom connector

https://toolspoke.com/mcp
Cursor

~/.cursor/mcp.json, or .cursor/mcp.json for one project

{ "mcpServers": { "toolspoke": { "url": "https://toolspoke.com/mcp" } } }
Codex

~/.codex/config.toml

[mcp_servers.toolspoke]
url = "https://toolspoke.com/mcp"
VS Code

.vscode/mcp.json, or the MCP: Add Server command

{ "servers": { "toolspoke": { "type": "http", "url": "https://toolspoke.com/mcp" } } }

What Figma asks for

Personal access token. You provide it once, when you install the connector. Toolspoke encrypts it at rest and decrypts it only for the length of a single call, and the gateway attaches it to the outbound request itself, so it is never part of the arguments an agent sends.

Personal access tokenRequired
Figma → Settings → Security → Personal access tokens. Grant file_content:read, file_comments:read, file_versions:read, projects:read and current_user:read, plus file_comments:write only if this install should post comments.
figd_…

What Claude can do in Figma

12 actions, each one declared and named by the connector rather than discovered at runtime. A workspace policy grants a person all of them, a hand-picked selection, everything on the read side, everything on the write side, or none.

Reads
11Reads
Writes
1Writes
Destructive
0Destructive

Reads

11

Fetches data and changes nothing.

  • get_me

    Return the Figma user the token belongs to: id, handle, email and avatar. Call it to confirm which account a connection is acting as. It is the cheapest call here and takes no arguments, which is why it is the connection's health check.

  • list_team_projects

    List the projects inside one Figma team, with their ids and names. This is the top of the discovery chain: team id, then list_project_files for the file keys, then the file operations. The team id is the number in a Figma team URL - figma.com/files/team/1234567890/….

  • list_project_files

    List the files in one project, each with the file key, name and last-modified time. The file key it returns is what every other operation here takes - a file key is not the same as the numeric project id, and it cannot be guessed from a file name. Get the project id from list_team_projects.

  • get_file

    Fetch a file's document tree: pages, frames, and every layer with its geometry, styles and text. Start with depth 2 - that returns the pages and their top-level frames with node ids and nothing else, which is usually all you need to find the frame you actually care about. A full-depth call on a real design file is enormous and will exhaust your context; once you have the node id, call get_file_nodes for that subtree instead.

  • get_file_nodes

    Fetch specific nodes from a file as structured JSON - one frame, one component, one screen - with their children, layout constraints, auto-layout padding and spacing, fills, strokes, effects and text styles. This is the operation to reach for when implementing a design: it gives an agent the actual measurements and tokens instead of a picture it has to guess from. Get node ids from get_file at a shallow depth, or from the node-id parameter of a Figma URL (convert the URL's 1-42 form to 1:42). Pair it with get_image_renders when you also want to see the frame.

  • get_image_renders

    Render nodes to images and return short-lived URLs, keyed by node id. Use it to actually look at a frame - png or jpg for a screenshot, svg for an icon you intend to copy into code, pdf for a print asset. The URLs expire after about 30 days, so treat them as something to fetch now rather than store. This shows what a design looks like; get_file_nodes tells you what it measures, and an implementation usually needs both.

  • get_file_components

    List the components published from a file, with their key, node id, name, description and containing frame. This is the design system as the file declares it: call it before building any UI from a file so an implementation reuses the components a team already named - Button/Primary, Card/Elevated - instead of inventing parallel ones. Feed a component's node id to get_file_nodes for its structure, or to get_image_renders to see it. The file key must be the main file, not a branch: publishing does not happen from branches.

  • get_file_component_sets

    List the component sets published from a file - the variant groups, such as one Button set holding every size and state. Use it after get_file_components when a component name looks like it has variants: the set is what tells you which properties (size, state, icon) the component actually accepts. Main file key only, not a branch.

  • get_file_styles

    List the styles published from a file - colour, text, effect and grid styles - with their key, node id, name and description. These are the design tokens by the names the team uses. Read them before writing any CSS from a Figma design so the implementation refers to Brand/Primary rather than a hex code copied out of a node. Main file key only, not a branch.

  • get_comments

    List the comments on a file, with their author, timestamp, resolution state and the node or coordinate they are pinned to. Use it to find out what reviewers asked for on a specific frame before implementing it, and to get the comment id that post_comment needs in order to reply in the same thread rather than starting a new one.

  • get_file_versions

    List a file's version history, newest first, with each version's id, label, description and author. Use it to see what changed and when, and to take a version id you can then pass to get_file, get_file_nodes or get_image_renders to read the design as it stood at that point rather than as it is now.

Writes

1

Creates or updates something on the other side.

  • post_comment

    Post a comment on a file. Everyone with access to the file sees it and Figma notifies the people watching, so write it as a message to designers, not as a note to yourself. Pass reply_to_comment_id with a comment id from get_comments to reply inside an existing thread; omit it to start a new one at the top level of the file.

What it will not do

Enforced by the gateway rather than left to convention, which is why each of these can be stated flatly.

It cannot call anything else
The 12 actions above are the whole of it. A call to any other name is refused before it reaches Figma rather than forwarded on, and connecting your account does not add to the list: it is fixed by the connector, not discovered at run time.
Nothing here deletes
This connector writes to Figma, but nothing in it deletes or permanently alters anything.
It reaches no further than your credential
Toolspoke holds no access to Figma of its own. Every call carries the credential you stored and nothing besides, so whatever that credential cannot reach, this connector cannot reach either.
It never hears from Figma
Nothing is pushed to it. There is no webhook, no subscription and no polling, so this connector cannot notice by itself that something changed in Figma. An agent has to ask.
It does not smooth over provider limits
Toolspoke does not retry, queue or back off around Figma's own rate limits. A call that Figma refuses comes back to the agent as a failed call.

Before you connect it

What can Claude do in Figma?

12 named actions: 11 that only read and 1 that write. They include get_me, list_team_projects and list_project_files. Nothing outside that list is reachable: the connector declares each operation by name rather than proxying whatever an agent asks for.

What credentials does the Figma connector need?

Personal access token. The connector asks for personal access token. Values are encrypted at rest and attached to the outbound request by the gateway, so they are never part of the arguments an agent sends and never reach the audit log.

Does the Figma connector work with Cursor and Codex, or only Claude?

Any client that speaks MCP, and every one of them gets the same 12 actions. There is a single address, https://toolspoke.com/mcp. Claude Code adds it with claude mcp add --transport http, Claude and Claude Desktop take it as a custom connector in settings, Cursor reads it from .cursor/mcp.json, Codex from ~/.codex/config.toml, and VS Code from .vscode/mcp.json. Each of them signs in to the gateway itself, so there is no key to paste.

What does the Figma connector not do?

The 12 actions above are the whole of it. A call to any other name is refused before it reaches Figma rather than forwarded on, and connecting your account does not add to the list: it is fixed by the connector, not discovered at run time. This connector writes to Figma, but nothing in it deletes or permanently alters anything. Toolspoke holds no access to Figma of its own. Every call carries the credential you stored and nothing besides, so whatever that credential cannot reach, this connector cannot reach either. Nothing is pushed to it. There is no webhook, no subscription and no polling, so this connector cannot notice by itself that something changed in Figma. An agent has to ask. Toolspoke does not retry, queue or back off around Figma's own rate limits. A call that Figma refuses comes back to the agent as a failed call.

Can I limit which actions an agent can call?

Yes, in two places. The project switches Figma's actions on and off one at a time, for everyone in the project at once, and the screen groups them by read, write and destructive so turning off everything that deletes is one click. An individual agent key can then be narrowed further, to particular toolkits in a project and to particular actions in a toolkit. Whatever it was granted, a key never reaches a project its owner cannot.

What gets recorded when an agent calls Figma?

Every attempt, with the agent that made it and the person that agent belongs to, the full request payload, the response payload, the status, the duration, and the credits spent. Values whose key names a secret are masked out before the record is shown to anyone. An operation the connector marks as not retained never has its response body written at all, so the gateway keeps no second copy of what was read.