# Clipping Campaigns Aggregator — 4 Boards, One Feed (`tactful_anvil/clipping-campaigns-aggregator`) Actor

Every public clipping / content-rewards campaign from Whop Content Rewards, Promote.fun, Vyro & ClipAffiliates in one deduplicated dataset: CPM, budget left, burn rate, est. days left and a proof-gated 0-100 opportunity score. HTTP-only, no login, no key.

- **URL**: https://apify.com/tactful\_anvil/clipping-campaigns-aggregator.md
- **Developed by:** [Mr Zack](https://apify.com/tactful_anvil) (community)
- **Categories:** Lead generation, Social media, Automation
- **Stats:** 1 total users, 0 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.08 / 1,000 campaign 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

## Clipping Campaigns Aggregator — Whop, Promote.fun, Vyro & ClipAffiliates in One Feed

**Every public clipping / content-rewards campaign, from four boards, in one deduplicated dataset.** One run pulls Whop Content Rewards (the biggest clipping board), Promote.fun, Vyro and ClipAffiliates, unifies them into a single schema, removes cross-board duplicates, and ranks every campaign with a proof-gated 0–100 opportunity score — so you see the best-paying campaign across the whole market, not just one site.

Clippers check these boards **manually, every day**, tab by tab. This Actor is that morning routine as an API: ~400–500 campaigns per run, HTTP-only, no login, no API key.

### Who this is for

- **Clippers & clipping agencies** — pick tonight's campaign by real numbers (CPM, budget actually left, burn rate, $ already paid per clipper) across all boards at once, not vibes on one board.
- **Job-alert / Discord bot builders** — one schema instead of four scrapers; `isFreshWithin72h` and `source` make "new campaign" alerts trivial.
- **Creator-economy analysts & platform founders** — track total budget posted vs actually paid out across the clipping market.

### Why an aggregator (and not four scrapers)

- **One schema.** Whop's `pricePerView`, Vyro's `payoutModel.payRate` and ClipAffiliates' `pay_rate/views_per_rate` all become `cpmUsd`. Budgets, spend and remaining are normalized the same way.
- **Deduplicated.** Brands cross-post. Duplicate campaigns collapse into the most complete row; `crossListedOn` tells you where else it runs. Dropped duplicates are never billed.
- **Comparable scores.** `opportunityScore` uses the identical formula for every board, so a Vyro campaign and a Whop campaign compete fairly in one ranking.
- **Fault-isolated.** Boards go down (ClipAffiliates spent late Aug 2026 in a site-wide 503). Each source fetches independently: one dead board reduces coverage, never kills your run. Per-source status is stored in the `SOURCE_SUMMARY` key-value record of every run.

### Output fields

| Field | Type | Description |
|---|---|---|
| `source` | string | `whop` | `promotefun` | `vyro` | `clipaffiliates` |
| `id` | string | Source-prefixed campaign ID (`whop:…`) |
| `name`, `brand` | string | Campaign title and the brand/creator paying |
| `campaignUrl` | string | Direct link to join the campaign |
| `status` | string | `active` | `completed` | null (board doesn't publish one) |
| `platforms` | array | tiktok / instagram / youtube / twitter / facebook |
| `cpmUsd` | number | USD paid per 1,000 views |
| `budgetUsd` / `budgetSpentUsd` / `budgetRemainingUsd` | number | Pool, actually paid out, still on the table |
| `budgetSpentPct` | number | 0–100 |
| `hasPaidEvidence` | boolean | `budgetSpentUsd > 0` — the campaign provably pays |
| `creatorsCount` | number | Clippers already in (competition) |
| `totalViews` | number | Views delivered so far |
| `postedAt`, `ageDays`, `isFreshWithin72h` | — | Recency |
| `estimatedViewsRemaining` | number | remaining budget ÷ CPM × 1000 |
| `burnUsdPerDay` | number | Payout speed (Promote.fun: from the platform's own snapshots; others: spend ÷ age) |
| `estimatedDaysLeft`, `budgetPace` | — | Runway + bucket: draining / healthy / slow / stalled |
| `payoutPerCreatorUsd`, `viewsPerCreator` | number | What participants actually earned / delivered on average |
| `effectiveCpmUsd` | number | Spent $ per 1k delivered views — sanity check vs promised CPM |
| `opportunityScore` | number | 0–100 composite, see below |
| `crossListedOn` | array | Other boards carrying the same campaign |

**No fake zeros:** anything a board doesn't publish is `null`, never `0`. Vyro doesn't publish clipper counts — so `creatorsCount` is `null` there, and the score treats it as neutral, not as "zero competition".

#### opportunityScore (documented, reproducible)

`35% reward rate` ($/1k, saturates at $5) + `25% budget headroom` (saturates at $25k) + `25% low competition` + `15% payout velocity` (3–60 days runway is the sweet spot; both "drains tonight" and "stalled, nobody gets paid" are penalized). **Proof-gating:** a campaign that has paid out $0 gets its competition term clamped to neutral — an untested board is not an uncontested board.

### Input

All optional. Defaults pull all four boards, active campaigns, sorted by opportunity.

```json
{
  "sources": ["whop", "promotefun", "vyro", "clipaffiliates"],
  "status": "active",
  "platforms": ["tiktok"],
  "minCpmUsd": 2,
  "minRemainingBudgetUsd": 500,
  "paidEvidenceOnly": true,
  "sortBy": "opportunity",
  "maxItems": 200
}
```

### How to schedule this Actor (the whole point)

Clipping campaigns are perishable: budgets drain in days, the best ones in hours. A one-off run is a snapshot; a schedule is an edge.

1. Open the Actor in Apify Console and set your input (e.g. `paidEvidenceOnly: true`, `minRemainingBudgetUsd: 500`).
2. Click **Actions → Schedule** and pick a cadence — **daily at 07:00** fits the "what do I clip today?" routine; twice daily if you chase fresh drops.
3. Add an integration (Slack, Discord webhook, email, Google Sheets) to push each run's dataset wherever you work.
4. Filter alerts on `isFreshWithin72h = true` to only hear about new money.

A daily run of ~450 campaigns costs about **$0.50/day** at $1.08 per 1,000 results.

### Fair use & data

Public data only, fetched politely over plain HTTP from each board's own public endpoints — no logins, no bypassing access controls. Budgets and payouts are the numbers the platforms themselves publish; this Actor adds arithmetic, not guesses.

### Related single-board Actors

Want just one board, cheaper? [Whop Content Rewards Scraper](https://apify.com/tactful_anvil/whop-content-rewards-scraper) · [Promote.fun Scraper](https://apify.com/tactful_anvil/promote-fun-clipping-campaigns-scraper) · [Vyro Scraper](https://apify.com/tactful_anvil/vyro-clipping-campaigns-scraper) · [ClipAffiliates Scraper](https://apify.com/tactful_anvil/clipaffiliates-clipping-campaigns-scraper)

# Actor input Schema

## `sources` (type: `array`):

Which clipping boards to pull. Default: all four (whop, promotefun, vyro, clipaffiliates).

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

active (default), completed (payout history), or all. Rows whose board doesn't publish a status are kept.

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

Keep campaigns accepting any of these (youtube, tiktok, instagram, twitter, facebook). Empty = all.

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

Case-insensitive match against campaign name, brand and category.

## `minCpmUsd` (type: `integer`):

Keep campaigns paying at least this per 1,000 views.

## `minRemainingBudgetUsd` (type: `integer`):

Keep campaigns with at least this much money left on the table.

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

Keep campaigns scoring at least this. Formula in README.

## `paidEvidenceOnly` (type: `boolean`):

Keep only campaigns with budget spent > 0 — proven payers.

## `deduplicate` (type: `boolean`):

Same campaign on several boards → keep the most complete row, note the rest in crossListedOn. Off = keep every row annotated.

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

Row order: opportunity (default), cpm, remainingBudget, burnRate, newest.

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

Cap on rows pushed (you are only billed for pushed rows).

## `promoteFunMaxItems` (type: `integer`):

Promote.fun needs 2 extra requests per campaign (detail + payout snapshots); this caps that board.

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

Only the Whop board needs it (TLS fingerprinting). Default: Apify datacenter proxy.

## Actor input object example

```json
{
  "sources": [
    "whop",
    "promotefun",
    "vyro",
    "clipaffiliates"
  ],
  "status": "active",
  "platforms": [],
  "paidEvidenceOnly": false,
  "deduplicate": true,
  "sortBy": "opportunity",
  "maxItems": 1000,
  "promoteFunMaxItems": 100,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `campaigns` (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 = {
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("tactful_anvil/clipping-campaigns-aggregator").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 = { "proxyConfiguration": { "useApifyProxy": True } }

# Run the Actor and wait for it to finish
run = client.actor("tactful_anvil/clipping-campaigns-aggregator").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 '{
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call tactful_anvil/clipping-campaigns-aggregator --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,tactful_anvil/clipping-campaigns-aggregator"
        }
    }
}

```

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/xol55k0upNnHkpyfA/builds/mdghXGcdbudtPcagV/openapi.json