# Apify Store Scraper (`extractmaster01/apify-store-scraper`) Actor

Scrape the entire Apify Store and export 30+ fields per actor — usage trends,
run success rates, pricing, ratings, and more. 10 built-in filters. Results
in under 10 seconds. Built for niche validation, competitor analysis, and
pricing intelligence.

- **URL**: https://apify.com/extractmaster01/apify-store-scraper.md
- **Developed by:** [extractmaster01](https://apify.com/extractmaster01) (community)
- **Categories:** Developer tools, Automation
- **Stats:** 3 total users, 2 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.00 / 1,000 result extracteds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

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

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use 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

### What does Apify Store Scraper do?

**Apify Store Scraper** is the **only actor that exports structured data from the entire [Apify Store](https://apify.com/store)** — the world's largest collection of web scraping and automation tools. Search, filter, and export the full catalog in **under 10 seconds**, with **10 built-in filters**, **35 output fields** (including usage trends and run success rates), and no proxies or coding required.

Built for **Apify developers who want to know what to build before they build it** — validate your niche, benchmark competitors, and set the right price in under a minute. Also used by analysts studying the Apify ecosystem and AI pipelines that need structured actor metadata at scale. **From $0.10 for 100 results.**

With this scraper, you can **filter actors by category, pricing model, rating, and user count**, then export everything as JSON or CSV. Each result includes the actor's title, description, pricing details, review score, and developer information — all in one clean, structured dataset.

---

### What can Apify Store Scraper extract?

The following data is extracted for each actor found in the Apify Store:

| Field | Description |
|---|---|
| `actorId` | Unique actor ID on the Apify platform |
| `url` | Direct link to the actor's Store page |
| `title` | Display title of the actor |
| `name` | URL slug (e.g. `google-maps-scraper`) |
| `username` | Developer's Apify username |
| `userFullName` | Developer's display name |
| `userPictureUrl` | URL of the developer's profile picture |
| `pictureUrl` | URL of the actor's icon or thumbnail |
| `description` | Short description shown in the Store listing |
| `readmeSummary` | Auto-generated summary of the actor's README |
| `categories` | Categories the actor belongs to (e.g. `AI`, `SOCIAL_MEDIA`) |
| `managedBy` | `APIFY` (official) or `COMMUNITY` (independent developer) |
| `notice` | Status notice: `NONE`, `DEPRECATED`, `UNDER_MAINTENANCE` |
| `badge` | Quality badge assigned by Apify (e.g. `VERIFIED`), or `null` |
| `isCritical` | Whether Apify considers this a critical infrastructure actor |
| `createdAt` | Publication date |
| `modifiedAt` | Date of last update |
| `totalUsers` | All-time total number of users |
| `totalUsers7Days` | Users in the last 7 days |
| `totalUsers30Days` | Users in the last 30 days |
| `totalUsers90Days` | Users in the last 90 days |
| `totalRuns` | All-time total number of runs |
| `totalBuilds` | All-time total number of builds |
| `lastRunStartedAt` | Timestamp of the most recent run |
| `runStats30Days` | Run outcome breakdown over the last 30 days: `SUCCEEDED`, `FAILED`, `ABORTED`, `TIMED-OUT`, `TOTAL` |
| `bookmarkCount` | Number of times the actor was bookmarked |
| `actorReviewRating` | Average rating (1–5 scale) |
| `actorReviewCount` | Number of user reviews |
| `currentPricingInfo.pricingModel` | Pricing type: `FREE`, `PAY_PER_EVENT`, `PRICE_PER_DATASET_ITEM`, `PAY_PER_USAGE`, `FLAT_PRICE_PER_MONTH` |
| `currentPricingInfo.pricingPerEvent` | Price per event breakdown (if Pay Per Event model) |
| `seoTitle` | SEO title configured by the developer |
| `seoDescription` | SEO description configured by the developer |
| `storePosition` | Position in the Apify Store listing |
| `isWhiteListedForAgenticPayments` | Whether the actor supports agentic payment flows |

---

### Why use Apify Store Scraper?

Whether you're a developer building tools on top of the Apify ecosystem or a researcher analyzing the marketplace, **Apify Store Scraper** gives you the data you need — instantly and at scale.

Here are the most common use cases:

- 🏗️ **Niche validation** — before spending weeks building, check if your actor idea already exists, how saturated the category is, and what price point is winning
- 🔍 **Market research** — analyze which actor categories and pricing models dominate the Store
- 🏆 **Competitor analysis** — benchmark actors in your niche by user count, rating, bookmarks, and pricing
- 👤 **Developer profiling** — collect all actors published by a specific username or organization
- 💡 **Tool discovery** — find the best-rated, most popular, or newest actors for a specific task
- 💰 **Pricing intelligence** — see what pricing models and price points are winning in each category
- 📊 **Ecosystem monitoring** — schedule weekly runs to track new actors and changes in popularity over time
- 🤖 **AI pipelines** — feed Store metadata into LLMs for automated actor recommendations or gap analysis

---

### Why Apify Store Scraper vs alternatives?

| Approach | Cost | Coverage | Setup time | Scheduling | Export formats |
|---|---|---|---|---|---|
| **Apify Store Scraper** (this actor) | From $0.10/1K | Full catalog | ⚡ 1 click | ✅ Built-in | JSON, CSV, Excel, XML |
| Manual Store browsing | Free | Limited by time | — | ❌ Manual | None |
| Direct Apify API | Free | Full | 🔧 2–4 hours coding | ❌ Custom | Custom |
| Other Store scrapers | $0.50–$100/1K | Partial | 1 click | Varies | Varies |

**Apify Store Scraper is the only option that combines one-click setup, full catalog coverage, 10 filters, scheduling, and instant multi-format export at the lowest cost per result.**

---

### How to use Apify Store Scraper

1. Click **Try for free** on this page
2. Set your **search query** (e.g. `"instagram"`, `"tiktok"`, `"google"`) or leave empty to get all actors
3. Choose filters: **category**, **pricing model**, **minimum rating**, or **maintainer** (Apify vs. Community)
4. Set the **maximum number of results** you need — use a small value for a quick sample or a high value to cover the entire Store
5. Click **Run** and wait a few seconds
6. **Download your data** from the Dataset tab as JSON, CSV, Excel, or XML

> 💡 **Tip:** Sort by `mostPopular` to get actors with the largest user base first. Sort by `newest` to monitor newly published actors.

---

### Input examples

#### Find all paid competitors in a category before launching your own actor

```json
{
    "maxItems": 200,
    "categories": ["LEAD_GENERATION"],
    "pricingModel": ["PAY_PER_EVENT", "PRICE_PER_DATASET_ITEM", "FLAT_PRICE_PER_MONTH"],
    "minUsers": 100,
    "sortBy": "mostPopular"
}
````

#### Find the most popular TikTok scrapers

```json
{
    "query": "tiktok",
    "maxItems": 50,
    "sortBy": "mostPopular",
    "categories": ["SOCIAL_MEDIA"]
}
```

#### Find all free AI actors from Apify

```json
{
    "maxItems": 200,
    "categories": ["AI"],
    "pricingModel": ["FREE"],
    "managedBy": "APIFY"
}
```

#### Find all actors by a specific developer

```json
{
    "username": "apify",
    "maxItems": 1000,
    "sortBy": "mostPopular"
}
```

#### Find highly-rated lead generation actors

```json
{
    "maxItems": 100,
    "categories": ["LEAD_GENERATION"],
    "minRating": 4,
    "minUsers": 500,
    "sortBy": "mostPopular"
}
```

#### Monitor newly launched actors in a category

```json
{
    "maxItems": 100,
    "categories": ["AI"],
    "sortBy": "newest"
}
```

#### Find well-bookmarked actors in a niche

```json
{
    "query": "email",
    "maxItems": 50,
    "minBookmarks": 10,
    "sortBy": "mostPopular"
}
```

#### Find recently updated actors in a category

```json
{
    "maxItems": 100,
    "categories": ["ECOMMERCE"],
    "sortBy": "lastUpdated"
}
```

#### Export the entire Apify Store

To export all actors, simply remove the `maxItems` field from your input. The actor will automatically scrape everything until the Store is fully extracted.

```json
{
    "sortBy": "mostPopular"
}
```

***

### Output example

Each item in the dataset represents one actor from the Apify Store:

```json
{
    "actorId": "zcVlfasqL3DpUAJxc",
    "url": "https://apify.com/extractmaster01/website-screenshot-generator",
    "title": "🔥 Website Screenshot Generator",
    "name": "website-screenshot-generator",
    "username": "extractmaster01",
    "userFullName": "extractmaster01",
    "userPictureUrl": "https://images.apifyusercontent.com/u5z2K3LyL_hv5FjSA2e-HdoMbmA7aXPpaslEwtn5ZrM/rs:fill:32:32/cb:1/aHR0cHM6Ly9...",
    "description": "[🥇 high-quality 🏆] Website Screenshot generator for full-page, viewport, and element screenshots. Capture websites as PNG, JPEG, WebP, or PDF with mobile emulation, metadata extraction, and batch processing.",
    "readmeSummary": "A scalable website screenshot tool that captures high-fidelity screenshots (full-page, viewport, or element) across desktop and mobile device emulations and exports visual outputs in PNG, JPEG, WebP, or PDF.",
    "pictureUrl": "https://apify-image-uploads-prod.s3.us-east-1.amazonaws.com/wBmqLlMi5gbu8DiD6-actor-zcVlfasqL3DpUAJxc-Ls971RMJV7-download-icone.png",
    "categories": ["AUTOMATION", "DEVELOPER_TOOLS", "SEO_TOOLS"],
    "managedBy": "COMMUNITY",
    "notice": "NONE",
    "badge": null,
    "isCritical": false,
    "createdAt": "2026-06-12T04:20:50.448Z",
    "modifiedAt": "2026-06-12T05:01:41.000Z",
    "totalUsers": 2,
    "totalUsers7Days": 1,
    "totalUsers30Days": 1,
    "totalUsers90Days": 1,
    "totalRuns": 7,
    "totalBuilds": 5,
    "lastRunStartedAt": "2026-06-13T05:04:15.066Z",
    "runStats30Days": {
        "SUCCEEDED": 2,
        "FAILED": 0,
        "ABORTED": 0,
        "TIMED-OUT": 0,
        "TOTAL": 2
    },
    "bookmarkCount": 0,
    "actorReviewRating": 0,
    "actorReviewCount": 0,
    "currentPricingInfo": {
        "pricingModel": "PAY_PER_EVENT",
        "pricingPerEvent": {
            "actorChargeEvents": {
                "apify-actor-start": {
                    "eventTitle": "Actor Start",
                    "eventDescription": "Charged when the Actor starts running.",
                    "isOneTimeEvent": true,
                    "eventPriceUsd": 0.01
                },
                "apify-default-dataset-item": {
                    "eventTitle": "result",
                    "eventDescription": "Single result in the default dataset.",
                    "isOneTimeEvent": false,
                    "eventPriceUsd": 0.003,
                    "isPrimaryEvent": true
                }
            }
        }
    },
    "seoTitle": null,
    "seoDescription": null,
    "storePosition": 22714,
    "isWhiteListedForAgenticPayments": false
}
```

> **Note:** `currentPricingInfo` reflects the pricing of the actor being described (in this example, Website Screenshot Generator charges $0.003 per result). This is data returned by the scraper — it is not related to the cost of running Apify Store Scraper itself.

***

### How much does it cost to run Apify Store Scraper?

**Apify Store Scraper** uses a **Pay Per Event** pricing model — you only pay for the actors successfully extracted. No subscription, no minimums.

| Use case | Results | Estimated cost |
|---|---|---|
| Quick niche snapshot | 100 actors | ~$0.10 |
| Category competitor sweep | 500 actors | ~$0.50 |
| Full developer catalog | 1,000 actors | ~$1.00 |
| Deep market analysis | 5,000 actors | ~$5.00 |
| Large-scale export | 25,000 actors | ~$25.00 |

Apify Store Scraper **does not use proxies or browser rendering** — it calls the Apify Store's public search API directly. This makes runs extremely fast (typically under 10 seconds for 100 results) and very cheap to operate.

***

### Real-world example: validating a niche in 60 seconds

**Scenario:** You're about to build a TikTok scraper. Before spending two weeks coding, you want to know how saturated the market is.

**Step 1:** Run this actor with the input below.

```json
{
    "query": "tiktok",
    "maxItems": 50,
    "sortBy": "mostPopular",
    "categories": ["SOCIAL_MEDIA"]
}
```

**Step 2:** The run completes in under 5 seconds. Click **Dataset → Download → CSV**.

**Step 3:** Open the CSV in Google Sheets (`File → Import → Upload`). Sort by `totalUsers` descending.

**Step 4:** You now see the top 50 TikTok actors, their user counts, ratings, pricing models, and when they were last updated. You can instantly identify which niches are dominated, which have weak competition, and what price point the market accepts.

**Total time:** Under 2 minutes. **Cost:** ~$0.05.

***

### Apify platform advantages

By running **Apify Store Scraper** on the Apify platform, you get all of these for free:

- ⏱️ **Scheduling** — run on a daily, weekly, or custom cron schedule to monitor the Store over time
- 🔌 **API access** — trigger runs and retrieve data programmatically via the Apify API
- 🔗 **Integrations** — connect directly with Google Sheets, Zapier, Make, Slack, Airbyte, and more
- 📦 **Export formats** — download results as JSON, CSV, XML, Excel, or HTML
- 📡 **Webhooks** — trigger actions automatically when a run completes
- 📊 **Run monitoring** — track performance, logs, and history from the Apify Console
- 🔒 **Secure storage** — your datasets are stored securely and available on demand

***

### Is it legal to scrape the Apify Store?

**Apify Store Scraper** only accesses **publicly available data** from the Apify Store marketplace — the same data you can see by visiting [apify.com/store](https://apify.com/store) in any browser.

This scraper does not extract any private user data, passwords, email addresses, or any information not explicitly displayed on the public Store pages. We therefore believe that using this scraper for ethical research, market analysis, or tool discovery purposes is safe.

However, you are responsible for how you use the extracted data. Personal data (such as developer names and profile pictures that are publicly listed) is protected under GDPR in the European Union and other regulations worldwide. Use data responsibly and in compliance with applicable laws. If in doubt, consult your legal team.

***

### Frequently asked questions

#### Why not just call the Apify Store API directly?

You can — `api.apify.com/v2/store` is public. But to use it you need to write code, handle pagination, build your own filters, manage authentication for rate limits, and manually export results to a spreadsheet. This actor does all of that for you in a single click, with 10 built-in filters, instant CSV/JSON/Excel export, scheduling, and integrations with Google Sheets, Zapier, and Make. For non-coders, it's the only option. For developers, it saves hours.

#### Does Apify Store Scraper work without an Apify account?

No — you need a free Apify account to run actors on the platform. Creating one takes less than a minute.

#### How many actors are available on the Apify Store?

Thousands of actors and growing continuously. The actor stops automatically when there are no more results, so set `maxItems` to any large value to cover the full Store.

#### How do I validate a niche before building my own actor?

Run this actor with your niche keyword as the search query (e.g., `"instagram"`) and `sortBy` set to `mostPopular`. You'll instantly see how many actors already exist, who the dominant players are, what pricing models they use, and how many users the top actors have. This tells you whether the niche is saturated, underserved, or nonexistent — in under 60 seconds.

#### Can I filter actors by multiple categories at once?

Yes. Set the `categories` input to an array with multiple values, for example `["AI", "SOCIAL_MEDIA", "ECOMMERCE"]`. Results will include actors that match **any** of the selected categories.

#### Can I get all actors from a specific developer?

Yes — use the `username` input field with the developer's Apify username. For example, setting `username` to `"apify"` returns all actors published by Apify's official team.

#### What is the difference between `APIFY` and `COMMUNITY` in the `managedBy` filter?

- `APIFY` — actors built and maintained by the Apify team
- `COMMUNITY` — actors built by independent developers (the vast majority of the Store)

#### What pricing models exist in the Apify Store?

Based on live Store data, three models are active:

- `FREE` — no cost beyond standard platform usage
- `PAY_PER_EVENT` — pay per result extracted (most common)
- `FLAT_PRICE_PER_MONTH` — fixed monthly subscription

#### How do I get only free actors?

Set `pricingModel` to `["FREE"]`. This returns all actors that have no cost beyond standard Apify platform usage.

#### Can I scrape Apify Store data via API?

Yes. Once you have an Apify account, you can trigger this Actor and retrieve results via the [Apify API](https://docs.apify.com/api/v2). The API tab on this page shows ready-to-use code examples in Node.js, Python, and cURL.

#### How often is the Apify Store data updated?

The data reflects the live state of the Apify Store at the time of each run. Schedule the Actor to run daily or weekly to track changes over time — new actors, rating changes, and user count shifts.

#### Can I monitor competitor actors over time?

Yes. Schedule this actor to run weekly with a fixed query (e.g., your niche keyword + `sortBy: mostPopular`). Each run produces a new dataset snapshot. Compare datasets across runs to detect new entrants, rating changes, and user count growth in your category.

***

### You might also like

If you found this Actor useful, you might also like:

| Actor | What it does |
|---|---|
| [🔥 Website Screenshot Generator](https://apify.com/extractmaster01/website-screenshot-generator) | Full-page, viewport, and element screenshots in PNG, JPEG, WebP, or PDF. Supports mobile emulation, metadata extraction, and batch processing. |
| [Website Contact Scraper](https://apify.com/extractmaster01/website-contact-scraper) | Crawls any website and extracts emails, phone numbers, and 14 social media profiles (LinkedIn, Twitter/X, Instagram, Facebook, WhatsApp, and more). Pay per email found. |
| [🔥 Google Ads Transparency Center Scraper](https://apify.com/extractmaster01/google-ads-scraper) | Extract VIDEO, IMAGE, and TEXT ad creatives for any advertiser from the Google Ads Transparency Center. Filter by region, platform, and date. $1 per 1,000 ads. |

***

### Support

Found a bug or want a new feature? Open a ticket on the **Issues tab** above — I read and respond to all feedback.

For custom data extraction needs or integrations, feel free to reach out through the Issues tab.

# Actor input Schema

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

Text to search across actor titles, names, descriptions, and README files. Leave empty to return all actors.

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

Limit the number of actors to extract. Leave empty to scrape the entire Store — the actor stops automatically when there are no more results.

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

How to order the results.

## `categories` (type: `array`):

Filter by one or more categories. Results include actors matching ANY of the selected categories.

## `pricingModel` (type: `array`):

Filter by pricing model. Results include actors matching ANY of the selected models.

## `managedBy` (type: `string`):

Filter by who maintains the actor.

## `username` (type: `string`):

Filter actors by a specific developer's Apify username.

## `actorId` (type: `string`):

Fetch a specific actor by its unique Apify ID.

## `minRating` (type: `number`):

Only include actors with an average rating equal to or above this value (1–5 scale).

## `minUsers` (type: `integer`):

Only include actors with at least this many total users.

## `minBookmarks` (type: `integer`):

Only include actors with at least this many bookmarks.

## Actor input object example

```json
{
  "query": "instagram scraper",
  "sortBy": "relevance",
  "managedBy": "ALL",
  "username": "apify",
  "actorId": "aYG0l9s7dbB7j3gbS",
  "minRating": 4,
  "minUsers": 100,
  "minBookmarks": 10
}
```

# 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": "instagram scraper",
    "username": "apify",
    "actorId": "aYG0l9s7dbB7j3gbS",
    "minRating": 4,
    "minUsers": 100,
    "minBookmarks": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("extractmaster01/apify-store-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": "instagram scraper",
    "username": "apify",
    "actorId": "aYG0l9s7dbB7j3gbS",
    "minRating": 4,
    "minUsers": 100,
    "minBookmarks": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("extractmaster01/apify-store-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": "instagram scraper",
  "username": "apify",
  "actorId": "aYG0l9s7dbB7j3gbS",
  "minRating": 4,
  "minUsers": 100,
  "minBookmarks": 10
}' |
apify call extractmaster01/apify-store-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Apify Store Scraper",
        "description": "Scrape the entire Apify Store and export 30+ fields per actor — usage trends, \nrun success rates, pricing, ratings, and more. 10 built-in filters. Results \nin under 10 seconds. Built for niche validation, competitor analysis, and \npricing intelligence.",
        "version": "0.0",
        "x-build-id": "oLv6gIOTIcj1yaysb"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/extractmaster01~apify-store-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-extractmaster01-apify-store-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/extractmaster01~apify-store-scraper/runs": {
            "post": {
                "operationId": "runs-sync-extractmaster01-apify-store-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/extractmaster01~apify-store-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-extractmaster01-apify-store-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "query": {
                        "title": "Search Query",
                        "type": "string",
                        "description": "Text to search across actor titles, names, descriptions, and README files. Leave empty to return all actors."
                    },
                    "maxItems": {
                        "title": "Maximum Results",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Limit the number of actors to extract. Leave empty to scrape the entire Store — the actor stops automatically when there are no more results."
                    },
                    "sortBy": {
                        "title": "Sort By",
                        "enum": [
                            "relevance",
                            "mostPopular",
                            "newest",
                            "lastUpdated"
                        ],
                        "type": "string",
                        "description": "How to order the results.",
                        "default": "relevance"
                    },
                    "categories": {
                        "title": "Categories",
                        "type": "array",
                        "description": "Filter by one or more categories. Results include actors matching ANY of the selected categories.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "AI",
                                "AGENTS",
                                "AUTOMATION",
                                "BUSINESS",
                                "DEVELOPER_TOOLS",
                                "EDUCATION",
                                "ECOMMERCE",
                                "FOR_CREATORS",
                                "INTEGRATIONS",
                                "JOBS",
                                "LEAD_GENERATION",
                                "MARKETING",
                                "MCP_SERVERS",
                                "NEWS",
                                "OPEN_SOURCE",
                                "OTHER",
                                "REAL_ESTATE",
                                "SEO_TOOLS",
                                "SOCIAL_MEDIA",
                                "SPORTS",
                                "TRAVEL",
                                "VIDEOS"
                            ],
                            "enumTitles": [
                                "AI",
                                "Agents",
                                "Automation",
                                "Business",
                                "Developer Tools",
                                "Education",
                                "E-commerce",
                                "For Creators",
                                "Integrations",
                                "Jobs",
                                "Lead Generation",
                                "Marketing",
                                "MCP Servers",
                                "News",
                                "Open Source",
                                "Other",
                                "Real Estate",
                                "SEO Tools",
                                "Social Media",
                                "Sports",
                                "Travel",
                                "Videos"
                            ]
                        }
                    },
                    "pricingModel": {
                        "title": "Pricing Model",
                        "type": "array",
                        "description": "Filter by pricing model. Results include actors matching ANY of the selected models.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "FREE",
                                "PAY_PER_EVENT",
                                "PRICE_PER_DATASET_ITEM",
                                "PAY_PER_USAGE",
                                "FLAT_PRICE_PER_MONTH"
                            ],
                            "enumTitles": [
                                "Free",
                                "Pay Per Event",
                                "Pay Per Result",
                                "Pay Per Usage",
                                "Monthly Flat Rate (deprecated)"
                            ]
                        }
                    },
                    "managedBy": {
                        "title": "Maintained By",
                        "enum": [
                            "ALL",
                            "APIFY",
                            "COMMUNITY"
                        ],
                        "type": "string",
                        "description": "Filter by who maintains the actor.",
                        "default": "ALL"
                    },
                    "username": {
                        "title": "Developer Username",
                        "type": "string",
                        "description": "Filter actors by a specific developer's Apify username."
                    },
                    "actorId": {
                        "title": "Actor ID",
                        "type": "string",
                        "description": "Fetch a specific actor by its unique Apify ID."
                    },
                    "minRating": {
                        "title": "Minimum Rating",
                        "minimum": 1,
                        "maximum": 5,
                        "type": "number",
                        "description": "Only include actors with an average rating equal to or above this value (1–5 scale)."
                    },
                    "minUsers": {
                        "title": "Minimum Total Users",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Only include actors with at least this many total users."
                    },
                    "minBookmarks": {
                        "title": "Minimum Bookmarks",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Only include actors with at least this many bookmarks."
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
