# Figma Community Scraper (`automation-lab/figma-community-scraper`) Actor

Search public Figma Community plugins, widgets, apps, templates, and creators. Export normalized catalog, engagement, publisher, pricing, and URL data.

- **URL**: https://apify.com/automation-lab/figma-community-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Marketing
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

## Figma Community Scraper

Search public Figma Community resources and creator profiles, then export clean catalog intelligence as JSON.

Figma Community Scraper collects plugins, widgets, apps, Figma design templates, FigJam templates, and Figma Sites templates.
It also searches public creator profiles.
Each result is normalized for analysis, monitoring, enrichment, and downstream automation.
No Figma login, user cookie, or API key is required.

### What does Figma Community Scraper do?

The Actor sends a keyword search to Figma's public Community search surface.
It returns structured records instead of rendered cards or raw HTML.

Use it to:

- research plugin and template categories;
- compare competing Community resources;
- track engagement signals such as likes, users, installs, and followers;
- find creators and publishers around a design topic;
- build resource directories and market maps;
- monitor repeat searches on an Apify schedule;
- feed catalog records into Sheets, databases, BI tools, or AI workflows.

The implementation is HTTP-first and runs with 256 MB of memory.
It does not download thumbnails or other media.

### Who is this Figma Community data for?

**Plugin and template makers** can compare names, positioning, engagement, categories, and publishers.

**Design-tool market researchers** can create repeatable snapshots for keywords such as accessibility, wireframe, dashboard, or AI design.

**Developer-relations teams** can discover public creator profiles and publisher signals for outreach research.

**Agencies and design-ops teams** can build curated resource catalogs for internal workflows.

**Data teams** can schedule searches and send normalized records to a warehouse or dashboard.

### Why use this Actor?

- Anonymous public search: no customer credentials are requested.
- Resource and creator modes in one consistent input contract.
- Six supported resource families.
- Clean plain-text descriptions with source HTML removed.
- Stable IDs and canonical Figma Community URLs for deduplication.
- Engagement, publisher, category, editor, monetization, and timestamp fields where Figma reports them.
- Bounded retries for temporary network, rate-limit, and server failures.
- Fail-visible behavior for blocked or malformed upstream responses.
- Pay-per-event billing tied to the run and records produced.

### What Figma Community data can I extract?

| Field | Meaning |
| --- | --- |
| `figmaId` | Stable Figma result identifier |
| `entityType` | `resource` or `creator` |
| `name` | Resource or profile display name |
| `handle` | Creator profile handle |
| `resourceType` | Plugin, widget, app, or template source type |
| `tagline` | Short resource positioning text |
| `description` | Plain-text resource or profile description |
| `category` | Category ID, name, and URL slug |
| `tags` | Tags reported by Figma |
| `editorTypes` | Compatible Figma editor types |
| `likes` | Community like count |
| `users` | User or unique-run signal reported by Figma |
| `views` | View count when available |
| `installs` | Plugin install count when available |
| `followers` | Creator or publisher follower count |
| `following` | Creator following count |
| `location` | Public profile location |
| `isPaid` | Derived paid-monetization signal |
| `isThirdPartyMonetized` | Third-party monetization flag |
| `publishingStatus` | Public publishing status |
| `publishedAt` | Public profile/resource timestamp when available |
| `createdAt` | Creation timestamp |
| `updatedAt` | Update timestamp |
| `thumbnailUrl` | Source thumbnail URL; image is not downloaded |
| `profileImageUrl` | Creator profile image URL |
| `creator` | Embedded creator summary |
| `publisher` | Embedded publisher summary |
| `url` | Canonical Community resource or profile URL |
| `scrapedAt` | Time this Actor normalized the row |

Fields are nullable because Figma does not report every metric for every resource family.

### Getting started

1. Open the Actor in Apify Console.
2. Enter a real keyword in **Search query**.
3. Choose **Resources** or **Creators**.
4. For resource searches, select the resource families, ordering, and price filter.
5. Set **Maximum items** from 1 to 100.
6. Click **Start**.
7. Open the default dataset to preview, download, or integrate the records.

