# Skool Posts & Comments Scraper — Full Threads & Engagement (`scrapersdelight/skool-posts-scraper`) Actor

$0.0005/post + $0.0005/comment. Scrape any Skool community's posts AND full nested comment trees — title, body, author, timestamp, likes, comment count, every reply. Public communities need no login; bring your own Skool login for member-only data. Date filter + new-post monitor.

- **URL**: https://apify.com/scrapersdelight/skool-posts-scraper.md
- **Developed by:** [Scrapers Delight](https://apify.com/scrapersdelight) (community)
- **Categories:** AI, Automation, Social media
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.50 / 1,000 lot scrapeds

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

## 💬 Skool Posts & Comments Scraper — Full Threads & Engagement

**Scrape any Skool community's feed — posts AND their complete, nested comment trees — in one run. For every post you get the title, body, author, timestamp, likes and comment count; for every reply you get the author, text, time, likes and how deep it sits in the thread. Filter by date for incremental pulls, and turn on the monitor to get alerted the moment a new post drops. Public communities need no login; bring your own Skool cookie for member-only data.**

Only checks your User-Agent — no captcha, no headless browser, no flaky login flow. Posts come straight from Skool's server-rendered page data; comments come from Skool's own public JSON API, so the full reply tree comes back intact.

---

### Why this one

Most Skool scrapers stop at the post and hand you a flat list with no replies, or scrape only what's on the first screen. This one is built around the **thread**:

- ✅ **Full nested comment tree** — every reply and reply-to-a-reply, with a `depth` field so you can rebuild the conversation
- ✅ **Posts *and* comments in one run** — no second actor, no stitching two datasets together
- ✅ **Real engagement numbers** — `likes` and `comment_count` on posts, `likes` on every comment
- ✅ **Date filter** — `postedAfter` for clean incremental/delta pulls instead of re-scraping everything
- ✅ **New-post monitor** with Slack / email / webhook alerts — pair with a Schedule
- ✅ **Public communities work with zero login**; private/paid communities work with **your own** Skool cookie

---

### What you get

**Per post:** `title` · `body` · `author_handle` · `author_name` · `author_id` · **`likes`** · **`comment_count`** · `pinned` · `category` (label) · `created_at` · `updated_at` · `post_url` · `id`

**Per comment / reply:** `text` · `author_handle` · `author_id` · **`likes`** · **`depth`** (0 = top-level) · `is_reply` · `parent_id` · `root_post_id` · `parent_post_title` · `created_at` · `comment_url` · `id`

Export to CSV / JSON / Excel, or pull via the Apify API into your warehouse, a sentiment model, n8n, Make, or a Clay table.

---

### How to use it

1. Click **Try for free**.
2. Paste a **community URL** (e.g. `https://www.skool.com/ai-automation-society`) — or just the slug.
3. Keep **Include comments & replies** on for full threads (turn it off for a faster, posts-only run).
4. Click **Start**, then open the **Dataset** tab (switch the view between **Posts** and **Comments & replies**).
5. **For a live feed:** turn on **Monitor mode** + a **Schedule** to get alerted when a new post lands.

#### Quick start (public community, no login)
```json
{ "communityUrl": "https://www.skool.com/ai-automation-society", "maxItems": 50, "includeComments": true }
````

#### Incremental / delta pull

```json
{ "communityUrl": "ai-automation-society", "postedAfter": "2026-06-01", "includeComments": true }
```

#### Private / paid community (your own membership)

```json
{ "communityUrl": "https://www.skool.com/your-paid-group", "skoolCookie": "auth_token=eyJ…", "maxItems": 0 }
```

#### Daily new-post monitor

```json
{ "communityUrl": "ai-automation-society", "monitorMode": true, "slackWebhookUrl": "https://hooks.slack.com/services/…" }
```

***

### Who it's for

- 🧠 **Community operators & ghostwriters** — pull the whole feed to study what gets engagement
- 📈 **Market & sentiment research** — mine posts + comments for pain points, objections, requests
- 🤖 **AI / RAG builders** — turn a community's threads into a clean dataset for a model
- 🔔 **Members who can't keep up** — monitor mode pings you when a new post drops
- 🗂️ **Course / cohort owners** — archive your own community's posts and discussions

***

### Pricing (pay-per-event)

You pay per record returned — no monthly subscription, no per-run minimum.

| Event | What it covers | Suggested price |
|-------|----------------|-----------------|
| `lot-scraped` | each post **or** comment returned | ~$1 / 1,000 ($0.001) |
| `lot-detail-enriched` | each post we open to pull its comment tree | ~$1 / 1,000 ($0.001) |
| `monitor-run-completed` | each scheduled watch run | ~$0.05 / run |
| `new-lot-detected` | each newly-seen post in monitor mode | ~$0.01 |
| `alert-delivered` | each Slack / email / webhook alert | ~$0.005 |

A 50-post run with comments on a busy community is typically a few cents. Posts-only runs are cheaper — turn off **Include comments & replies**.

***

### How it compares

| | **This actor** | Typical Skool scraper | Leading Skool suite | Budget clone |
|---|---|---|---|---|
| Posts (title, body, author, time) | ✅ | ✅ | ✅ | ✅ |
| **Full nested comment tree** | ✅ every reply + `depth` | ❌ none / first level only | ⚠️ flat, no nesting | ❌ |
| Likes + comment count | ✅ both | ⚠️ posts only | ✅ | ⚠️ |
| Date / delta filter | ✅ `postedAfter` | ❌ | ⚠️ | ❌ |
| New-post monitor + alerts | ✅ Slack / email / webhook | ❌ | ⚠️ extra actor | ❌ |
| Private community (your login) | ✅ your own cookie | ⚠️ sometimes | ✅ | ❌ |
| Pricing | **per-result, $0.001** | monthly | monthly | per-result |

*Generic comparison — not a claim about any specific provider.*

***

### Related Skool & community actors (ours)

| Actor | What it pulls |
|-------|---------------|
| **Skool Posts & Comments Scraper** (this) | Posts + full nested comment threads + engagement |
| **Eventective Scraper** | Event vendor & venue leads + emails |
| **BounceGuide Scraper** | Party-rental company leads by state/city |

***

### Notes & limits

- **Public community data.** Post and comment content, authors, and engagement are visible to anyone who opens the public community page; this actor reads the same data. **You are responsible** for compliant use of what you collect (GDPR / local law) and for respecting Skool's Terms.
- **Private/paid communities use *your own* login.** The `skoolCookie` is your personal `auth_token` — it is sent only to Skool, never stored or logged. Only use it on communities you are a paying/approved member of.
- **No double-counting in monitor mode** — seen post IDs are remembered in a named store, so each post is alerted once.
- **`depth`** rebuilds the thread: `0` = top-level comment, `1` = reply, `2` = reply-to-a-reply, and so on.

***

### FAQ

**Does it get the comments, not just the posts?** Yes — that's the point. With **Include comments & replies** on, every post's full nested reply tree is pulled and flattened with a `depth` field so you can reconstruct the conversation.

**Do I need to log in?** No, for **public/free** communities. Only **private/paid** communities need your own Skool cookie.

**Where do I get the cookie?** Log into Skool in your browser, open DevTools → Application → Cookies → `skool.com`, copy the `auth_token` value, and paste it (raw, or as `auth_token=…`). It's marked secret and is never logged.

**Can it scrape a community I'm not a member of?** Only if it's **public**. Private communities require you to be a member (your cookie).

**How do I do an incremental update?** Set `postedAfter` to your last run's date. It stops paging once it reaches older posts and skips older comments.

**How do I only get *new* posts?** Turn on **Monitor mode** and add a **Schedule**. It diffs against the previous run per community and outputs/alerts only new posts.

**How many posts can it pull?** Set `maxItems: 0` for the entire community (can be thousands). The default `50` keeps test runs fast and cheap.

**What's the `category` field?** Skool communities organize posts into labels/channels (e.g. "General Discussion", "Support"). We map each post's label to its display name.

**Does it handle @mentions in the text?** Yes — Skool's `[@Name](obj://user/…)` mention markup is normalized to a readable `@Name`.

**Is it blocked by anti-bot?** No captcha or JS challenge — Skool only checks the User-Agent, which the actor sends, with proxy rotation and retries for reliability.

**Can I get posts only (no comments)?** Yes — turn off **Include comments & replies** for a faster, cheaper run.

**Why per-result pricing instead of monthly?** You only pay for what you pull. A small run costs a few cents; you're never locked into a subscription.

# Actor input Schema

## `communityUrl` (type: `string`):

The Skool community to scrape, e.g. https://www.skool.com/ai-automation-society (or just the slug 'ai-automation-society'). Public/free communities need no login. For a private/paid community you are a member of, add your Skool cookie below.

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

Cap on how many posts to scrape from the feed (newest first). 0 = the whole community (can be thousands). Comments are pulled per post on top of this.

## `includeComments` (type: `boolean`):

Also pull each post's FULL nested comment tree (every reply, with author, text, time, likes, depth). Turn off for a posts-only, faster/cheaper run.

## `maxCommentsPerPost` (type: `integer`):

Cap on comments pulled per post (0 = all). Keeps big viral threads from dominating a run.

## `postedAfter` (type: `string`):

ISO date, e.g. 2026-06-01. Skips anything older — ideal for incremental/delta pulls. Leave blank for everything.

## `skoolCookie` (type: `string`):

OPTIONAL. Your OWN Skool login cookie (the 'auth\_token' value set on .skool.com after you log in), used to scrape private/paid communities you are a member of. Paste either the raw token or 'auth\_token=...'. Never stored or logged. Leave blank for public communities.

## `monitorMode` (type: `boolean`):

Recurring watcher: diff against the prior run (per community) and output/alert ONLY new posts. Pair with an Apify Schedule.

## `alertOnNewPost` (type: `boolean`):

In monitor mode, send an alert for each new post.

## `webhookUrl` (type: `string`):

POST endpoint for new-post alerts (monitor mode).

## `slackWebhookUrl` (type: `string`):

Slack incoming-webhook URL for new-post alerts.

## `emailRecipients` (type: `array`):

Emails for the new-post digest (via apify/send-mail).

## `concurrency` (type: `integer`):

How many posts to pull comments for in parallel.

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

Proxy settings. Datacenter rotation is plenty — Skool only checks the User-Agent, not the IP.

## `diagnose` (type: `boolean`):

Dev only. Logs the first parsed post + its comments, then exits.

## Actor input object example

```json
{
  "communityUrl": "https://www.skool.com/ai-automation-society",
  "maxItems": 50,
  "includeComments": true,
  "maxCommentsPerPost": 200,
  "monitorMode": false,
  "alertOnNewPost": true,
  "concurrency": 5,
  "proxyConfiguration": {
    "useApifyProxy": true
  },
  "diagnose": false
}
```

# Actor output Schema

## `threads` (type: `string`):

The dataset of posts and their nested comments/replies (one item per post or comment).

# 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 = {
    "communityUrl": "https://www.skool.com/ai-automation-society",
    "maxItems": 50
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapersdelight/skool-posts-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 = {
    "communityUrl": "https://www.skool.com/ai-automation-society",
    "maxItems": 50,
}

# Run the Actor and wait for it to finish
run = client.actor("scrapersdelight/skool-posts-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 '{
  "communityUrl": "https://www.skool.com/ai-automation-society",
  "maxItems": 50
}' |
apify call scrapersdelight/skool-posts-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Skool Posts & Comments Scraper — Full Threads & Engagement",
        "description": "$0.0005/post + $0.0005/comment. Scrape any Skool community's posts AND full nested comment trees — title, body, author, timestamp, likes, comment count, every reply. Public communities need no login; bring your own Skool login for member-only data. Date filter + new-post monitor.",
        "version": "0.1",
        "x-build-id": "cLpdc1INoVOwdNRhj"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapersdelight~skool-posts-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapersdelight-skool-posts-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/scrapersdelight~skool-posts-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scrapersdelight-skool-posts-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/scrapersdelight~skool-posts-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scrapersdelight-skool-posts-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": {
                    "communityUrl": {
                        "title": "Skool community URL (or slug)",
                        "type": "string",
                        "description": "The Skool community to scrape, e.g. https://www.skool.com/ai-automation-society (or just the slug 'ai-automation-society'). Public/free communities need no login. For a private/paid community you are a member of, add your Skool cookie below."
                    },
                    "maxItems": {
                        "title": "Max posts",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Cap on how many posts to scrape from the feed (newest first). 0 = the whole community (can be thousands). Comments are pulled per post on top of this.",
                        "default": 50
                    },
                    "includeComments": {
                        "title": "Include comments & replies",
                        "type": "boolean",
                        "description": "Also pull each post's FULL nested comment tree (every reply, with author, text, time, likes, depth). Turn off for a posts-only, faster/cheaper run.",
                        "default": true
                    },
                    "maxCommentsPerPost": {
                        "title": "Max comments per post",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Cap on comments pulled per post (0 = all). Keeps big viral threads from dominating a run.",
                        "default": 200
                    },
                    "postedAfter": {
                        "title": "Only posts/comments after (date)",
                        "type": "string",
                        "description": "ISO date, e.g. 2026-06-01. Skips anything older — ideal for incremental/delta pulls. Leave blank for everything."
                    },
                    "skoolCookie": {
                        "title": "Skool session cookie (private communities only)",
                        "type": "string",
                        "description": "OPTIONAL. Your OWN Skool login cookie (the 'auth_token' value set on .skool.com after you log in), used to scrape private/paid communities you are a member of. Paste either the raw token or 'auth_token=...'. Never stored or logged. Leave blank for public communities."
                    },
                    "monitorMode": {
                        "title": "Monitor mode (new-post watcher)",
                        "type": "boolean",
                        "description": "Recurring watcher: diff against the prior run (per community) and output/alert ONLY new posts. Pair with an Apify Schedule.",
                        "default": false
                    },
                    "alertOnNewPost": {
                        "title": "Alert on new posts",
                        "type": "boolean",
                        "description": "In monitor mode, send an alert for each new post.",
                        "default": true
                    },
                    "webhookUrl": {
                        "title": "Webhook URL",
                        "type": "string",
                        "description": "POST endpoint for new-post alerts (monitor mode)."
                    },
                    "slackWebhookUrl": {
                        "title": "Slack webhook URL",
                        "type": "string",
                        "description": "Slack incoming-webhook URL for new-post alerts."
                    },
                    "emailRecipients": {
                        "title": "Email recipients",
                        "type": "array",
                        "description": "Emails for the new-post digest (via apify/send-mail).",
                        "items": {
                            "type": "string"
                        }
                    },
                    "concurrency": {
                        "title": "Comment-fetch concurrency",
                        "minimum": 1,
                        "maximum": 15,
                        "type": "integer",
                        "description": "How many posts to pull comments for in parallel.",
                        "default": 5
                    },
                    "proxyConfiguration": {
                        "title": "Proxy",
                        "type": "object",
                        "description": "Proxy settings. Datacenter rotation is plenty — Skool only checks the User-Agent, not the IP.",
                        "default": {
                            "useApifyProxy": true
                        }
                    },
                    "diagnose": {
                        "title": "Diagnostic mode (dev)",
                        "type": "boolean",
                        "description": "Dev only. Logs the first parsed post + its comments, then exits.",
                        "default": false
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```