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

💵 Find public Whop clipping and UGC campaigns with payout rates, budget left, platforms, requirements, and direct opportunity links.

- **URL**: https://apify.com/automation-lab/whop-content-rewards-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Marketing
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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 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 Content Rewards Scraper

Find public **Whop Content Rewards clipping and UGC campaigns** before their budgets run out.

This Apify Actor turns `contentrewards.com/discover` into a clean dataset of campaign payouts, remaining budgets, accepted platforms, requirements, brands, and direct opportunity links.

Use it to discover creator work, compare campaign economics, or monitor budget burn without manually opening hundreds of campaign cards.

- 💵 Compare reward rates per 1,000 views.
- 📊 Rank campaigns by budget left or newest funding date.
- 🎬 Separate clipping, UGC, and mixed campaigns.
- 📱 Filter TikTok, Instagram, YouTube, and X opportunities.
- 🧾 Enrich selected campaigns with requirements and payout rules.
- 🔌 Export to JSON, CSV, Excel, Google Sheets, APIs, webhooks, or MCP.

### What does Whop Content Rewards Scraper do?

The Actor reads the public Content Rewards discovery directory and creates one structured record per paid campaign.

It extracts the public campaign identity, brand, status, category, payout rate, total budget, spent budget, calculated remaining budget, funding time, supported platforms, and media.

Optional detail enrichment opens each selected public campaign page and adds mandatory requirements, per-platform payout constraints, creator counts, and resource links.

You can scan the directory or supply exact URLs such as:

