# Whop Content Rewards Scraper (`crawloop/whop-content-rewards-scraper`) Actor

Scrape public Whop Content Rewards clipping and UGC campaigns. Export CPM, budget left, platforms, 30-day views, top clips, and posting rules as JSON.

- **URL**: https://apify.com/crawloop/whop-content-rewards-scraper.md
- **Developed by:** [Andrej Kiva](https://apify.com/crawloop) (community)
- **Categories:** Social media, Videos, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.05 / 1,000 campaigns

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

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## 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.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Whop Content Rewards Scraper

> **Disclaimer:** Unofficial tool — not affiliated with, sponsored by, or endorsed by Whop Inc. or its affiliates. Data is read from the public Content Rewards campaign directory only. No login. You are responsible for complying with applicable law (including GDPR where a public creator username appears) and the site’s terms. No warranty on accuracy or availability. Provided for informational and research use.

Scrape public Whop Content Rewards campaigns — clipping, UGC, sound, logo, and slideshow briefs — into one dataset. Each row has the rate per 1,000 views, budget left, daily burn, platforms, a 30-day view series, top clips, top earners, and the posting rules (face on camera, link in bio, pre-approval).

Clippers use it to skip campaigns that look funded but do not pay. Brands use it to benchmark CPM and budget. It is an HTTP Content Rewards API alternative: Python, Node.js, cURL, or an MCP client. Export JSON or CSV from the dataset.

### When to use

Use this Actor when you need the live public directory: rates, remaining budget, who already got paid, and the rules before you join.

Skip it for private campaigns, member emails, or anything behind a Whop login. Those are not on the public directory.

### Key features

- Search, category, platform, payout model (CPM or per post), and campaign type, including slideshows, logo, sound, reposting, and YouTube long-form
- Budget left, spend, paid-out total, daily burn, estimated days left, and payout per creator
- Opportunity score from rate, budget headroom, creator count, and runway
- 30-day view series, views in the last 7 and 30 days, and effective rate (what 1,000 views actually paid)
- Top clips (platform, views, post link) and top earners (username and amount paid)
- Posting rules on each saved row: guidelines, face on camera, link in bio, pre-approval, no reposts
- Per-platform min and max payout, not only the headline rate
- Monitor mode for campaigns that were not on the directory last time, plus a trend signal between runs
- Sort by featured, newest, budget, trending, paid out, CPM, budget left, opportunity, or fewest creators

### Input

| Field | Default | What it does |
| :--- | :--- | :--- |
| Search text | empty | Name, brand, or description |
| Campaign URLs | empty | Fetch these campaigns only |
| Campaign types | all | `clipping`, `ugc`, `sound`, `logo`, `slideshows`, `reposting`, `youtube-long-form` |
| Categories | all | Category id, such as `gaming` or `music` |
| Platforms | all | `tiktok`, `instagram`, `youtube`, `x`, `facebook` |
| Payout models | both | `cpm` or `perPost` |
| Min reward per 1,000 views | none | USD |
| Min budget left | none | USD still unspent |
| Max budget spent | none | Percent already spent |
| Max creators | none | Competition cap |
| Min payout per creator | none | Spend divided by creators |
| Min days of budget left | none | From spend since listing |
| Min opportunity score | none | 0–100 |
| Listed after / max age | none | Drop older campaigns |
| Only new campaigns | off | Later runs keep campaigns that were not on the baseline |
| Track trends | off | Budget, creator, and view change versus the previous run |
| Include posting rules | on | Guidelines and requirement flags. Still one charge per saved campaign |
| Max campaigns | 100 | You are charged only for saved rows |
| Proxy | off | Leave off unless a run returns zero campaigns |

```json
{
  "campaignTypes": ["clipping"],
  "platforms": ["tiktok", "instagram"],
  "minRewardPerThousand": 1,
  "minBudgetLeftUsd": 500,
  "sortBy": "budgetLeft",
  "maxItems": 50,
  "includeDetails": true
}
```

One campaign by URL:

```json
{
  "startUrls": [
    { "url": "https://contentrewards.com/discover/bdebe4a4-be6c-4110-81a5-b598a3e1badc" }
  ],
  "maxItems": 1
}
```

### Output

One campaign per dataset row. Nested clips and earners are part of that row, not extra charges.

| Field | Meaning |
| :--- | :--- |
| `name`, `brand`, `campaignUrl` | Title, organization, public page |
| `rewardPerThousandUsd` | Headline USD per 1,000 views |
| `effectiveRewardPerThousandUsd` | Paid out ÷ views × 1,000 |
| `platformPayouts` | Rate plus min and max payout on each platform |
| `budgetLeftUsd`, `progressPercentage`, `dailyBurnUsd`, `estimatedDaysLeft` | What is left and how fast it is moving |
| `payoutPerCreatorUsd`, `creatorCount`, `paidOutUsd` | Whether creators have actually been paid |
| `viewsByDay`, `viewsLast7Days`, `topClips`, `topEarners` | View history and who is earning |
| `guidelines`, `faceOnCamera`, `linkInBio`, `preApproval` | Posting rules |
| `opportunityScore` | 0–100 |
| `isNew`, `trendSignal` | Set when monitor or trends are on |

```json
{
  "name": "Example clipping campaign",
  "brand": "Example brand",
  "rewardPerThousandUsd": 1.5,
  "budgetLeftUsd": 4200,
  "progressPercentage": 16,
  "platforms": ["tiktok", "instagram"],
  "opportunityScore": 72,
  "requiresApplication": false,
  "faceOnCamera": false,
  "preApproval": false,
  "viewsLast7Days": 180000,
  "campaignUrl": "https://contentrewards.com/discover/00000000-0000-4000-8000-000000000001"
}
```

### Use cases

- Pick clipping campaigns that still have budget and a rate worth the edit
- Drop briefs that require an application, a face on camera, or a link in bio
- Watch for new listings on a schedule and send the dataset to Sheets or a webhook
- Compare CPM across gaming, music, and personal-brand categories
- Check top clips and top earners before joining a board that has not paid anyone

### Integration examples

Replace `YOUR_TOKEN` and the Actor id after you open the Actor in Apify Console. These calls start a run and do not set a price.

#### Node.js

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

const client = new ApifyClient({ token: "YOUR_TOKEN" });
const run = await client.actor("crawloop/whop-content-rewards-scraper").call({
  campaignTypes: ["clipping"],
  minBudgetLeftUsd: 500,
  sortBy: "newest",
  maxItems: 50,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_TOKEN")
run = client.actor("crawloop/whop-content-rewards-scraper").call(run_input={
    "campaignTypes": ["clipping"],
    "minBudgetLeftUsd": 500,
    "sortBy": "newest",
    "maxItems": 50,
})
items = client.dataset(run["defaultDatasetId"]).list_items().items
print(items)
```

#### cURL

```bash
curl -X POST "https://api.apify.com/v2/acts/crawloop~whop-content-rewards-scraper/runs?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"campaignTypes":["clipping"],"minBudgetLeftUsd":500,"sortBy":"newest","maxItems":50}'
```

### MCP and AI assistants

Use this Actor from AI tools via [Apify MCP](https://docs.apify.com/platform/integrations/mcp).
Connect your Apify account, then call this Actor by its Store name.

Example prompts:

- "Run Whop Content Rewards Scraper for clipping campaigns with at least $500 budget left and return the top 20 by opportunity score as JSON"
- "Find Content Rewards campaigns that pay on TikTok, do not require a face on camera, and still have budget"
- "List new Whop clipping campaigns since yesterday and include the rate, budget left, and guidelines"

### FAQ

**Does this need a Whop login or API key?**\
No. It reads the public campaign directory.

**What is one charged result?**\
One saved campaign. Top clips, earners, and the daily view series sit on that same row.

**Why did a monitor run save campaigns I have already seen?**\
The first run is the baseline. It saves up to Max campaigns and marks the rest of the directory as seen, so the next run only returns campaigns that were not on the board. Turn on Reset monitor memory to start over.

**Can I get ended campaigns?**\
The public directory lists campaigns that are still shown. Campaigns removed from that directory are not returned.

# Actor input Schema

## `searchText` (type: `string`):

Match campaign name, brand, and description. Example: valorant.

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

Public Content Rewards campaign URLs. When set, only these campaigns are fetched.

## `campaignTypes` (type: `array`):

clipping, ugc, slideshows, logo, sound, reposting, or youtube-long-form. Leave empty for every type.

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

Category ids such as gaming, music, personal-brand, finance. Leave empty for every category.

## `platforms` (type: `array`):

Keep campaigns that pay on at least one of these: tiktok, instagram, youtube, x, facebook.

## `payoutTypes` (type: `array`):

cpm (per 1,000 views) or perPost. Leave empty for both.

## `status` (type: `string`):

active keeps campaigns that are still paying. all keeps every listed campaign.

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

featured, newest, budget, trending, paidOut, cpm, budgetLeft, opportunity, payoutPerCreator, burn, daysLeft, fewestCreators, or progress.

## `minRewardPerThousand` (type: `number`):

Drop campaigns paying less than this per 1,000 views.

## `minBudgetLeftUsd` (type: `number`):

Drop campaigns with less than this much unspent budget.

## `maxProgressPercentage` (type: `number`):

Drop campaigns that have already spent more than this percent of the budget.

## `maxCreators` (type: `integer`):

Drop campaigns with more creators than this.

## `minPayoutPerCreatorUsd` (type: `number`):

Budget already spent divided by creator count. Campaigns with no creators are dropped.

## `minEstimatedDaysLeft` (type: `number`):

Estimated from spend since the campaign was listed. Campaigns with no spend yet are dropped.

## `minOpportunityScore` (type: `integer`):

Score from reward rate, budget left, creator count, and estimated runway.

## `maxAgeDays` (type: `number`):

Drop campaigns listed more than this many days ago.

## `listedAfter` (type: `string`):

ISO date, for example 2026-09-01. Drops campaigns listed before this.

## `onlyNew` (type: `boolean`):

First run saves up to Max campaigns and marks the rest of the directory as already seen. Later runs save only campaigns that were not on that baseline.

## `trackTrends` (type: `boolean`):

Compare budget, creators, and views with the previous run and add a trend signal.

## `includeDetails` (type: `boolean`):

Fetch each saved campaign's rules: guidelines, face-on-camera, link in bio, pre-approval, and content type. Extra requests, still one charge per saved campaign.

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

Maximum campaigns to save. You are charged only for saved rows. The public directory is a few hundred campaigns.

## `resetMonitorState` (type: `boolean`):

Forget campaigns remembered by Only new campaigns and Track trends.

## `monitorStoreName` (type: `string`):

Named key-value store for seen campaigns and trend snapshots.

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

Leave proxy off. The public directory answers without one. Turn on Apify Proxy only if a run starts returning zero campaigns.

## Actor input object example

```json
{
  "status": "active",
  "sortBy": "featured",
  "onlyNew": false,
  "trackTrends": false,
  "includeDetails": true,
  "maxItems": 100,
  "resetMonitorState": false,
  "monitorStoreName": "whop-content-rewards-seen",
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

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

Default dataset items.

# 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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("crawloop/whop-content-rewards-scraper").call(input);

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

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

```

## Python example

```python
from apify_client import ApifyClient

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

# Prepare the Actor input
run_input = {}

# Run the Actor and wait for it to finish
run = client.actor("crawloop/whop-content-rewards-scraper").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 '{}' |
apify call crawloop/whop-content-rewards-scraper --silent --output-dataset

```

## MCP server setup

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

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/cyMhgVPOS0DwnkAuP/builds/wmekexAP8nejKb2Va/openapi.json