A useful first run is:

```json
{
  "query": "dashboard",
  "searchMode": "resources",
  "resourceTypes": ["plugins", "widgets", "designTemplates"],
  "sortBy": "relevancy",
  "price": "all",
  "maxItems": 25
}
```

### Input parameters

| Parameter | Type | Default | Description |
| --- | --- | --- | --- |
| `query` | string | `dashboard` prefill | Required non-empty Community search phrase |
| `searchMode` | string | `resources` | Search `resources` or `creators` |
| `resourceTypes` | string\[] | all supported | Plugins, widgets, apps, design templates, FigJam templates, or Sites templates |
| `sortBy` | string | `relevancy` | Resource ordering: `relevancy` or `popular` |
| `price` | string | `all` | Resource price filter: `all`, `free`, or `paid` |
| `maxItems` | integer | `20` | Number of unique normalized rows, from 1 to 100 |

`resourceTypes`, `sortBy`, and `price` apply only to resource searches.
Creator mode uses `query` and `maxItems`.

### Resource type mapping

The friendly input values map to Figma's public source types:

| Input value | Source types |
| --- | --- |
| `plugins` | plugin and weave-app results |
| `widgets` | widgets |
| `apps` | OAuth apps |
| `designTemplates` | Figma design templates |
| `figjamTemplates` | FigJam templates |
| `siteTemplates` | Figma Sites templates |

Select one family for focused competitive research.
Select several families for a broader keyword catalog.

### Output example

A real dashboard-plugin search returns rows shaped like this:

```json
{
  "figmaId": "26d9f55c-6122-47a5-8830-e3ed91fbaee7",
  "entityType": "resource",
  "name": "Dashboard Blueprint",
  "resourceType": "plugin",
  "tagline": "Dashboard Blueprint is a page structure to jumpstart your design projects with ease.",
  "category": {
    "id": "c6555486-845c-4377-91e8-05d4583d3034",
    "name": "Design systems",
    "slug": "design-systems"
  },
  "editorTypes": ["design"],
  "likes": 28,
  "users": 15024,
  "installs": 891,
  "isPaid": false,
  "publishingStatus": "approved_public",
  "creator": {
    "id": "731777893200200113",
    "name": "Sagar Palsapure"
  },
  "publisher": {
    "id": "1841299",
    "name": "Sagar Palsapure",
    "handle": "sagarpalsapure",
    "followers": 9,
    "location": "India"
  },
  "url": "https://www.figma.com/community/plugin/1269988062029001969",
  "scrapedAt": "2026-07-26T07:10:03.829Z"
}
```

The dataset schema includes all possible resource and creator fields.
Use `entityType` when one downstream table receives runs from both modes.

### How much does it cost to search Figma Community?

This Actor uses pay-per-event pricing:

- a **$0.005 start event** per run;
- a plan-dependent tiered **item event** for each saved result;
- the FREE-tier item rate is **$0.000041071 per result**;
- higher Apify plans receive lower per-result tier rates.

At the FREE-tier item rate:

| Useful run | Calculation | Actor charge |
| --- | --- | ---: |
| 10 results | $0.005 + 10 × $0.000041071 | $0.00541071 |
| 25 results | $0.005 + 25 × $0.000041071 | $0.006026775 |
| 50 results | $0.005 + 50 × $0.000041071 | $0.00705355 |
| 100 results | $0.005 + 100 × $0.000041071 | $0.0091071 |

Rejected, duplicate, or absent source rows are not charged as items.
Apify platform usage may be shown separately according to your account and pricing plan.
See the Actor pricing tab for the active tier applicable to your account.

### Monitoring and research workflows

#### Keyword competitor monitor

Run `query: "accessibility"`, choose plugins, sort by popularity, and schedule the Actor weekly.
Store each dataset in a warehouse and compare IDs, likes, users, installs, and update timestamps.

#### Template landscape map

