Skip to content
saymock
Product Agents Use cases Developers FAQ Pricing
EN, English
  • Français
  • English
  • Deutsch
  • Español
  • Português
  • Italiano
  • Nederlands
  • 日本語
  • 한국어
  • 简体中文
Theme
Sign in Try it

Guides · Figma MCP tokens

Why Figma’s MCP server uses so many tokens, and how to use fewer

Updated November 18, 2026

Figma’s MCP server costs tokens in two places. Reading a design, a single get_design_context call can return hundreds of thousands of tokens. Writing one, the agent writes Figma Plugin API code, and output tokens are the expensive ones. Below: the figures Figma and its users have published, the ones we measured, and what actually reduces them.

Reading a design: one call can exceed the context

get_design_context returns a selection as code, “React and Tailwind by default” in Figma’s words, with styles and assets. On a large frame that output is huge. Figma’s own troubleshooting page quotes the error Claude Code shows when it happens:

Error: MCP tool "get_design_context" response (351378 tokens) exceeds maximum allowed tokens (25000).

That is 14 times the 25,000 tokens Claude Code accepts from one tool call by default. Users report larger figures: on Figma’s forum, one measured about 960,000 tokens for one component through get_design_context, where Figma’s interface estimated about 67,000 for the same component (December 2025). Another reported the call failing once a container grew to six instances (November 2025). When the response is too large, the server can fall back to a sparse outline and tell the agent to call it again on each sublayer: more calls, each one adding to the context.

Figma documents the cause plainly: “Large, deeply nested frames can overwhelm your agent, slow things down, or fail without an error.”

Writing a design: the agent writes code to draw layers

Since March 2026, the use_figma tool lets an agent create and change layers in a Figma file. It does so by writing JavaScript against Figma’s Plugin API: frames, auto-layout, text nodes and fills, one property at a time. That code is output, and output tokens are the most expensive ones at API prices.

We measured it in our benchmark (November 12, 2026): Claude Code reproduced three Wikipedia screens as editable designs, three runs per screen, once with Figma’s MCP server and once with Saymock’s. Averages per run, from the 18 transcripts:

Per runFigma MCPSaymock
Design written by the agent48,300 characters of Plugin API code (10.6 use_figma calls)22,000 characters of HTML + Tailwind (create_frame, edit_html, update_nodes)
Output tokens per screen (median)61,00030,000
Tokens processed per screen (median)2.74M1.88M
Cost per screen, API prices$2.69$1.70

Quality was a tie: 82.2 for Figma, 79.0 for Saymock out of 100, within the protocol’s 5-point threshold. The difference is the format the agent writes, not the agent.

Why the bill grows faster than the output

An agent re-reads its whole context on every turn. A 40,000-token tool result or 5,000 tokens of code written early in a session are read again on each of the 30 or 40 turns that follow. That is why “tokens processed” runs in millions for a single screen, and why a large response costs far more than its own size: it is paid on every later turn too (cached input is cheaper, not free).

How to use fewer tokens with Figma’s MCP server

  1. Read the outline first. get_metadata returns “a lightweight XML outline” of layer ids, names, types, positions and sizes; then call get_design_context only on the parts you need. Figma recommends it “for very large designs”.
  2. Select less. Figma’s advice: “Generate code for smaller sections or individual components, like a card, header, or sidebar.”
  3. Set up Code Connect. When Figma components map to your code components, the server returns the mapping instead of regenerating code. Figma measured a 29.5% lower median token usage and 19.6% shorter tasks across 27 test cases (August 2026).
  4. Raising the limit is not a saving. MAX_MCP_OUTPUT_TOKENS lets Claude Code accept larger responses; the response is just as large, and stays in the context.
  5. Start new sessions. Each screen in a fresh session keeps earlier responses from being re-read on every turn.

Or change what the agent writes

The other lever is the format. Saymock’s screens are HTML with Tailwind classes, a format models already write well: a screen is one create_frame call, repeated rows are written once as a template with data, and every element keeps a data-id, so a change is one small edit instead of a rewrite. Reading is cheap for the same reason: get_file gives the board’s outline without HTML, find_nodes returns ids in one line each.

It is not a replacement for every Figma workflow. If your designs live in Figma and the agent’s job is to read them and write code, Figma’s MCP server is the one that reads them, and the steps above make it cheaper. When the agent produces the design, the comparison is in Saymock vs Figma MCP.

Questions

How many tokens does get_design_context use?

It depends on the selection. Figma’s own example error shows 351,378 tokens for one call, and a user measured about 960,000 for one component. Selecting a smaller part, or reading get_metadata first, keeps it under the client’s limit.

Why does Claude Code refuse Figma MCP responses?

Claude Code accepts 25,000 tokens per tool response by default. A larger get_design_context response is refused; MAX_MCP_OUTPUT_TOKENS raises the limit but does not make the response smaller.

Does Code Connect reduce tokens?

Yes, according to Figma: across 27 test cases, median token usage fell by 29.5% and median task time by 19.6% with Code Connect mappings.

Is writing to Figma with use_figma expensive?

In our benchmark, the agent wrote about 48,000 characters of Plugin API code per run with use_figma, against about 22,000 characters of HTML with Saymock, and used twice the output tokens per screen.

Sources

  • Figma, Tools and prompts, Avoid large frames and MCP server FAQs (read November 18, 2026).
  • Figma blog, Agents, meet the Figma canvas (March 24, 2026) and Better code, fewer tokens (August 5, 2026).
  • Figma forum, about 960k tokens for one component (December 9, 2025) and get_design_context failing on a growing container (November 2025).
  • Saymock, benchmark against Figma MCP (November 12, 2026): protocol and the 18 runs; per-tool figures from the runs’ transcripts.

See also

  • Design tools for agents
  • Claude Code
  • Figma import
saymock
Product Agents Developers FAQ Pricing Benchmark Figma MCP alternative Connect your agent Use cases Gallery Guides MCP tools Changelog About Contact Sign in

© 2026 Saymock

Legal notice Terms of use Terms of sale Privacy