# Whop Scraper - Products, Sellers & Content Rewards Campaigns (`webdatalabs/whop-marketplace-intelligence`) Actor

Scrape whop.com marketplace products with prices and categories, seller/company intelligence, and Content Rewards clipping campaigns with reward-per-1k-views and remaining budget. No login. Opt-in change tracking across scheduled runs.

- **URL**: https://apify.com/webdatalabs/whop-marketplace-intelligence.md
- **Developed by:** [WebDataLabs](https://apify.com/webdatalabs) (community)
- **Categories:** E-commerce, Automation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 1,000 campaign scrapeds

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

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

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 Scraper - Products, Sellers & Content Rewards Campaigns

Scrape **whop.com** and the **Content Rewards** campaign feed without logging in. Find the
highest-paying clipping campaigns, research what sells in a niche, and track how prices, budgets
and communities move over time.

### What you get

**Campaigns** - every live Content Rewards clipping campaign in one run:

| Field | Example |
|---|---|
| Reward per 1,000 views | `3` |
| Total budget / spent / **remaining** | `250000` / `199887.63` / `50112.37` |
| Progress | `79.96` % |
| Platforms | `tiktok, instagram, youtube` |
| Type / status | `clipping` / `active` |
| Views delivered | `126700000` |

**Products** - name, price, currency, billing period (in days), release method, trial length, stock,
rating, review count, seller.

**Sellers** - company name, route, category, member count, average rating, review count, verified
and live flags.

#### Example output (campaign)

```json
{
  "recordType": "campaign",
  "url": "https://contentrewards.com/discover/dd9f7918-e51d-4935-9f23-5935c783774a",
  "title": "CapCut Clipping",
  "brand": "CapCut",
  "rewardPerThousandViewsUsd": 3,
  "totalBudgetUsd": 30000,
  "budgetSpentUsd": 225.54,
  "budgetRemainingUsd": 29774.46,
  "progressPercentage": 0.75,
  "campaignType": "clipping",
  "status": "active",
  "socialPlatforms": ["youtube"],
  "viewCount": 124000,
  "isVerified": true,
  "changeType": "new",
  "firstSeenAt": "2026-07-20T09:00:00.000Z",
  "scrapedAt": "2026-07-27T10:31:00.000Z"
}
````

### Use it for

- **Find the best-paying campaigns** - sort by reward per 1,000 views, filter to campaigns that
  still have budget left. A campaign at 98% progress is not worth clipping.
- **Niche and pricing research** - what products exist in a category, what they charge, how big and
  how well-reviewed their communities are.
- **Competitor monitoring** - schedule it and get told when a price moves, a budget drains, or a
  campaign ends.

### Change tracking

Turn on **Track changes between runs** and schedule the actor. Every record is tagged:

`new` · `active` · `price_change` · `reward_change` · `budget_drop` · `ended` · `delisted`

plus `firstSeenAt`, `lastSeenAt`, `daysTracked`, and the previous price/reward/budget on rows that
moved. The first run is the baseline, so nothing is reported as ended on run one. State is kept in a
named key-value store per target, so scheduled runs compare against the previous run rather than
starting cold.

Unchanged records are still returned (tagged `active`) - a run that returned almost nothing would
look broken. Filter to the change types you care about.

### Input

| Field | Description |
|---|---|
| **What to scrape** | `campaigns`, `products` or `sellers` |
| **Search or category** | Keyword filter; in Sellers mode also picks the category pages to crawl |
| **Specific Whop URLs** | Paste product, company or category-browse URLs to target them exactly |
| **Max results** | Cap per run - keep it low for a cheap trial |
| **Track changes between runs** | Tags deltas against the previous run |

Everything else (proxy, country, retries) has a sensible default under *Advanced*.

### Pricing

Pay per result, with **one price per mode** - each run scrapes a single record type, so your cost
is always `results x one number`. No start fee, no surcharges.

| You scrape | Price per result |
|---|---|
| Campaigns | $0.002 |
| Sellers | $0.004 |
| Products | $0.012 |

Products cost more because each one is a full page fetch, while a single request returns ~500
campaigns or 24 sellers at a time.

Examples: 500 campaigns = **$1.00** · 740 sellers = **$2.96** · 50 products = **$0.60**.

### Speed and freshness

Sellers mode can crawl Whop's whole category taxonomy (**894 category pages**, ~18 minutes,
**6,440 distinct companies**). Category pages are **cached between runs** and re-used while they
are younger than **Reuse category data younger than** (default 24 hours, Advanced), so repeat runs
over the same categories return almost immediately.

Most of the value arrives early: the taxonomy is a tree, so child categories largely repeat the
companies of their parents. Scoping with **Search or category** (for example `trading`) gets you a
category's companies in seconds instead of crawling everything.

- Cached rows keep the `scrapedAt` of the run that actually fetched them, so a record never claims
  to be fresher than it is.
- Set the value to `0` to always fetch fresh.
- **Campaigns are never cached.** Their value is the live remaining budget, which moves within
  minutes, so that mode always fetches - and it only costs one request anyway.
- Results stream into the dataset as they are found, so you can start reading a long crawl while it
  is still running.

### Data notes

- Campaigns come from the public Content Rewards discover feed - the whole feed arrives in a single
  request, so this mode is cheap to run on a schedule.
- `viewCount` and `creators` are `null` when Content Rewards does not publish them for a campaign.
  They are never reported as `0` just to fill the column.
- Products discovered automatically come from Whop's new-arrivals feed, so they are brand new and
  usually have no ratings yet. To scrape established products, paste their URLs into
  **Specific Whop URLs**.
- `billingPeriodDays` is `null` for one-off purchases; it only has a value on recurring plans.

### Notes

- No login or cookies required; nothing behind a paywall is touched.
- Only pages the sites allow crawling are used - their internal `/api/` routes are excluded, as
  their robots.txt asks.
- **No personal data.** Records carry business identity only (company name, route, logo, member
  and review counts). Owner names, bios, avatars and social handles are deliberately not collected.
- Category browse pages publish 24 companies each, so Sellers mode gets breadth from crawling many
  categories rather than deep pagination.

# Actor input Schema

## `mode` (type: `string`):

Campaigns = Content Rewards clipping campaigns with reward per 1,000 views and remaining budget. Products = Whop listings with prices and ratings. Sellers = company/community intelligence with member counts and review scores.

## `search` (type: `string`):

Filter results by keyword. In Sellers mode this also picks which category pages to crawl (for example "forex-trading"). Leave empty to take everything.

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

Optional. Paste Whop product, company or category-browse URLs to scrape exactly those instead of searching. Example: https://whop.com/discover/browse/coaching-and-courses/

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

Maximum records to return. Keep this low for a cheap trial run.

## `trackChanges` (type: `boolean`):

For scheduled runs. Tags every record as new, active, price/reward change, budget drop, or ended, and adds first-seen and last-seen dates. The first run is the baseline.

## `country` (type: `string`):

Country for the proxy exit node.

## `cacheMaxAgeHours` (type: `integer`):

Sellers mode only. Re-use previously scraped category pages if they are newer than this, which makes repeat runs far faster. Set to 0 to always fetch fresh. Campaign data is never cached.

## `maxRetries` (type: `integer`):

How many times to retry a page on a network error or rate-limit, rotating to a fresh IP each time.

## `proxyConfiguration` (type: `object`):

Residential is the default and is recommended for long category crawls.

## `debug` (type: `boolean`):

Log every request status. Use only when troubleshooting.

## Actor input object example

```json
{
  "mode": "campaigns",
  "search": "",
  "startUrls": [],
  "maxItems": 100,
  "trackChanges": false,
  "country": "US",
  "cacheMaxAgeHours": 24,
  "maxRetries": 6,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  },
  "debug": false
}
```

# Actor output Schema

## `campaigns` (type: `string`):

No description

## `products` (type: `string`):

No description

## `sellers` (type: `string`):

No description

## `full` (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 = {
    "mode": "campaigns",
    "search": ""
};

// Run the Actor and wait for it to finish
const run = await client.actor("webdatalabs/whop-marketplace-intelligence").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 = {
    "mode": "campaigns",
    "search": "",
}

# Run the Actor and wait for it to finish
run = client.actor("webdatalabs/whop-marketplace-intelligence").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 '{
  "mode": "campaigns",
  "search": ""
}' |
apify call webdatalabs/whop-marketplace-intelligence --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Whop Scraper - Products, Sellers & Content Rewards Campaigns",
        "description": "Scrape whop.com marketplace products with prices and categories, seller/company intelligence, and Content Rewards clipping campaigns with reward-per-1k-views and remaining budget. No login. Opt-in change tracking across scheduled runs.",
        "version": "1.0",
        "x-build-id": "b8qe3oucpsiPtf2tf"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/webdatalabs~whop-marketplace-intelligence/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-webdatalabs-whop-marketplace-intelligence",
                "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/webdatalabs~whop-marketplace-intelligence/runs": {
            "post": {
                "operationId": "runs-sync-webdatalabs-whop-marketplace-intelligence",
                "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/webdatalabs~whop-marketplace-intelligence/run-sync": {
            "post": {
                "operationId": "run-sync-webdatalabs-whop-marketplace-intelligence",
                "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",
                "required": [
                    "mode"
                ],
                "properties": {
                    "mode": {
                        "title": "What to scrape",
                        "enum": [
                            "campaigns",
                            "products",
                            "sellers"
                        ],
                        "type": "string",
                        "description": "Campaigns = Content Rewards clipping campaigns with reward per 1,000 views and remaining budget. Products = Whop listings with prices and ratings. Sellers = company/community intelligence with member counts and review scores.",
                        "default": "campaigns"
                    },
                    "search": {
                        "title": "Search or category",
                        "type": "string",
                        "description": "Filter results by keyword. In Sellers mode this also picks which category pages to crawl (for example \"forex-trading\"). Leave empty to take everything.",
                        "default": ""
                    },
                    "startUrls": {
                        "title": "Specific Whop URLs",
                        "type": "array",
                        "description": "Optional. Paste Whop product, company or category-browse URLs to scrape exactly those instead of searching. Example: https://whop.com/discover/browse/coaching-and-courses/",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxItems": {
                        "title": "Max results",
                        "minimum": 1,
                        "maximum": 50000,
                        "type": "integer",
                        "description": "Maximum records to return. Keep this low for a cheap trial run.",
                        "default": 100
                    },
                    "trackChanges": {
                        "title": "Track changes between runs",
                        "type": "boolean",
                        "description": "For scheduled runs. Tags every record as new, active, price/reward change, budget drop, or ended, and adds first-seen and last-seen dates. The first run is the baseline.",
                        "default": false
                    },
                    "country": {
                        "title": "Proxy country",
                        "enum": [
                            "US",
                            "GB",
                            "DE",
                            "CA",
                            "AU"
                        ],
                        "type": "string",
                        "description": "Country for the proxy exit node.",
                        "default": "US"
                    },
                    "cacheMaxAgeHours": {
                        "title": "Reuse category data younger than",
                        "minimum": 0,
                        "maximum": 168,
                        "type": "integer",
                        "description": "Sellers mode only. Re-use previously scraped category pages if they are newer than this, which makes repeat runs far faster. Set to 0 to always fetch fresh. Campaign data is never cached.",
                        "default": 24
                    },
                    "maxRetries": {
                        "title": "Max retries per page",
                        "minimum": 1,
                        "maximum": 10,
                        "type": "integer",
                        "description": "How many times to retry a page on a network error or rate-limit, rotating to a fresh IP each time.",
                        "default": 6
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Residential is the default and is recommended for long category crawls.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ]
                        }
                    },
                    "debug": {
                        "title": "Debug logging",
                        "type": "boolean",
                        "description": "Log every request status. Use only when troubleshooting.",
                        "default": false
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