```text
https://contentrewards.com/discover/dd9f7918-e51d-4935-9f23-5935c783774a
````

### Who is this Whop campaign scraper for?

#### Clippers and clipping agencies

Build a daily shortlist of active campaigns with enough budget left to justify production.

#### UGC creators

Find TikTok, Instagram, or YouTube campaigns that match a minimum payout rate.

#### Creator managers

Compare brands, requirements, platform coverage, and reward ceilings before assigning work.

#### Brands and agencies

Benchmark public creator campaign rates, funding sizes, and budget progress across categories.

#### Creator-economy analysts

Track launches, campaign churn, budget burn, and category-level payout patterns over time.

#### Automation builders

Feed normalized campaign data into alerts, dashboards, lead scoring, or AI-agent workflows.

### Why use this Actor?

The public directory is large and changes frequently.

Manual review makes it difficult to compare payout and remaining budget consistently.

This Actor provides:

- ✅ numeric USD fields for sorting and calculations;
- ✅ original display strings for source fidelity;
- ✅ stable campaign IDs for deduplication and monitoring;
- ✅ strict campaign URL validation;
- ✅ useful filtering before the result limit;
- ✅ optional deep details without forcing hundreds of extra requests;
- ✅ a source failure signal instead of silent empty shell records.

### What Whop campaign data can I extract?

| Field | Description |
|---|---|
| `campaignId` | Stable public campaign or program ID |
| `title` | Campaign title |
| `brand` | Public brand or operator name |
| `status` | Active or completed status |
| `campaignType` | Clipping, UGC, or both |
| `category` | Content Rewards category |
| `description` | Public campaign summary |
| `rewardPer1k` | Source payout display string |
| `rewardPer1kUsd` | Normalized payout per 1,000 views |
| `totalBudgetUsd` | Normalized funded budget |
| `budgetSpentUsd` | Normalized spent amount |
| `budgetRemainingUsd` | Calculated budget left |
| `progressPercentage` | Public budget progress |
| `platforms` | TikTok, Instagram, YouTube, or X |
| `fundedAt` | Public funding timestamp |
| `requirements` | Enriched mandatory requirement text |
| `payoutDetails` | Enriched platform payout constraints |
| `resourceUrls` | Enriched public brief or asset links |
| `campaignUrl` | Direct public campaign page |
| `thumbnailUrl` | Campaign image |
| `scrapedAt` | Extraction timestamp |

### How to scrape Whop Content Rewards campaigns

1. Open **Whop Content Rewards Scraper** on Apify.
2. Leave campaign URLs empty to scan the public discovery directory.
3. Set the maximum number of campaigns.
4. Choose status, campaign type, platforms, or budget thresholds.
5. Select how matching campaigns should be sorted.
6. Enable detail enrichment only when requirements are needed.
7. Click **Start**.
8. Open the Dataset tab and export the records.

A quick first run can use the prefilled values and should finish in well under two minutes.

### Input parameters

| Input | Type | Default | Purpose |
|---|---|---:|---|
| `startUrls` | array | empty | Exact public campaign pages |
| `maxItems` | integer | `20` | Maximum saved campaigns |
| `searchQuery` | string | empty | Search title, brand, and description |
| `categories` | array | empty | Match any selected category |
| `campaignType` | string | `all` | All, clipping, UGC, or both |
| `platforms` | array | empty | Match any selected platform |
| `status` | string | `active` | Active, completed, or all |
| `minRewardPer1kUsd` | number | empty | Minimum payout per 1K views |
| `minBudgetRemainingUsd` | number | empty | Minimum budget left |
| `sortBy` | string | `newest` | Newest, reward, or budget left |
| `enrichDetails` | boolean | `false` | Add requirements and payout rules |
| `maxConcurrency` | integer | `5` | Parallel detail requests, 1–10 |

### Example input: newest clipping campaigns

```json
{
  "maxItems": 25,
  "campaignType": "clipping",
  "status": "active",
  "sortBy": "newest",
  "enrichDetails": false,
  "maxConcurrency": 5
}
```

### Example input: high-paying TikTok UGC

```json
{
  "maxItems": 50,
  "campaignType": "ugc",
  "platforms": ["tiktok"],
  "status": "active",
  "minRewardPer1kUsd": 1.5,
  "sortBy": "reward"
}
```

### Example input: campaigns with budget left

```json
{
  "maxItems": 100,
  "status": "active",
  "minBudgetRemainingUsd": 5000,
  "sortBy": "budget-left",
  "enrichDetails": true,
  "maxConcurrency": 5
}
```

### Example output

```json
{
  "campaignId": "dd9f7918-e51d-4935-9f23-5935c783774a",
  "title": "ROOBET UGC REPOSTING V2",
  "brand": "Creator Casino",
  "status": "active",
  "campaignType": "clipping",
  "category": "Entertainment",
  "rewardPer1k": "$1.00",
  "rewardPer1kUsd": 1,
  "totalBudgetUsd": 250000,
  "budgetSpentUsd": 136651.72,
  "budgetRemainingUsd": 113348.28,
  "platforms": ["tiktok", "instagram"],
  "fundedAt": "2026-06-10T21:05:05.000Z",
  "verified": false,
  "campaignUrl": "https://contentrewards.com/discover/dd9f7918-e51d-4935-9f23-5935c783774a"
}
```

Values are live public source data and will change as campaigns spend their budgets.

### How much does it cost to scrape Whop Content Rewards?

The Actor uses pay-per-event pricing:

- a small one-time Actor start charge;
- one `Campaign` event for each dataset record.

The current price is **$0.005 per run** plus a tiered charge for each saved campaign.

| Apify tier | Price per campaign | 100 campaigns including start |
|---|---:|---:|
| Free | $0.000032396 | about $0.00824 |
| Bronze | $0.00002817 | about $0.00782 |
| Silver | $0.000021973 | about $0.00720 |
| Gold | $0.000016902 | about $0.00669 |
| Platinum | $0.000011268 | about $0.00613 |
| Diamond | $0.00001 | about $0.00600 |

Your exact platform price is displayed before each run.

A 100-campaign extraction costs only a small fraction of the value of finding one viable paid campaign.

Detail enrichment does not create duplicate output charges; it adds public detail fields to the selected campaign records.

### Filtering and sorting tips

- 🎯 Combine `status: active` with a remaining-budget floor for actionable opportunities.
- 💰 Sort by reward to compare the highest public payout rates first.
- 🆕 Sort by newest to discover recently funded campaigns.
- 📱 Select one platform when your creator accounts are platform-specific.
- 🧾 Enable enrichment after filtering so only useful campaigns need detail requests.
- 🔍 Use a brand, game, creator, or niche term in `searchQuery`.
- 📦 Increase `maxItems` only after validating your filters with a small run.

### Monitoring new campaigns and budget burn

Schedule the Actor hourly or daily in Apify.

Use `campaignId` as the stable key in your database.

Compare `budgetSpentUsd`, `budgetRemainingUsd`, and `progressPercentage` between runs.

A simple monitor can alert when:

- a new campaign ID appears;
- a campaign crosses your payout threshold;
- a campaign gains or loses platform coverage;
- remaining budget drops below a working threshold;
- a campaign changes from active to completed.

### Integrations

#### Google Sheets campaign board

Connect the dataset to Google Sheets and sort opportunities by reward or budget left.

#### Slack or Discord alerts

Use an Apify webhook after successful runs, then post newly seen campaign IDs to your team channel.

#### Airtable creator operations

Upsert records by `campaignId`, assign owners, and track whether your team has reviewed each brief.

#### Data warehouse intelligence

Export daily snapshots to BigQuery, Snowflake, or PostgreSQL for payout and budget trend analysis.

#### Make and Zapier

Trigger workflows when high-value campaign rows satisfy your downstream filters.

### JavaScript API example

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/whop-content-rewards-scraper').call({
  maxItems: 50,
  status: 'active',
  sortBy: 'budget-left'
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

### Python API example

```python
import os
from apify_client import ApifyClient

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/whop-content-rewards-scraper').call(run_input={
    'maxItems': 50,
    'campaignType': 'ugc',
    'status': 'active',
})
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

