# Whop Scraper Pro (`deepmine/whop-scraper-pro`) Actor

Scrape Whop Discover search results and product pages by keyword. Extract titles, prices, ratings, product URLs, and category rank for competitor analysis, offer research, lead generation, and marketplace intelligence.

- **URL**: https://apify.com/deepmine/whop-scraper-pro.md
- **Developed by:** [DeepMine](https://apify.com/deepmine) (community)
- **Categories:** E-commerce, Lead generation, Automation
- **Stats:** 14 total users, 0 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $5.00 / 1,000 results

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/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

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

## How to integrate an Actor?

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

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

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

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

# README

## Whop Scraper Pro | Whop Discover Search Scraper for Product Research, Competitor Tracking, and Marketplace Intelligence

Whop Scraper Pro is an Apify actor that scrapes **Whop Discover search results** and returns structured data for each product card and product page.

Use it to monitor Whop listings, track competitors, analyze pricing, discover offers in a niche, and build repeatable market research workflows.

### Why use this Whop scraper?

If you are searching for a reliable **Whop scraper**, **Whop product scraper**, or **Whop Discover scraper**, this actor is designed for exactly that workflow:

- Scrape Whop search results by keyword
- Expand across Whop categories (agency, software, newsletters, events, and more)
- Collect product links and metadata in clean JSON
- Optionally fetch each product page for richer fields
- Export to API, Make, Zapier, Google Sheets, or your own pipeline

### Best use cases

- Whop competitor analysis
- Whop offer and pricing research
- Digital product market mapping
- Whop niche discovery (e.g. AI tools, trading, OnlyFans, creators, communities)
- Lead generation and list building
- Product intelligence dashboards

### What data you get

Each output item can include:

- `query`
- `category`
- `rank`
- `cardType`
- `title`
- `subtitle`
- `description`
- `price`
- `ratingValue`
- `ratingCount`
- `companyRoute`
- `productRoute`
- `productUrl`
- `canonicalUrl`
- `mediaCardUrl`
- `searchUrl`
- `funnelId`
- `fetchedUrl`
- `imageUrl`
- `iconUrl`
- `scrapedAt`

This makes it easy to build reports like:

- Top-ranked Whop products by keyword
- Category-level Whop offer snapshots
- Price/rating comparison tables
- Competitor watchlists over time

### Input options

- `queries` (array): keywords to search on Whop Discover
- `query` (string): single-query alias
- `maxResultsPerQuery`: cap per query after dedupe
- `includeCategoryPages`: scrape category tabs in addition to “all”
- `categorySlugs`: optional custom category list
- `includeProductPages`: fetch product pages for richer fields
- `maxConcurrency`: request parallelism
- `proxyConfiguration`: Apify proxy settings

### How it works (high level)

1. Runs your Whop search query in Discover
2. Extracts media card links and preview metadata
3. Deduplicates product URLs across selected categories
4. Optionally opens product pages for extended fields
5. Saves structured records to dataset

### Example workflow

#### Example query ideas

- `onlyfans`
- `ai tools`
- `discord`
- `trading`
- `seo`
- `automation`

#### Example output usage

- Push JSON to your internal DB
- Schedule daily snapshots for trend tracking
- Compare rank/price changes between runs
- Feed BI dashboards and competitor alerts

### API access

After a run, read dataset items from:

- `{{links.apiDefaultDatasetUrl}}/items`

You can also trigger runs via Apify API and integrate into Make/Zapier/n8n.

### Guardian telemetry to Grafana Cloud (optional)

This actor includes Wire Guardian telemetry that can export advanced run diagnostics to Grafana Cloud.

Set these env vars in Actor settings:

- `GUARDIAN_TELEMETRY_ENABLED=true`
- `OTEL_EXPORTER_OTLP_ENDPOINT=https://otlp-gateway-<stack-region>.grafana.net/otlp`
- `OTEL_EXPORTER_OTLP_HEADERS=Authorization=Basic <base64(instanceId:apiKey)>`
- `GUARDIAN_SERVICE_NAME=whop-scraper-pro`
- `GUARDIAN_ENV=prod`

Optional Loki streaming:

- `GUARDIAN_LOKI_URL=https://logs-prod-<region>.grafana.net`
- `GUARDIAN_LOKI_API_KEY=<grafana_api_key>`

Emitted metrics include:

- `guardian_platform_cost_usd`
- `guardian_total_run_cost_usd`
- `guardian_creator_revenue_usd`
- `guardian_creator_profit_usd`
- `guardian_settlement_actions_total`
- `guardian_records_emitted_total`
- `guardian_request_failures_total`

Run-level labels are included on all metrics:

- `guardian_run_id`
- `guardian_service`, `guardian_namespace`, `guardian_environment`

Example per-run revenue bar query:

```promql
sum by (guardian_run_id) (sum_over_time(guardian_creator_revenue_usd_sum{guardian_service="guardian",guardian_namespace="apify-guardian-workspace",guardian_environment="production"}[24h]))
```

### SEO keyword coverage

This actor is optimized for users searching terms like:

- Whop scraper
- Whop Discover scraper
- Whop search scraper
- Whop product scraper
- scrape Whop products
- Whop competitor analysis tool
- Whop marketplace intelligence
- Whop pricing scraper
- Whop listing monitor
- Apify Whop scraper

### Performance and reliability notes

- Supports proxy rotation through Apify Proxy
- Built for structured, repeatable data collection
- Handles dedupe across categories for cleaner datasets
- Designed for integration in scheduled automation pipelines

### FAQ

#### Does this scrape Whop search by keyword?

Yes. It supports one or multiple search queries.

#### Can I scrape only specific Whop categories?

Yes. Use `includeCategoryPages` with `categorySlugs`.

#### Can I get richer product detail fields?

Yes. Keep `includeProductPages=true`.

#### Is this useful for Whop competitor research?

Yes. It is built for exactly that use case.

### Getting started locally

```bash
npm install
git submodule update --init --recursive
apify run
```

### Shared Wire Guardian source (submodule)

This actor uses the shared guard from:

- `vendor/apify-ppe-guard`

Update shared guard code into this actor:

```bash
yarn guard:update
```

Check pinned guard commit:

```bash
yarn guard:status
```

### Deploy

```bash
apify push
```

### Legal and ethical use

Use responsibly and comply with Whop terms, applicable law, and data privacy requirements in your jurisdiction.

# Actor input Schema

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

One or more Whop Discover keywords to scrape. Example values: "onlyfans", "trading", "discord". Each query is processed independently.

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

Optional single-query shortcut. If set, this value is merged with Search Queries and de-duplicated.

## `maxResultsPerQuery` (type: `integer`):

Maximum number of unique Whop listings to emit for each query after de-duplication. Lower values complete faster and cost less.

## `includeCategoryPages` (type: `boolean`):

When enabled, crawl extra category tabs (agency, software, events, etc.) in addition to All. This increases coverage but also runtime.

## `categorySlugs` (type: `array`):

Optional custom category slugs used only when Expand Across Categories is enabled. Leave empty to use built-in category defaults.

## `includeProductPages` (type: `boolean`):

When enabled, each selected media card URL is opened to enrich data (description, canonical URL, images, rating extraction). This is slower but richer.

## `maxConcurrency` (type: `integer`):

Maximum parallel HTTP requests. Higher values can be faster but may increase throttling/timeouts.

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

Proxy settings used for Whop requests. Apify Proxy is recommended for stable cloud reliability.

## Actor input object example

```json
{
  "queries": [
    "onlyfans"
  ],
  "maxResultsPerQuery": 20,
  "includeCategoryPages": false,
  "categorySlugs": [
    "paid_group",
    "agency",
    "coaching_and_courses",
    "physical_products",
    "software",
    "newsletter",
    "events"
  ],
  "includeProductPages": false,
  "maxConcurrency": 6
}
```

# 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": [
        "onlyfans"
    ],
    "categorySlugs": [
        "paid_group",
        "agency",
        "coaching_and_courses",
        "physical_products",
        "software",
        "newsletter",
        "events"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("deepmine/whop-scraper-pro").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": ["onlyfans"],
    "categorySlugs": [
        "paid_group",
        "agency",
        "coaching_and_courses",
        "physical_products",
        "software",
        "newsletter",
        "events",
    ],
}

# Run the Actor and wait for it to finish
run = client.actor("deepmine/whop-scraper-pro").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).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": [
    "onlyfans"
  ],
  "categorySlugs": [
    "paid_group",
    "agency",
    "coaching_and_courses",
    "physical_products",
    "software",
    "newsletter",
    "events"
  ]
}' |
apify call deepmine/whop-scraper-pro --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,deepmine/whop-scraper-pro"
        }
    }
}

```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/QopWX1XVoc9Qk5G38/builds/5EKdUdG8q0yup60KX/openapi.json