Skip to main content
figma-sdk-patterns Production-ready patterns for the Figma REST API and Plugin API.
Use when building reusable Figma client wrappers, extracting design tokens,
traversing node trees, or creating typed API helpers.
Trigger with phrases like "figma patterns", "figma best practices",
"figma client wrapper", "figma typed API".
الانتقال إلى التثبيت سوق المهارات اكتشف واستكشف مهارات الذكاء الاصطناعي التي بناها المجتمع.
التثبيت باستخدام Codex أو Claude انسخ هذا Prompt والصقه في Codex أو Claude أو مساعد آخر ليراجع صفحة Skill ويثبّتها لك.
نسخ Promptعرض تفاصيل Prompt يتجاوز الأمر المباشر Prompt المخصّص للمراجعة. افحص المصدر قبل تشغيله.
npx skills add https://github.com/jeremylongshore/claude-code-plugins-plus-skills --skill figma-sdk-patternsيبقى الأمر في سطر واحد. مرّر أفقيًا لمراجعته كاملًا قبل النسخ.
تفضّل نسخة محلية؟ نزّل الملفات المتاحة حاليًا لدى SkillsMP.
تحميل Zip جاري التحميل... المزيد من هذا المستودع Implement user sign-up and sign-in flows with Clerk.
Use when building authentication UI, customizing sign-in experience,
or implementing OAuth social login.
Trigger with phrases like "clerk sign-in", "clerk sign-up",
"clerk login flow", "clerk OAuth", "clerk social login".
Implement session management and middleware with Clerk.
Use when managing user sessions, configuring route protection,
or implementing token refresh and custom JWT templates.
Trigger with phrases like "clerk session", "clerk middleware",
"clerk route protection", "clerk token", "clerk JWT".
Configure enterprise SSO, role-based access control, and organization management.
Use when implementing SSO integration, configuring role-based permissions,
or setting up organization-level controls.
Trigger with phrases like "clerk SSO", "clerk RBAC",
"clerk enterprise", "clerk roles", "clerk permissions", "clerk organizations".
المهن ذات الصلة SOC
استنادا إلى تصنيف SOC المهني
name figma-sdk-patterns description Production-ready patterns for the Figma REST API and Plugin API.
Use when building reusable Figma client wrappers, extracting design tokens,
traversing node trees, or creating typed API helpers.
Trigger with phrases like "figma patterns", "figma best practices",
"figma client wrapper", "figma typed API".
allowed-tools Read, Write, Edit version 1.6.0 license MIT author Jeremy Longshore <jeremy@intentsolutions.io> tags ["saas","figma"] compatibility Designed for Claude Code
Figma SDK Patterns
Overview
Production patterns for the Figma REST API (external tools) and Plugin API (in-editor plugins). Figma has no official Node.js SDK -- you call https://api.figma.com directly with fetch. These patterns give you type safety, error handling, and reusable abstractions.
Prerequisites
FIGMA_PAT environment variable set
TypeScript 5+ project
Understanding of Figma node types
Instructions
Step 1: Typed REST API Client
export class FigmaClient {
private baseUrl = 'https://api.figma.com' ;
constructor (private token : string ) {
if (!token) throw new Error ('Figma token is required' );
}
private async request<T>(path : string , init ?: RequestInit ): Promise <T> {
const res = await fetch (`${this .baseUrl} ${path} ` , {
...init,
headers : {
'X-Figma-Token' : this .token ,
'Content-Type' : 'application/json' ,
...init?.headers ,
},
});
if (res.status === ) {
retryAfter = (res. . ( ) || );
(retryAfter);
}
(res. === ) ( );
(res. === ) (path);
(!res. ) (res. , res. ());
res. ();
}
( ) {
. < >( );
}
( ) {
ids = (nodeIds. ( ));
. < >( );
}
( ) {
params = ({
: nodeIds. ( ),
: opts?. ?? ,
: (opts?. ?? ),
});
. < >( );
}
( ) {
. < >( );
}
( ) {
. ( , {
: ,
: . ({
message,
...(nodeId && { : { : nodeId } }),
}),
});
}
( ) {
. < >(
);
}
}
429
const
parseInt
headers
get
'Retry-After'
'60'
throw
new
FigmaRateLimitError
if
status
403
throw
new
FigmaAuthError
'Invalid or expired token'
if
status
404
throw
new
FigmaNotFoundError
if
ok
throw
new
FigmaApiError
status
await
text
return
json
async
getFile
fileKey : string
return
this
request
FigmaFileResponse
`/v1/files/${fileKey} `
async
getFileNodes
fileKey : string , nodeIds : string []
const
encodeURIComponent
join
','
return
this
request
FigmaNodesResponse
`/v1/files/${fileKey} /nodes?ids=${ids} `
async
getImages
fileKey : string , nodeIds : string [], opts ?: ImageOptions
const
new
URLSearchParams
ids
join
','
format
format
'png'
scale
String
scale
2
return
this
request
FigmaImagesResponse
`/v1/images/${fileKey} ?${params} `
async
getComments
fileKey : string
return
this
request
FigmaCommentsResponse
`/v1/files/${fileKey} /comments`
async
postComment
fileKey : string , message : string , nodeId ?: string
return
this
request
`/v1/files/${fileKey} /comments`
method
'POST'
body
JSON
stringify
client_meta
node_id
async
getLocalVariables
fileKey : string
return
this
request
FigmaVariablesResponse
`/v1/files/${fileKey} /variables/local`
Step 2: Custom Error Classes
export class FigmaApiError extends Error {
constructor (public status : number , public body : string ) {
super (`Figma API error ${status} : ${body} ` );
this .name = 'FigmaApiError' ;
}
}
export class FigmaRateLimitError extends FigmaApiError {
constructor (public retryAfterSeconds : number ) {
super (429 , `Rate limited. Retry after ${retryAfterSeconds} s` );
this .name = 'FigmaRateLimitError' ;
}
}
export class FigmaAuthError extends FigmaApiError {
constructor (message : string ) {
super (403 , message);
this .name = 'FigmaAuthError' ;
}
}
export class FigmaNotFoundError extends FigmaApiError {
constructor (path : string ) {
super (404 , `Resource not found: ${path} ` );
this .name = 'FigmaNotFoundError' ;
}
}
Step 3: Type Definitions
export interface FigmaNode {
id : string ;
name : string ;
type : string ;
children ?: FigmaNode [];
fills ?: Paint [];
strokes ?: Paint [];
absoluteBoundingBox ?: { x : number ; y : number ; width : number ; height : number };
characters ?: string ;
style ?: TypeStyle ;
componentId ?: string ;
backgroundColor ?: Color ;
}
export interface FigmaFileResponse {
name : string ;
lastModified : string ;
version : string ;
thumbnailUrl : string ;
document : FigmaNode ;
components : Record <string , ComponentMeta >;
styles : Record <string , StyleMeta >;
}
export interface FigmaNodesResponse {
nodes : Record <string , { document : FigmaNode ; components : Record <string , ComponentMeta > }>;
}
export interface FigmaImagesResponse {
images : Record <string , string | null >;
}
export interface ImageOptions {
format ?: 'png' | 'svg' | 'jpg' | 'pdf' ;
scale ?: number ;
}
interface Paint { type : string ; color ?: Color ; opacity ?: number }
interface Color { r : number ; g : number ; b : number ; a ?: number }
interface TypeStyle { fontFamily : string ; fontSize : number ; fontWeight : number }
interface ComponentMeta { key : string ; name : string ; description : string }
interface StyleMeta { key : string ; name : string ; style_type : 'FILL' | 'TEXT' | 'EFFECT' | 'GRID' }
Step 4: Node Tree Walker
function walkNodes (node : FigmaNode , visitor : (n: FigmaNode) => void ) {
visitor (node);
if (node.children ) {
for (const child of node.children ) {
walkNodes (child, visitor);
}
}
}
function findTextNodes (root : FigmaNode ): FigmaNode [] {
const results : FigmaNode [] = [];
walkNodes (root, (n ) => {
if (n.type === 'TEXT' ) results.push (n);
});
return results;
}
function findComponents (root : FigmaNode ): FigmaNode [] {
const results : FigmaNode [] = [];
walkNodes (root, (n ) => {
if (n.type === 'COMPONENT' ) results.push (n);
});
return results;
}
Step 5: Singleton with Retry
let client : FigmaClient | null = null ;
export function getFigmaClient ( ): FigmaClient {
if (!client) {
client = new FigmaClient (process.env .FIGMA_PAT !);
}
return client;
}
export async function withRetry<T>(
fn : () => Promise <T>,
maxRetries = 3
): Promise <T> {
for (let attempt = 0 ; attempt <= maxRetries; attempt++) {
try {
return await fn ();
} catch (err) {
if (err instanceof FigmaRateLimitError ) {
await new Promise (r => setTimeout (r, err.retryAfterSeconds * 1000 ));
continue ;
}
if (attempt === maxRetries) throw err;
await new Promise (r => setTimeout (r, 1000 * Math .pow (2 , attempt)));
}
}
throw new Error ('Unreachable' );
}
Output
Typed Figma REST API client with full error handling
Custom error hierarchy for rate limits, auth, not found
Node tree walker for extracting design data
Singleton pattern with retry logic
Error Handling Pattern Use Case Benefit Typed errors catch (e) { if (e instanceof FigmaRateLimitError) }Targeted recovery Node walker Traversing arbitrarily deep trees Handles any file structure Retry wrapper Transient 429/5xx errors Automatic recovery Singleton Shared client across modules Consistent config, one token
Examples Use the typed client (Step 1) with the custom error classes (Step 2) — call sites stay clean:
import { FigmaClient , FigmaRateLimitError , FigmaAuthError } from './figma' ;
const figma = new FigmaClient (process.env .FIGMA_PAT !);
try {
const file = await figma.getFile (process.env .FIGMA_FILE_KEY !, { depth : 1 });
console .log (`${file.name} — ${file.document .children.length} pages` );
} catch (err) {
if (err instanceof FigmaRateLimitError ) scheduleRetry (err.retryAfterSeconds );
else if (err instanceof FigmaAuthError ) alertOps ('figma token invalid' );
else throw err;
}
Count every TEXT node with the tree walker (Step 4) instead of hand-rolled recursion:
const textCount = walkNodes (file.document , (n ) => n.type === 'TEXT' ).length ;
Full type definitions and the retry-wrapped singleton: references/type-definitions.md, references/singleton-with-retry.md.
Resources
Next Steps Apply patterns in figma-core-workflow-a for real-world file inspection.