Search one category phrase across design, FigJam, and Sites templates.
Group results by category and publisher to identify crowded and underserved themes.

#### Creator discovery

Use creator mode for topics such as `AI design`, `design systems`, or `education`.
Export handles, follower signals, locations, and profile URLs for manual qualification.
Do not treat a public profile as consent for unsolicited messaging.

#### Internal resource directory

Send approved result rows to Google Sheets, Airtable, Notion, or a database.
Use the canonical URL as the launch link and stable ID as the deduplication key.

### Tips and limits

- Search results reflect Figma's public ranking at run time.
- A run saves at most 100 unique results from the public search response.
- `total_hits` can be larger than the number returned by the source endpoint.
- Popularity metrics are source-provided signals and may use different definitions by resource family.
- Template, app, widget, and plugin records do not expose identical fields.
- Signed thumbnail URLs can expire; use the canonical Community URL as the durable reference.
- The Actor does not download files, templates, plugins, images, or private content.
- No browser or proxy fallback is automatically enabled.
- Temporary network, 429, and 5xx failures receive up to three bounded attempts.
- A challenge, deterministic 4xx response, or changed JSON shape fails the run rather than creating a misleading empty result.

For repeat monitoring, keep the same query and filters so snapshots are comparable.

### Integrations

Use Apify integrations to send results to:

- Google Sheets for lightweight research lists;
- Make or Zapier for notification and enrichment flows;
- webhooks for event-driven pipelines;
- Amazon S3, Google Cloud Storage, or a database through your own consumer;
- Python, JavaScript, or any HTTP client through the Apify API;
- an AI assistant through Apify MCP.

The default dataset is the primary integration output.
It can be downloaded as JSON, JSONL, CSV, XML, Excel, or RSS using Apify dataset endpoints.

### Run with the Apify API using cURL

Replace `APIFY_TOKEN` with your token:

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~figma-community-scraper/runs?token=APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "query": "accessibility",
    "searchMode": "resources",
    "resourceTypes": ["plugins"],
    "sortBy": "popular",
    "price": "all",
    "maxItems": 100
  }'
```

To wait for completion and receive dataset metadata, use the synchronous Actor run endpoint documented by Apify.
For production systems, start asynchronously and poll the run or use a webhook.

### Run with JavaScript

Install the client:

```bash
npm install apify-client
```

Then run the Actor:

```javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/figma-community-scraper').call({
  query: 'dashboard',
  searchMode: 'resources',
  resourceTypes: ['plugins', 'widgets', 'designTemplates'],
  sortBy: 'relevancy',
  price: 'all',
  maxItems: 50,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

### Run with Python

Install the client:

```bash
pip install apify-client
```

Then run the Actor:

```python
import os
from apify_client import ApifyClient

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/figma-community-scraper').call(run_input={
    'query': 'AI design',
    'searchMode': 'creators',
    'maxItems': 80,
})

items = client.dataset(run['defaultDatasetId']).list_items().items
for item in items:
    print(item['name'], item['url'])
```

### Use Figma Community Scraper with MCP

Add the Actor to Claude Code through Apify MCP:

```bash
claude mcp add --transport http apify \
  "https://mcp.apify.com?tools=automation-lab/figma-community-scraper"
```

