# Whop Marketplace Scraper API (`lurkapi/whop-marketplace-scraper-api`) Actor

Scrape the Whop marketplace at scale. Export every public product, price, creator, category, rating, and review into one clean spreadsheet. Filter, sort, and rank the whole board without login. Search, product, company, and leaderboard inputs supported.

- **URL**: https://apify.com/lurkapi/whop-marketplace-scraper-api.md
- **Developed by:** [LurkAPI](https://apify.com/lurkapi) (community)
- **Categories:** Agents, Automation, Social media
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.99 / 1,000 product scrapeds

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/docs.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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

## Whop Marketplace Scraper API

Pull every public Whop marketplace product into one clean, normalized dataset. Rank by price, rating, active users, popularity, or newest. Enrich with public reviews and 90-day keyword-GMV series on demand.

_A DIY marketplace-intelligence table for creators picking a niche, agencies scoping competitor prices, and operators sizing category demand on the Whop ecosystem._

### 🎯 What it does

Whop's public marketplace hides real signal behind a scroll-and-click browsing UI. This scraper flattens the whole board into one export so you can sort, filter, and compare products the way a spreadsheet lets you.

- **Full-marketplace scan**: sweep leaderboards or a search query and get up to 10,000 normalized product rows in one run
- **Targeted lookup**: paste product or company URLs to get the exact rows you already care about
- **Deep-value finder**: filter by minimum rating, minimum active users, category, or price range and rank the winners
- **Creator lookup**: every row includes the product's public owner (name, username, bio, profile picture) so you can see who is behind each listing
- **Visual catalog**: rows carry banner, company logo, and gallery image URLs by default
- **Popularity intel**: enrich matched searches with public 90-day daily keyword-GMV series to see which categories are trending
- **Reputation snapshot**: pull public company-level reviews next to every product in one call

Built for creators shopping a niche, agencies tracking competitor pricing, and market analysts studying the creator-commerce economy.

### 📋 How to use it

#### Step 1: Pick your inputs

**Option A: Scan by search or leaderboard.** Paste one or more search terms in **Search queries** (e.g. `productivity`, `fitness`, `language learning`), or paste public search / leaderboard URLs. A single query returns up to 10,000 matching products.

**Option B: Scrape specific products or companies.** Paste public URLs, one per line:

- Product URL: `https://whop.com/focus-coach/pro/`
- Company URL: `https://whop.com/focus-coach/`
- Search URL: `https://whop.com/discover/search/?q=productivity`
- Leaderboard URL: `https://whop.com/discover/leaderboards/` or `https://whop.com/discover/leaderboards/f/newest_arrivals/`

Mix modes freely. A product matched by several inputs is returned once, and its `sourceQueries` / `sourceUrls` cells retain every matched query, URL, and leaderboard filter (pipe-separated).

#### Step 2: Filter and sort

Combine any of these filters (each counts once per emitted row):

- **Price range** in USD
- **Category** name or ID (case-insensitive)
- **Verification**: verified or unverified
- **Free or paid**
- **Minimum rating**
- **Minimum review count**
- **Minimum active users**
- **Product GMV range** (requires revenue add-on)
- **Creation-date range**
- **Plan type**: subscription, one-time, or split pay

Sort options:

- **Source / relevance** (default, free)
- **Newest**
- **Price**
- **Rating**
- **Review count**
- **Active users**
- **Revenue / GMV** (requires revenue add-on)

#### Step 3: Run and read results

Click **Start**. The Output tab has two ready-made views:

- **Overview**: identity, pricing, and metrics at a glance
- **Details**: descriptions, companies, revenue, reviews, images, and source attribution

Every row is a flat set of scalar columns (no nested objects) so exports open cleanly in Excel and Google Sheets. Always check the `status` column first. `success` means the row is a real product. Anything else explains what happened and is not billed.

#### Example output

One row from a search scan, revenue and reviews add-ons off. Flat scalar columns only:

```json
{
    "status": "success",
    "productId": "prod_abc123",
    "url": "https://whop.com/focus-coach/pro/",
    "title": "Focus Coach Pro",
    "route": "pro",
    "headline": "Build your daily deep-focus habit",
    "categoryId": "mcat_productivity",
    "categoryName": "Productivity",
    "verified": true,
    "createdAt": "2024-05-11T18:22:03.000Z",
    "firstApprovedAt": "2024-05-12T09:00:00.000Z",
    "description": "Daily habit prompts, guided focus sessions, and a community of deep workers.",
    "companyId": "biz_focuscoach",
    "companyTitle": "Focus Coach",
    "companyUrl": "https://whop.com/focus-coach/",
    "companyRoute": "focus-coach",
    "companyCreatedAt": "2023-08-01T12:00:00.000Z",
    "companyVerified": true,
    "companyMemberCount": 4720,
    "companyReviewsAverage": 4.7,
    "companyPublishedReviewsCount": 189,
    "companyBusinessType": "coaching_and_courses",
    "companyIndustryGroup": "productivity",
    "companyIndustryType": "habit_coaching",
    "ownerId": "user_focuscoach",
    "ownerName": "Alex Rivera",
    "ownerUsername": "alex-focuscoach",
    "ownerBio": null,
    "ownerCreatedAt": "2023-01-17T23:21:05.000Z",
    "ownerProfilePictureUrl": "https://cdn.whop.com/focus-coach/avatar.jpg",
    "planId": "plan_1",
    "planType": "renewal",
    "currency": "usd",
    "initialPrice": 19,
    "renewalPrice": 19,
    "currentPriceUsd": 19,
    "period": "/month",
    "trialPeriodDays": 7,
    "releaseMethod": "buy_now",
    "free": false,
    "hasFreeAvailablePlan": false,
    "hasPaidAvailablePlan": true,
    "reviewsAverage": 4.8,
    "publishedReviewsCount": 312,
    "activeUsersCount": 1284,
    "whopRanking": 7,
    "productGmvUsd": null,
    "bannerUrl": "https://cdn.whop.com/focus-coach/banner.jpg",
    "companyLogoUrl": "https://cdn.whop.com/focus-coach/logo.jpg",
    "galleryUrls": "https://cdn.whop.com/focus-coach/g1.jpg | https://cdn.whop.com/focus-coach/g2.jpg",
    "sourceTypes": "query",
    "sourceQueries": "productivity",
    "sourceUrls": null,
    "sourceLeaderboardFilters": null,
    "scrapedAt": "2026-07-23T04:05:42.328Z",
    "error": null
}
````

Enable the revenue or reviews add-on and the row gains a nested `revenue` or `reviews` object at the end. Those two are opt-in and intentionally kept nested because they carry per-day and per-review sub-records.

### 💎 Add-ons

Optional extras, all off by default. Turn on only what a run needs.

- **Include revenue enrichment** *(paid)*: Adds product GMV alongside a public 90-day daily keyword-GMV series for every matched search term. Only rows where at least one keyword-revenue lookup succeeded are billed.
- **Include reviews enrichment** *(paid)*: Adds public company-level reviews to every product row (up to 500 per product; 50,000 per run). Companies are deduped so multiple products from the same brand cost one review fetch. Only rows that actually returned reviews are billed.

### 💰 Pricing

Pay only for results you actually get back. No subscription, no minimum.

| Event | Price | When |
|---|---|---|
| Product scraped | **$0.99 per 1,000 products** | per normalized product row emitted to the dataset |
| Add-on: Filter | **$0.10 per 1,000 results** | per active filter, per emitted row (multiple choices inside one filter still count as one) |
| Add-on: Sort | **$0.10 per 1,000 results** | per emitted row, when a non-default sort is used |
| Add-on: Revenue | **$0.10 per 1,000 results** | per emitted row where the revenue enrichment actually returned keyword data |
| Add-on: Reviews | **$0.10 per 1,000 results** | per emitted row where reviews were retrieved |

No charge for filtered-out products, invalid input, empty results, or unavailable exact URLs. Apify's default start event may still apply.

### 💡 Good to know

- **10,000 products per run.** Bounded on purpose so a full-marketplace run stays cheap and predictable.
- **Reviews are per-run capped at 50,000.** Default is 20 per product; the maximum is 500 per product.
- **90-day keyword-GMV is a live snapshot.** It is not an Actor-maintained history. Schedule runs and compare snapshots in your own tool for trends.
- **No cross-run history.** Every run is independent.
- **Dedup is automatic.** The same target reached through a query, product URL, and leaderboard is fetched and billed once. Query text is deduped case-insensitively; product/company URLs are deduped by canonical route.
- **Field coverage matches the source.** If Whop did not publish a value, the cell comes back `null`.
- **Filtering and non-default sorting scan up to 5×** `maxProducts` **candidates**, capped at 10,000, then trim to `maxProducts`. Highly restrictive filters can therefore return fewer rows than `maxProducts` even when more distant results exist.
- **Output toggles** let you trim each row to just the columns you actually need. Disabled groups are omitted from the row entirely.
- Files and datasets live in your Apify storage. How long they are kept depends on your Apify plan.

### ❓ FAQ

**Does it track a product over time?**
No. Every run is a current public snapshot. To watch a product, schedule runs and compare `productId` or `activeUsersCount` values across snapshots in your own tool.

**Why is a cell null?**
Not every seller publishes every value. `null` means the column was requested but the public page did not include it at scrape time.

**Do I need a Whop account?**
No. Only public marketplace pages are read.

**Can I scrape private, member-only, or paid content?**
No. Login-gated and member-only content is out of scope.

**Which proxy should I use?**
Nothing on your side. Networking is managed by the Actor automatically.

**Can I run this on a schedule?**
Yes. Use Apify Schedules to run the Actor on any cadence (hourly, daily, custom cron).

**How long are my results stored?**
Results live in your Apify dataset. How long they are kept depends on your Apify plan.

**Does this cover the Whop App Store?**
Not in v1. Only the public marketplace is scraped.

### ⚖️ Legal Disclaimer

This Actor is for educational, research, and market-intelligence use. It extracts public commercial data (product titles, companies, prices, metrics, and public review text) from publicly accessible Whop marketplace pages. The developer does not host, store, or possess any output; all data is delivered to your Apify dataset. No login-gated or personal user data is collected.

By running this Actor, **you assume full responsibility** for compliance with applicable laws, Whop's Terms of Service, and any data-protection regulations in your target jurisdiction (e.g. GDPR, CCPA). The developer assumes **no liability** for platform blocks, bans, regulatory actions, or any other consequences of your use.

This software is provided **"as-is"** with no warranty. Prices, ratings, popularity signals, and other exposed metrics are public snapshots, not audited figures. Data availability depends on the source at run time.

**Keywords:** Whop scraper, Whop marketplace scraper, Whop products API, Whop company scraper, Whop reviews scraper, marketplace analytics, creator commerce, Whop leaderboards, creator economy data, niche research, competitor pricing, Whop API alternative, creator marketplace data.

# Actor input Schema

## `queries` (type: `array`):

Marketplace search terms, one per line. Duplicates are merged case-insensitively. Leave empty if you only want to scrape specific URLs below.

## `startUrls` (type: `array`):

Public search, product, company, leaderboard, or filtered leaderboard URLs, one per line.

## `maxProducts` (type: `integer`):

Maximum number of normalized product rows returned for the run. Product limit is 10,000 per run.

## `priceMin` (type: `number`):

Keep products at or above this normalized current USD price. Setting either price bound activates one paid price filter.

## `priceMax` (type: `number`):

Keep products at or below this normalized current USD price.

## `category` (type: `string`):

Case-insensitive category name or category ID. Whitespace is trimmed on both sides.

## `verified` (type: `string`):

Keep only verified or only unverified products. Any is free.

## `pricingType` (type: `string`):

Keep products with a free or paid available plan. Any is free.

## `minimumRating` (type: `number`):

Return products at or above this public average rating.

## `minimumReviewCount` (type: `integer`):

Return products with at least this many published reviews.

## `minimumActiveUsers` (type: `integer`):

Return products with at least this many public active users.

## `revenueMin` (type: `number`):

Requires revenue enrichment. Setting either GMV bound activates one paid revenue filter.

## `revenueMax` (type: `number`):

Requires revenue enrichment.

## `createdAfter` (type: `string`):

Setting either date bound activates one paid creation-date filter.

## `createdBefore` (type: `string`):

Latest product creation date, inclusive.

## `planType` (type: `string`):

Return products whose default public plan has this billing type.

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

Source/relevance order is free. Any other sort costs one sorting event per emitted product. Revenue sort requires revenue enrichment.

## `sortDirection` (type: `string`):

Direction for the selected sort field. Source order ignores this setting.

## `includeRevenue` (type: `boolean`):

Adds product GMV and, for matched searches, a public 90-day daily keyword GMV series. Charged only for rows where enrichment succeeded.

## `includeReviews` (type: `boolean`):

Adds public company-level reviews to each product. Charged only for rows where review retrieval succeeded.

## `maxReviewsPerProduct` (type: `integer`):

Used only when reviews enrichment is enabled. Run-wide safety cap is 50,000 returned reviews.

## `includeDescription` (type: `boolean`):

Include the public shortened product description.

## `includeCompany` (type: `boolean`):

Include the nested public company profile.

## `includeOwner` (type: `boolean`):

Include the public product creator (name, username, bio, profile picture).

## `includePricing` (type: `boolean`):

Include the default public plan and normalized current price.

## `includeMetrics` (type: `boolean`):

Include ratings, review count, active users, ranking, and product GMV.

## `includeImages` (type: `boolean`):

Include the product banner, product logo, company logo, and gallery image URLs.

## Actor input object example

```json
{
  "queries": [
    "productivity"
  ],
  "startUrls": [
    "https://whop.com/discover/search/?q=productivity",
    "https://whop.com/discover/leaderboards/"
  ],
  "maxProducts": 100,
  "verified": "any",
  "pricingType": "any",
  "planType": "any",
  "sortBy": "source",
  "sortDirection": "desc",
  "includeRevenue": false,
  "includeReviews": false,
  "maxReviewsPerProduct": 20,
  "includeDescription": true,
  "includeCompany": true,
  "includeOwner": true,
  "includePricing": true,
  "includeMetrics": true,
  "includeImages": true
}
```

# Actor output Schema

## `results` (type: `string`):

No description

# 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 = {
    "queries": [
        "productivity"
    ],
    "startUrls": [
        "https://whop.com/discover/search/?q=productivity",
        "https://whop.com/discover/leaderboards/"
    ],
    "maxProducts": 100,
    "sortBy": "source",
    "maxReviewsPerProduct": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("lurkapi/whop-marketplace-scraper-api").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 = {
    "queries": ["productivity"],
    "startUrls": [
        "https://whop.com/discover/search/?q=productivity",
        "https://whop.com/discover/leaderboards/",
    ],
    "maxProducts": 100,
    "sortBy": "source",
    "maxReviewsPerProduct": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("lurkapi/whop-marketplace-scraper-api").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 '{
  "queries": [
    "productivity"
  ],
  "startUrls": [
    "https://whop.com/discover/search/?q=productivity",
    "https://whop.com/discover/leaderboards/"
  ],
  "maxProducts": 100,
  "sortBy": "source",
  "maxReviewsPerProduct": 20
}' |
apify call lurkapi/whop-marketplace-scraper-api --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Whop Marketplace Scraper API",
        "description": "Scrape the Whop marketplace at scale. Export every public product, price, creator, category, rating, and review into one clean spreadsheet. Filter, sort, and rank the whole board without login. Search, product, company, and leaderboard inputs supported.",
        "version": "0.0",
        "x-build-id": "LfXQzTf7jKJxhC93f"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/lurkapi~whop-marketplace-scraper-api/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-lurkapi-whop-marketplace-scraper-api",
                "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/lurkapi~whop-marketplace-scraper-api/runs": {
            "post": {
                "operationId": "runs-sync-lurkapi-whop-marketplace-scraper-api",
                "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/lurkapi~whop-marketplace-scraper-api/run-sync": {
            "post": {
                "operationId": "run-sync-lurkapi-whop-marketplace-scraper-api",
                "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": {
                    "queries": {
                        "title": "Search queries",
                        "maxItems": 20,
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Marketplace search terms, one per line. Duplicates are merged case-insensitively. Leave empty if you only want to scrape specific URLs below.",
                        "items": {
                            "type": "string",
                            "minLength": 1,
                            "maxLength": 200
                        },
                        "default": []
                    },
                    "startUrls": {
                        "title": "Whop URLs",
                        "maxItems": 100,
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Public search, product, company, leaderboard, or filtered leaderboard URLs, one per line.",
                        "items": {
                            "type": "string",
                            "minLength": 1,
                            "maxLength": 2000
                        },
                        "default": []
                    },
                    "maxProducts": {
                        "title": "Maximum products",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of normalized product rows returned for the run. Product limit is 10,000 per run.",
                        "default": 100
                    },
                    "priceMin": {
                        "title": "Minimum price ($)",
                        "minimum": 0,
                        "type": "number",
                        "description": "Keep products at or above this normalized current USD price. Setting either price bound activates one paid price filter."
                    },
                    "priceMax": {
                        "title": "Maximum price ($)",
                        "minimum": 0,
                        "type": "number",
                        "description": "Keep products at or below this normalized current USD price."
                    },
                    "category": {
                        "title": "Category ($)",
                        "maxLength": 100,
                        "type": "string",
                        "description": "Case-insensitive category name or category ID. Whitespace is trimmed on both sides."
                    },
                    "verified": {
                        "title": "Verification ($)",
                        "enum": [
                            "any",
                            "verified",
                            "unverified"
                        ],
                        "type": "string",
                        "description": "Keep only verified or only unverified products. Any is free.",
                        "default": "any"
                    },
                    "pricingType": {
                        "title": "Free or paid ($)",
                        "enum": [
                            "any",
                            "free",
                            "paid"
                        ],
                        "type": "string",
                        "description": "Keep products with a free or paid available plan. Any is free.",
                        "default": "any"
                    },
                    "minimumRating": {
                        "title": "Minimum rating ($)",
                        "minimum": 0,
                        "maximum": 5,
                        "type": "number",
                        "description": "Return products at or above this public average rating."
                    },
                    "minimumReviewCount": {
                        "title": "Minimum review count ($)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Return products with at least this many published reviews."
                    },
                    "minimumActiveUsers": {
                        "title": "Minimum active users ($)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Return products with at least this many public active users."
                    },
                    "revenueMin": {
                        "title": "Minimum product GMV ($)",
                        "minimum": 0,
                        "type": "number",
                        "description": "Requires revenue enrichment. Setting either GMV bound activates one paid revenue filter."
                    },
                    "revenueMax": {
                        "title": "Maximum product GMV ($)",
                        "minimum": 0,
                        "type": "number",
                        "description": "Requires revenue enrichment."
                    },
                    "createdAfter": {
                        "title": "Created on or after ($)",
                        "type": "string",
                        "description": "Setting either date bound activates one paid creation-date filter."
                    },
                    "createdBefore": {
                        "title": "Created on or before ($)",
                        "type": "string",
                        "description": "Latest product creation date, inclusive."
                    },
                    "planType": {
                        "title": "Plan type ($)",
                        "enum": [
                            "any",
                            "renewal",
                            "one_time",
                            "split_pay"
                        ],
                        "type": "string",
                        "description": "Return products whose default public plan has this billing type.",
                        "default": "any"
                    },
                    "sortBy": {
                        "title": "Sort by",
                        "enum": [
                            "source",
                            "newest",
                            "price",
                            "rating",
                            "reviewCount",
                            "activeUsers",
                            "revenue"
                        ],
                        "type": "string",
                        "description": "Source/relevance order is free. Any other sort costs one sorting event per emitted product. Revenue sort requires revenue enrichment.",
                        "default": "source"
                    },
                    "sortDirection": {
                        "title": "Sort direction",
                        "enum": [
                            "desc",
                            "asc"
                        ],
                        "type": "string",
                        "description": "Direction for the selected sort field. Source order ignores this setting.",
                        "default": "desc"
                    },
                    "includeRevenue": {
                        "title": "Revenue enrichment ($)",
                        "type": "boolean",
                        "description": "Adds product GMV and, for matched searches, a public 90-day daily keyword GMV series. Charged only for rows where enrichment succeeded.",
                        "default": false
                    },
                    "includeReviews": {
                        "title": "Reviews enrichment ($)",
                        "type": "boolean",
                        "description": "Adds public company-level reviews to each product. Charged only for rows where review retrieval succeeded.",
                        "default": false
                    },
                    "maxReviewsPerProduct": {
                        "title": "Maximum reviews per product",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Used only when reviews enrichment is enabled. Run-wide safety cap is 50,000 returned reviews.",
                        "default": 20
                    },
                    "includeDescription": {
                        "title": "Output: description",
                        "type": "boolean",
                        "description": "Include the public shortened product description.",
                        "default": true
                    },
                    "includeCompany": {
                        "title": "Output: company",
                        "type": "boolean",
                        "description": "Include the nested public company profile.",
                        "default": true
                    },
                    "includeOwner": {
                        "title": "Output: owner",
                        "type": "boolean",
                        "description": "Include the public product creator (name, username, bio, profile picture).",
                        "default": true
                    },
                    "includePricing": {
                        "title": "Output: pricing",
                        "type": "boolean",
                        "description": "Include the default public plan and normalized current price.",
                        "default": true
                    },
                    "includeMetrics": {
                        "title": "Output: metrics",
                        "type": "boolean",
                        "description": "Include ratings, review count, active users, ranking, and product GMV.",
                        "default": true
                    },
                    "includeImages": {
                        "title": "Output: images",
                        "type": "boolean",
                        "description": "Include the product banner, product logo, company logo, and gallery image URLs.",
                        "default": true
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```