### cURL API example

```bash
curl -X POST \
  'https://api.apify.com/v2/acts/automation-lab~whop-content-rewards-scraper/runs?token=YOUR_APIFY_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"maxItems":25,"campaignType":"clipping","status":"active"}'
```

Never commit your Apify token to source control.

### Use Whop Content Rewards Scraper with MCP

Apify MCP lets Claude and other compatible AI clients run this Actor as a tool.

#### Claude Code

```bash
claude mcp add --transport http apify "https://mcp.apify.com?tools=automation-lab/whop-content-rewards-scraper"
```

#### Claude Desktop, Cursor, or VS Code

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=automation-lab/whop-content-rewards-scraper"
    }
  }
}
```

Example prompts:

- “Find active TikTok clipping campaigns with at least $5,000 budget left.”
- “Compare the highest-paying public UGC campaigns on Whop.”
- “Extract requirements for the 10 newest Content Rewards campaigns.”
- “Create a table of campaign brand, payout, platforms, and budget remaining.”

### Data quality and technical design

The Actor uses the public server-rendered Next.js data sent to normal visitors.

It does not require a Whop account, login cookie, or private API key.

Campaigns repeated in featured page collections are deduplicated by public ID.

Numeric filters exclude unparseable source values instead of treating them as zero.

A changed or incomplete source payload fails the run loudly, preventing a misleading successful extraction of empty shell records.

### Troubleshooting

#### Why did my valid run return zero campaigns?

Your filter combination may be too narrow.

Remove the minimum payout or budget threshold, use `status: all`, or increase `maxItems` after confirming matching campaigns exist publicly.

#### Why are requirements empty?

Requirements come from campaign detail pages.

Set `enrichDetails` to `true` or provide exact campaign URLs.

Some campaign owners may not publish requirements.

#### Why was a start URL rejected?

For safety and product consistency, direct URLs must use HTTPS and match `contentrewards.com/discover/{campaign-id}`.

Whop marketplace, checkout, account, and unrelated URLs are outside this Actor's scope.

#### Why did a source request fail?

The Actor retries temporary 429 and server errors.

If the public site changes its data serialization, review the run log and retry later rather than accepting partial records.

### Is it legal to scrape Whop Content Rewards?

The Actor extracts information available on public discovery pages without logging in.

Web scraping laws and contractual rules vary by country and use case.

You are responsible for using the data lawfully, respecting applicable terms, privacy rights, intellectual property, and reasonable request volumes.

Do not use extracted campaign or creator information for spam, harassment, impersonation, or unauthorized submissions.

### FAQ

#### Does it submit content to campaigns?

No. It only extracts public campaign discovery information.

#### Does it require a Whop login?

No. The supported pages are public.

#### Can it scrape one campaign?

Yes. Add its public Content Rewards discovery URL to `startUrls`.

#### Can it return completed campaigns?

Yes. Set `status` to `completed` or `all` when those records remain on the public source.

#### Is reward per 1K a number?

Both forms are returned: the source display string and normalized `rewardPer1kUsd` number.

#### How is remaining budget calculated?

`budgetRemainingUsd` equals total public budget minus public spent budget, with a floor of zero.

#### Does enrichment cost more output events?

No duplicate rows are emitted. Each saved campaign is charged once.

### Related creator economy scrapers

- [Whop Marketplace Scraper](https://apify.com/automation-lab/whop-marketplace-scraper) — extract Whop marketplace products, communities, creators, prices, ratings, and reviews.
- [TikTok Scraper](https://apify.com/automation-lab/tiktok-scraper) — collect public TikTok content and creator data for campaign research.
- [Instagram Scraper](https://apify.com/automation-lab/instagram-scraper) — analyze public Instagram profiles and posts.
- [YouTube Scraper](https://apify.com/automation-lab/youtube-scraper) — extract public YouTube channel and video data.

Choose this Actor when the entity you need is a **Content Rewards campaign** rather than a Whop marketplace offer or social media post.

### Support

If a run fails, open the run detail and include:

- the run URL;
- the exact input, with secrets removed;
- the campaign URL or filter that failed;
- the relevant log message;
- the expected campaign record.

That evidence makes source changes and edge cases much faster to diagnose.

# Actor input Schema

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

Optional public Content Rewards campaign URLs in the form https://contentrewards.com/discover/{campaign-id}. Leave empty to scan the discovery directory.

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

Maximum number of campaign records to save. Keep this low for a quick first run.

## `searchQuery` (type: `string`):

Keep only campaigns whose title, brand, or description contains this text.

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

Keep campaigns in any selected Content Rewards category.

## `campaignType` (type: `string`):

Keep all campaigns or only clipping, UGC, or mixed opportunities.

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

Keep campaigns that accept at least one selected social platform.

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

Choose active opportunities only, completed campaigns, or both.

## `minRewardPer1kUsd` (type: `number`):

Exclude campaigns with a lower or unparseable public payout rate.

## `minBudgetRemainingUsd` (type: `number`):

Exclude campaigns with less remaining budget or an unparseable budget.

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

Order matching campaigns by funding date, payout rate, or remaining budget before applying the limit.

## `enrichDetails` (type: `boolean`):

Open each selected campaign page to add requirements, platform payout details, creator counts, and resource links. This is slower than discovery-only extraction.

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

Maximum campaign detail pages fetched at once when enrichment or direct URLs are used.

## Actor input object example

```json
{
  "maxItems": 10,
  "campaignType": "all",
  "status": "active",
  "sortBy": "newest",
  "enrichDetails": false,
  "maxConcurrency": 5
}
```

# Actor output Schema

## `overview` (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 = {
    "maxItems": 10,
    "campaignType": "all",
    "status": "active",
    "sortBy": "newest",
    "enrichDetails": false,
    "maxConcurrency": 5
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/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 = {
    "maxItems": 10,
    "campaignType": "all",
    "status": "active",
    "sortBy": "newest",
    "enrichDetails": False,
    "maxConcurrency": 5,
}

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

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "maxItems": 10,
  "campaignType": "all",
  "status": "active",
  "sortBy": "newest",
  "enrichDetails": false,
  "maxConcurrency": 5
}' |
apify call automation-lab/whop-content-rewards-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Whop Content Rewards Scraper",
        "description": "💵 Find public Whop clipping and UGC campaigns with payout rates, budget left, platforms, requirements, and direct opportunity links.",
        "version": "0.1",
        "x-build-id": "kybTKaXzPAGo4NYr9"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~whop-content-rewards-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-whop-content-rewards-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/automation-lab~whop-content-rewards-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-whop-content-rewards-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/automation-lab~whop-content-rewards-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-whop-content-rewards-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "startUrls": {
                        "title": "Campaign URLs",
                        "type": "array",
                        "description": "Optional public Content Rewards campaign URLs in the form https://contentrewards.com/discover/{campaign-id}. Leave empty to scan the discovery directory.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxItems": {
                        "title": "Maximum campaigns",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Maximum number of campaign records to save. Keep this low for a quick first run.",
                        "default": 20
                    },
                    "searchQuery": {
                        "title": "Search title, brand, or description",
                        "type": "string",
                        "description": "Keep only campaigns whose title, brand, or description contains this text."
                    },
                    "categories": {
                        "title": "Categories",
                        "type": "array",
                        "description": "Keep campaigns in any selected Content Rewards category.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "Personal Brand",
                                "Music",
                                "Entertainment",
                                "Product",
                                "Technology",
                                "Logo",
                                "Slideshow",
                                "Gaming",
                                "Education",
                                "Other"
                            ],
                            "enumTitles": [
                                "Personal Brand",
                                "Music",
                                "Entertainment",
                                "Product",
                                "Technology",
                                "Logo",
                                "Slideshow",
                                "Gaming",
                                "Education",
                                "Other"
                            ]
                        }
                    },
                    "campaignType": {
                        "title": "Campaign type",
                        "enum": [
                            "all",
                            "clipping",
                            "ugc",
                            "both"
                        ],
                        "type": "string",
                        "description": "Keep all campaigns or only clipping, UGC, or mixed opportunities.",
                        "default": "all"
                    },
                    "platforms": {
                        "title": "Accepted platforms",
                        "type": "array",
                        "description": "Keep campaigns that accept at least one selected social platform.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "tiktok",
                                "instagram",
                                "youtube",
                                "x"
                            ],
                            "enumTitles": [
                                "TikTok",
                                "Instagram",
                                "YouTube",
                                "X / Twitter"
                            ]
                        }
                    },
                    "status": {
                        "title": "Campaign status",
                        "enum": [
                            "all",
                            "active",
                            "completed"
                        ],
                        "type": "string",
                        "description": "Choose active opportunities only, completed campaigns, or both.",
                        "default": "active"
                    },
                    "minRewardPer1kUsd": {
                        "title": "Minimum reward per 1K views (USD)",
                        "minimum": 0,
                        "type": "number",
                        "description": "Exclude campaigns with a lower or unparseable public payout rate."
                    },
                    "minBudgetRemainingUsd": {
                        "title": "Minimum budget left (USD)",
                        "minimum": 0,
                        "type": "number",
                        "description": "Exclude campaigns with less remaining budget or an unparseable budget."
                    },
                    "sortBy": {
                        "title": "Sort campaigns",
                        "enum": [
                            "newest",
                            "reward",
                            "budget-left"
                        ],
                        "type": "string",
                        "description": "Order matching campaigns by funding date, payout rate, or remaining budget before applying the limit.",
                        "default": "newest"
                    },
                    "enrichDetails": {
                        "title": "Extract requirements and payout rules",
                        "type": "boolean",
                        "description": "Open each selected campaign page to add requirements, platform payout details, creator counts, and resource links. This is slower than discovery-only extraction.",
                        "default": false
                    },
                    "maxConcurrency": {
                        "title": "Detail request concurrency",
                        "minimum": 1,
                        "maximum": 10,
                        "type": "integer",
                        "description": "Maximum campaign detail pages fetched at once when enrichment or direct URLs are used.",
                        "default": 5
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```