For **Claude Desktop**, add this server to the MCP configuration:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=automation-lab/figma-community-scraper"
    }
  }
}
```

For **Cursor**, add the same JSON under Cursor Settings → MCP.

For **VS Code**, add the same HTTP endpoint through your MCP extension's server configuration.

Example prompts:

- “Search Figma Community for popular accessibility plugins and summarize the top publishers.”
- “Find creators related to AI design and return profile URLs and follower signals.”
- “Collect dashboard templates, then group them by category and publisher.”

### Responsible use and legality

The Actor accesses public Figma Community search records.
It does not bypass login, download protected resources, or access private Figma files.

You are responsible for your use of the data.
Review Figma's terms, applicable database and copyright rules, and privacy or marketing laws for your jurisdiction and use case.
Do not use public profile data for harassment, spam, discrimination, or attempts to infer sensitive personal traits.
Minimize stored personal data and honor valid deletion or objection requests where applicable.

This Actor is an independent automation tool and is not affiliated with or endorsed by Figma.
Figma is a trademark of its respective owner.

### Troubleshooting

#### Why did my run return fewer than `maxItems`?

The source may return fewer matching records, or normalization may reject rows without a stable ID, name, and canonical URL.
Try a broader query, more resource families, `price: "all"`, or relevance ordering.

#### Why did the run fail with an upstream response error?

Figma may have rate-limited the request, changed its public endpoint, or returned a challenge.
Temporary network, 429, and 5xx failures are retried automatically.
Check the Actor log before rerunning; do not repeatedly retry a deterministic 4xx failure.

#### Why are some metrics missing?

Figma reports different fields for plugins, widgets, apps, templates, and profiles.
Missing optional fields are expected and remain absent rather than being fabricated as zero.

#### Why does a thumbnail URL no longer load?

Some source image URLs are signed and expire.
The Actor returns them as observed, but the canonical `url` is the durable link to retain.

### FAQ

#### Does it require a Figma account?

No.
The supported searches use anonymous public Community JSON endpoints.

#### Can it scrape private Figma files?

No.
The Actor only searches public Community resources and profiles.

#### Can it download plugins or template files?

No.
It exports catalog metadata and canonical URLs, not resource binaries.

#### Does it support pagination beyond 100 results?

No.
The current public search response exposes up to 100 result records to this workflow.
The input limit makes that boundary explicit.

#### Can I filter by category?

Use a category keyword in `query` and choose relevant resource families.
The output includes the category Figma reports, but there is no separate category-ID input.

#### Is creator mode mixed with resource results?

No.
Each run selects one mode, so downstream consumers receive a consistent entity focus.
The shared dataset schema supports both modes across separate runs.

### Related Automation Lab Actors

For broader app and marketplace intelligence, combine these records with:

- [Apple App Store Scraper](https://apify.com/automation-lab/apple-app-store-scraper) for iOS app catalog and publisher research;
- [Google Play Store Scraper](https://apify.com/automation-lab/google-play-scraper) for Android app catalog intelligence;
- [Notion Templates Marketplace Scraper](https://apify.com/automation-lab/notion-templates-marketplace-scraper) for cross-platform template landscape research;
- [Miro Marketplace Scraper](https://apify.com/automation-lab/miro-marketplace-scraper) for collaborative-tool marketplace comparisons.

Use stable source IDs and canonical URLs to keep each platform's records separate in a shared warehouse.

# Actor input Schema

## `query` (type: `string`):

Keyword or phrase to search in Figma Community.

## `searchMode` (type: `string`):

Return Community resources or creator profiles.

## `resourceTypes` (type: `array`):

Resource families to include. Leave unchanged to search all supported families.

## `sortBy` (type: `string`):

Ordering used for resource results.

## `price` (type: `string`):

Filter resources by Figma Community pricing.

## `maxItems` (type: `integer`):

Maximum number of normalized records saved from the Community search response.

## Actor input object example

```json
{
  "query": "dashboard",
  "searchMode": "resources",
  "resourceTypes": [
    "plugins",
    "widgets",
    "apps",
    "designTemplates",
    "figjamTemplates",
    "siteTemplates"
  ],
  "sortBy": "relevancy",
  "price": "all",
  "maxItems": 20
}
```

# Actor output Schema

## `dataset` (type: `string`):

Dataset containing normalized Figma Community results.

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "query": "dashboard",
    "maxItems": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/figma-community-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "query": "dashboard",
    "maxItems": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/figma-community-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "query": "dashboard",
  "maxItems": 20
}' |
apify call automation-lab/figma-community-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=automation-lab/figma-community-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/acts/S3WWjOsld9aRf2kJm/builds/LGzbyIHjQFmeVO2hq/openapi.json