# Whop Content Rewards Scraper — Clipping & UGC Campaigns (`fayoussef/whop-clipping-campaigns-scraper`) Actor

Scrape every live Whop Content Rewards campaign: reward per 1K views, budget left, burn rate, platforms, categories & campaign URLs. Monitor mode flags new clipping campaigns since your last run. Filter by reward, budget, platform. Export JSON/CSV, run via API or MCP.

- **URL**: https://apify.com/fayoussef/whop-clipping-campaigns-scraper.md
- **Developed by:** [youssef farhan](https://apify.com/fayoussef) (community)
- **Categories:** Automation, Developer tools, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.20 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.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/platform/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

### What does Whop Content Rewards Scraper do?

Whop Content Rewards Scraper lets you **scrape every live clipping and UGC campaign** from [Whop Content Rewards](https://whop.com/discover/content-rewards/) in one run — no login, no cookies, no API key. For each campaign you get the **reward per 1,000 views**, **total budget**, **budget spent**, **budget left**, burn percentage, accepted social platforms (TikTok, Instagram, YouTube, X), campaign type, category, creator count, view stats, funding date, full rules text, and a direct campaign URL.

Because it runs on Apify, you can **export the data to JSON, CSV, or Excel**, call it as a **Content Rewards API** from your own code, **schedule it** to run hourly or daily, plug it into integrations (Google Sheets, Slack, webhooks), or let **AI agents call it via the Apify MCP server**.

### Why use Whop Content Rewards Scraper?

- **Clippers & clipping agencies** — find the highest-paying clipping campaigns and catch new launches *before they saturate*. Sort by "fewest creators" to find low-competition campaigns.
- **Creators & brands** — benchmark reward-per-view rates and budgets against other campaigns in your category before launching your own.
- **Analysts & tool builders** — treat the creator-economy campaign directory as a dataset: track launches, budget burn rates, platform trends, and payout velocity over time.
- **Automation & AI agents** — programmatically discover campaigns matching your criteria (reward threshold, budget left, platform, category) and chain the results into downstream tools.

#### What makes this scraper different?

- **Built-in campaign monitoring.** A persistent snapshot is kept between runs, so every item carries `isNew` (campaign launched since your last run) and `budgetSpentDeltaUsd` (how much the campaign paid out since your last run — a live burn-rate signal). Turn on **Only new campaigns** and schedule the Actor to get a feed of fresh campaigns only.
- **Estimated views remaining.** `budgetLeftUsd / rewardPerThousandUsd × 1000` tells you how many views a campaign can still pay for.
- **One request, whole directory.** Pure HTTP scraping — fast, cheap, and reliable.

### How to find the best Whop clipping campaigns

1. Click **Try for free** — no input is required; the default run returns all active campaigns sorted by budget left.
2. Optionally set filters: minimum reward per 1K views, minimum budget left, platforms, campaign type (clipping / UGC), or a search keyword.
3. Click **Start** and wait a few seconds.
4. Open the **Output** tab to browse campaigns, or **Export** the dataset as JSON, CSV, or Excel.
5. To monitor for new campaigns, enable **Only new campaigns since last run** and add a **Schedule** (e.g. every 6 hours).

### Input

All fields are optional — an empty input returns the full active directory. Example:

```json
{
    "platforms": ["tiktok", "instagram"],
    "minRewardPerThousand": 1,
    "minBudgetLeftUsd": 1000,
    "maxProgressPercentage": 90,
    "sortBy": "budgetLeft",
    "maxItems": 100
}
````

This example returns TikTok/Instagram campaigns paying at least $1 per 1K views with at least $1,000 of budget still unspent — roughly 200 live campaigns at the time of writing.

### Output

You can download the dataset in various formats such as JSON, HTML, CSV, or Excel. One item per campaign:

```json
{
    "title": "ROOBET UGC REPOSTING V2",
    "brand": "Creator Casino",
    "campaignType": "clipping",
    "category": "Entertainment",
    "status": "active",
    "rewardPerThousandUsd": 1.5,
    "totalBudgetUsd": 250000.0,
    "budgetSpentUsd": 40688.64,
    "budgetLeftUsd": 209311.36,
    "progressPercentage": 16,
    "estimatedViewsRemaining": 139540907,
    "socialPlatforms": ["tiktok", "instagram"],
    "creatorsCount": 3181,
    "viewCountDisplay": "23.2M",
    "successRate": 13,
    "fundedAt": "2026-06-10T21:05:05.000Z",
    "campaignUrl": "https://whop.com/creator-casino-7b/",
    "description": "Roobet is putting their product in front of the right audience at scale...",
    "isNew": false,
    "budgetSpentDeltaUsd": 4.7
}
```

### Data fields

| Field | Description |
|---|---|
| `title`, `brand`, `description` | Campaign name, the brand running it, and the full rules text |
| `rewardPerThousandUsd` | Dollars paid per 1,000 views |
| `totalBudgetUsd` / `budgetSpentUsd` / `budgetLeftUsd` | Campaign budget, amount already paid out, and money still available |
| `progressPercentage` | % of the budget already spent |
| `estimatedViewsRemaining` | Views the remaining budget can still pay for |
| `socialPlatforms` | Accepted platforms: tiktok, instagram, youtube, x |
| `campaignType` / `category` | clipping, ugc, or both / Music, Personal Brand, Product, … |
| `creatorsCount` | Creators already participating — a competition signal |
| `successRate` | Share of submissions that get approved |
| `isNew` | Campaign appeared since your previous run |
| `budgetSpentDeltaUsd` | Payout since your previous run (burn rate) |
| `campaignUrl` | Direct link to the campaign's Whop page |

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

You pay per campaign returned — a full directory pull (~500 campaigns) costs well under a dollar, and filtered runs cost just cents. **Free plan users are limited to 25 campaigns per run.** Subscribe to an [Apify plan](https://apify.com/pricing?fpr=youssef) to unlock the full directory, scheduling, and higher limits.

### Tips for catching campaigns early

- **Schedule + Only new campaigns** is the killer combo: run every few hours and receive only freshly launched campaigns, before thousands of clippers pile in.
- Sort by **Fewest creators first** to find campaigns with real budget but little competition.
- Use **Max budget spent %** ≤ 80 to skip nearly exhausted campaigns whose views may no longer be paid.
- Watch `budgetSpentDeltaUsd` across scheduled runs — campaigns that burn fast are campaigns that actually pay.

### FAQ

#### What is Whop Content Rewards?

Whop Content Rewards is a marketplace where brands and creators fund campaigns that pay you per 1,000 views for posting clips or original UGC on TikTok, Instagram, YouTube, and X. Campaigns have a fixed budget and pay out until it runs dry.

#### How do I find Whop clipping campaigns that still pay?

Filter by **Min budget left** and **Max budget spent %**. A campaign with $50,000 unspent and only 20% burned will keep paying for a long time; a 95%-spent campaign may stop paying tomorrow.

#### Do I need a Whop account or cookies?

No. This scraper reads the public campaign directory — no login, cookies, or API key required.

#### Can I use this as a Whop Content Rewards API?

Yes. Every Apify Actor is callable via REST API — start a run and fetch the dataset in JSON from your own code, n8n, Make, or Zapier. AI agents can also call this Actor through the **Apify MCP server** for programmatic campaign discovery.

#### Is scraping Whop Content Rewards legal?

This Actor only collects publicly visible campaign data (no personal data, no login-gated content). You are responsible for using the data in compliance with Whop's terms of service and applicable laws.

### Support & custom solutions

Found an issue or want an extra field? Open a ticket in the **Issues** tab — the Actor is actively maintained.

💼 Need a custom scraper or automation? Reach out at **youssefarhan24@gmail.com**
🌐 Got a site in mind? [Suggest it here](https://automationbyexperts.com/apify)
⚡ Unlock full results with an [Apify plan](https://apify.com/pricing?fpr=youssef)

# Actor input Schema

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

Only keep campaigns whose title, brand, category or description contains this text (case-insensitive). Example: `poker`, `music`, `AI`. Leave empty to get the whole directory.

⚡ Unlock full pages and higher limits by subscribing to an [Apify plan](https://apify.com/pricing?fpr=youssef).
💼 Need a custom solution? Reach out at youssefarhan24@gmail.com
🌐 Got a site in mind? [Suggest it here](https://automationbyexperts.com/apify)

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

Filter by campaign type. `Clipping` = repost/clip existing content, `UGC` = create original content. Campaigns marked `Both` accept either and are included when you pick Clipping or UGC. Leave empty for all types.

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

Only campaigns that accept at least one of these platforms. Leave empty for all.

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

Filter by campaign category as shown on Whop. Leave empty for all categories.

## `minRewardPerThousand` (type: `integer`):

Only campaigns paying at least this many dollars per 1,000 views. Example: `2`.

## `minBudgetLeftUsd` (type: `integer`):

Only campaigns with at least this much unspent budget — the practical signal that new views will still get paid. Example: `5000`.

## `maxProgressPercentage` (type: `integer`):

Skip nearly exhausted campaigns: only keep campaigns whose budget is at most this % spent. Example: `80`.

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

`Active` = currently paying out (default). `All` also includes completed campaigns present in the directory.

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

`Budget left` surfaces campaigns with the most money still to pay out. `Fewest creators` surfaces low-competition campaigns.

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

Upper limit of campaigns to return. You are only charged for returned results.

## `onlyNewCampaigns` (type: `boolean`):

Monitoring mode: only output campaigns that were NOT present in your previous run — perfect on a schedule to catch fresh campaigns before they saturate. The first run just builds the baseline snapshot.

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

Proxy settings. The default Apify proxy works in most cases; switch to the RESIDENTIAL group if runs start returning zero campaigns.

## Actor input object example

```json
{
  "campaignTypes": [],
  "platforms": [
    "tiktok",
    "instagram"
  ],
  "categories": [],
  "minRewardPerThousand": 1,
  "minBudgetLeftUsd": 1000,
  "maxProgressPercentage": 90,
  "status": "active",
  "sortBy": "budgetLeft",
  "maxItems": 100,
  "onlyNewCampaigns": false,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

All scraped Content Rewards campaigns with reward rates, budgets and burn metrics.

# 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 = {
    "platforms": [
        "tiktok",
        "instagram"
    ],
    "minRewardPerThousand": 1,
    "minBudgetLeftUsd": 1000,
    "maxProgressPercentage": 90,
    "maxItems": 100,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("fayoussef/whop-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 = {
    "platforms": [
        "tiktok",
        "instagram",
    ],
    "minRewardPerThousand": 1,
    "minBudgetLeftUsd": 1000,
    "maxProgressPercentage": 90,
    "maxItems": 100,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("fayoussef/whop-clipping-campaigns-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 '{
  "platforms": [
    "tiktok",
    "instagram"
  ],
  "minRewardPerThousand": 1,
  "minBudgetLeftUsd": 1000,
  "maxProgressPercentage": 90,
  "maxItems": 100,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call fayoussef/whop-clipping-campaigns-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Whop Content Rewards Scraper — Clipping & UGC Campaigns",
        "description": "Scrape every live Whop Content Rewards campaign: reward per 1K views, budget left, burn rate, platforms, categories & campaign URLs. Monitor mode flags new clipping campaigns since your last run. Filter by reward, budget, platform. Export JSON/CSV, run via API or MCP.",
        "version": "0.1",
        "x-build-id": "1IU3g5GEZ0ukKckCa"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/fayoussef~whop-clipping-campaigns-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-fayoussef-whop-clipping-campaigns-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/fayoussef~whop-clipping-campaigns-scraper/runs": {
            "post": {
                "operationId": "runs-sync-fayoussef-whop-clipping-campaigns-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/fayoussef~whop-clipping-campaigns-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-fayoussef-whop-clipping-campaigns-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": {
                    "searchText": {
                        "title": "Search text (optional)",
                        "type": "string",
                        "description": "Only keep campaigns whose title, brand, category or description contains this text (case-insensitive). Example: `poker`, `music`, `AI`. Leave empty to get the whole directory.\n\n⚡ Unlock full pages and higher limits by subscribing to an [Apify plan](https://apify.com/pricing?fpr=youssef).\n💼 Need a custom solution? Reach out at youssefarhan24@gmail.com\n🌐 Got a site in mind? [Suggest it here](https://automationbyexperts.com/apify)"
                    },
                    "campaignTypes": {
                        "title": "Campaign types",
                        "type": "array",
                        "description": "Filter by campaign type. `Clipping` = repost/clip existing content, `UGC` = create original content. Campaigns marked `Both` accept either and are included when you pick Clipping or UGC. Leave empty for all types.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "clipping",
                                "ugc",
                                "both"
                            ],
                            "enumTitles": [
                                "Clipping",
                                "UGC",
                                "Both"
                            ]
                        },
                        "default": []
                    },
                    "platforms": {
                        "title": "Social platforms",
                        "type": "array",
                        "description": "Only campaigns that accept at least one of these platforms. Leave empty for all.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "tiktok",
                                "instagram",
                                "youtube",
                                "x"
                            ],
                            "enumTitles": [
                                "TikTok",
                                "Instagram",
                                "YouTube",
                                "X (Twitter)"
                            ]
                        },
                        "default": []
                    },
                    "categories": {
                        "title": "Categories",
                        "type": "array",
                        "description": "Filter by campaign category as shown on Whop. Leave empty for all categories.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "Personal Brand",
                                "Music",
                                "Product",
                                "Entertainment",
                                "Technology",
                                "Logo",
                                "Slideshow",
                                "Gaming",
                                "Other"
                            ],
                            "enumTitles": [
                                "Personal Brand",
                                "Music",
                                "Product",
                                "Entertainment",
                                "Technology",
                                "Logo",
                                "Slideshow",
                                "Gaming",
                                "Other"
                            ]
                        },
                        "default": []
                    },
                    "minRewardPerThousand": {
                        "title": "Min reward per 1K views (USD)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only campaigns paying at least this many dollars per 1,000 views. Example: `2`."
                    },
                    "minBudgetLeftUsd": {
                        "title": "Min budget left (USD)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only campaigns with at least this much unspent budget — the practical signal that new views will still get paid. Example: `5000`."
                    },
                    "maxProgressPercentage": {
                        "title": "Max budget spent (%)",
                        "minimum": 0,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Skip nearly exhausted campaigns: only keep campaigns whose budget is at most this % spent. Example: `80`."
                    },
                    "status": {
                        "title": "Campaign status",
                        "enum": [
                            "active",
                            "all"
                        ],
                        "type": "string",
                        "description": "`Active` = currently paying out (default). `All` also includes completed campaigns present in the directory.",
                        "default": "active"
                    },
                    "sortBy": {
                        "title": "Sort results by",
                        "enum": [
                            "budgetLeft",
                            "reward",
                            "newest",
                            "progress",
                            "creators"
                        ],
                        "type": "string",
                        "description": "`Budget left` surfaces campaigns with the most money still to pay out. `Fewest creators` surfaces low-competition campaigns.",
                        "default": "budgetLeft"
                    },
                    "maxItems": {
                        "title": "Max campaigns",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Upper limit of campaigns to return. You are only charged for returned results.",
                        "default": 500
                    },
                    "onlyNewCampaigns": {
                        "title": "Only new campaigns since last run",
                        "type": "boolean",
                        "description": "Monitoring mode: only output campaigns that were NOT present in your previous run — perfect on a schedule to catch fresh campaigns before they saturate. The first run just builds the baseline snapshot.",
                        "default": false
                    },
                    "proxyConfiguration": {
                        "title": "Proxy",
                        "type": "object",
                        "description": "Proxy settings. The default Apify proxy works in most cases; switch to the RESIDENTIAL group if runs start returning zero campaigns.",
                        "default": {
                            "useApifyProxy": true
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```