# ClipAffiliates Clipping Campaigns Scraper (`tactful_anvil/clipaffiliates-clipping-campaigns-scraper`) Actor

Scrape ClipAffiliates' public campaign board: CPM per 1,000 views, budget spent vs remaining, paid views left, active affiliate competition count and a 0-100 opportunity score. HTTP-only, no login, no key. Built for clippers, UGC creators and agencies hunting fresh, low-competition campaigns.

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

## Pricing

from $0.96 / 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/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.

- **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

## ClipAffiliates Clipping Campaigns Scraper

Pulls the **public campaign board of [ClipAffiliates](https://www.clipaffiliates.com/discover)** — the clipping & UGC marketplace where creators pay clippers per 1,000 views — and turns it into clean, money-first rows: **CPM, budget remaining, paid views left, how many clippers are already competing, and a 0-100 opportunity score.**

No login. No API key. No proxies. HTTP-only, so runs finish in seconds and cost almost nothing.

### Who this is for

- **Clippers & UGC creators** deciding which campaign to jump on *today* — before the budget runs out.
- **Clipping agencies** monitoring every board (Whop, Vyro, ClipAffiliates) from one dashboard.
- **Analysts & builders** tracking the creator-economy clipping market.

The board moves fast: budgets deplete in days and new drops appear without notice. The clippers who catch a fresh campaign with low competition earn the most per clip. This actor exists so you never refresh the board manually again.

### What makes this board special: competition data

ClipAffiliates publicly exposes **`active_affiliates_count`** — how many clippers already joined each campaign. This actor turns that into:

- **`remainingUsdPerAffiliate`** — remaining budget ÷ active affiliates: the *competition-adjusted* money on the table.
- **`lowCompetition` sort + `maxActiveAffiliates` filter** — surface quiet campaigns before the crowd arrives.

No other clipping-board dataset gives you this.

### Output fields

| Field | Meaning |
|---|---|
| `name`, `creatorName`, `type` | Campaign, who runs it, `clipping` or `ugc` |
| `status` | `active` / `ended` (derived from end date + budget) |
| `cpmUsd` | USD per 1,000 views (normalized from pay rate) |
| `budgetUsd` / `budgetSpentUsd` / `budgetRemainingUsd` / `budgetSpentPct` | The money pool |
| `remainingViews` | How many views can still get paid at this CPM |
| `activeAffiliatesCount` | Clippers already in — your competition |
| `remainingUsdPerAffiliate` | Remaining budget split across the competition |
| `maxPostsPerAffiliate`, `maxAffiliates`, `accessType` | Participation rules |
| `platforms`, `countries`, `hashtag` | Where and how to post |
| `createdAt`, `ageHours`, `isFreshWithin24h/72h` | Catch new drops early |
| `endDate`, `endsInDays`, `closingWithin48h` | Deadline math |
| `opportunityScore` | 0-100: CPM (30) + budget headroom (30) + low competition (15) + freshness (15) + time left (10) |

### How to schedule this actor (recommended)

This data is worth the most when it's fresh. Set it and forget it:

1. Open the actor → **Schedules** → create a schedule (e.g. **every 30 minutes** or hourly).
2. For a cheap "new drop alert", set input `freshWithinHours: 1` with a 1-hour schedule — most runs push **0 rows (you pay only the $0.01 start fee)**, and the moment a new campaign lands you get exactly the new rows.
3. Add an **integration** (Slack / email / webhook) on "run succeeded with items" to get pinged only when something new appears.
4. Pair with `sortBy: "lowCompetition"` or `maxActiveAffiliates: 10` to be first into quiet campaigns.

### Example input

```json
{
  "activeOnly": true,
  "minCpmUsd": 1,
  "maxActiveAffiliates": 40,
  "sortBy": "opportunity"
}
```

### Pricing

Pay-per-event: **$0.01 per run + $0.96 per 1,000 campaign rows**. A typical run on today's board costs about a cent.

### The full clipping-economy data stack

Track every major clipping board with one scheduler:

- **[Whop Content Rewards Scraper](https://apify.com/tactful_anvil/whop-content-rewards-scraper)** — the biggest board (Whop.com content rewards)
- **[Vyro Clipping Campaigns Scraper](https://apify.com/tactful_anvil/vyro-clipping-campaigns-scraper)** — the MrBeast-backed marketplace
- **ClipAffiliates Campaigns Scraper** — this actor
- **[Galxe Quest Rewards Scraper](https://apify.com/tactful_anvil/galxe-quest-rewards-scraper)** — web3 quest rewards

### Notes & fair use

- Reads only the public discover board over its official public JSON endpoint — no login, no bypass, gentle request rate (a single GET per run).
- Not affiliated with ClipAffiliates.
- Data accuracy depends on what the board publishes; `estimated_spend` is the platform's own estimate.

# Actor input Schema

## `activeOnly` (type: `boolean`):

Keep only campaigns that have not ended and still have budget.

## `budgetAvailableOnly` (type: `boolean`):

Keep only campaigns with remaining budget > $0.

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

Filter by type: clipping or ugc. Leave empty for both.

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

Keep campaigns that accept at least one of these platforms (e.g. tiktok, youtube, twitter, instagram).

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

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

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

Keep campaigns with at least this much money left in the pool.

## `maxActiveAffiliates` (type: `integer`):

Keep campaigns with at most this many clippers already in — find the quiet ones.

## `freshWithinHours` (type: `integer`):

Keep only campaigns created in the last N hours. Great for schedules: most runs return 0 rows (cheap), new drops alert you.

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

opportunity = 0-100 blend of CPM, budget headroom, low competition, freshness and time left.

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

Hard cap on rows pushed (caps your cost).

## Actor input object example

```json
{
  "activeOnly": true,
  "budgetAvailableOnly": false,
  "sortBy": "opportunity",
  "maxItems": 500
}
```

# Actor output Schema

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

One row per ClipAffiliates campaign: CPM per 1,000 views, budget spent vs remaining, paid views left, active affiliate competition count, remaining USD per affiliate and a 0-100 opportunity score.

# 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("tactful_anvil/clipaffiliates-clipping-campaigns-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("tactful_anvil/clipaffiliates-clipping-campaigns-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 tactful_anvil/clipaffiliates-clipping-campaigns-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,tactful_anvil/clipaffiliates-clipping-campaigns-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/YiJGTUKuGL5wVaT61/builds/eOIEHTCg1JSDDad1c/openapi.json