# 🎓 Skool Group Scraper (`scraper-engine/skool-group-scraper`) Actor

🎓 Skool Group Scraper extracts rich data from Skool groups — members, profiles, posts, comments, reactions, topics/events & engagement stats. 📊 Export CSV/JSON datasets for analysis or outreach. 🚀 Ideal for community insights, growth & lead gen.

- **URL**: https://apify.com/scraper-engine/skool-group-scraper.md
- **Developed by:** [Scraper Engine](https://apify.com/scraper-engine) (community)
- **Categories:** Lead generation, Social media, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $4.99 / 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

### 🎓 Skool Group Scraper

The 🎓 Skool Group Scraper is a fast, reliable Skool group scraper that discovers communities from Skool discovery pages and enriches each with public About-page details. It solves the hassle of manual copy-paste by streaming structured group metadata — names, pricing, owners, counts, media, and visibility flags — directly into your Apify dataset in real time. Built for marketers, developers, data analysts, and researchers, this Skool community scraper scales from quick previews to large Skool group data export jobs with live progress and deduplication across multiple discovery URLs.

### What data / output can you get?

Below are examples of the structured fields this Skool web scraper produces. Results stream to the Apify dataset as each row finishes, ready to export to CSV, JSON, or Excel.

| Data type | Description | Example value |
| --- | --- | --- |
| id | Unique group ID | 123456 |
| name | Group slug used in URLs | "growth-hackers" |
| displayName | Public display name | "Growth Hackers" |
| description | Short group description | "Learn ethical growth tactics for SaaS." |
| monthlyPrice | Monthly membership price (major units) | 49 |
| monthlyCurrency | ISO currency (lowercase) | "usd" |
| annualPrice | Annual membership price (major units) | 490 |
| annualCurrency | ISO currency (lowercase) | "usd" |
| totalMembers | Total members count | 3127 |
| ownerName | Group owner’s full name | "Jane Doe" |
| ownerFirstName | Owner given name | "Jane" |
| ownerLastName | Owner family name | "Doe" |
| ownerLocation | Owner location (if provided) | "Austin, TX" |
| landingPageDescription | About/landing copy | "Join us for weekly AMAs and workshops…" |
| logoUrl | Logo URL (small) | "https://.../logo-small.png" |
| coverSmallUrl | Cover image URL | "https://.../cover-small.jpg" |
| audioChatVisible | Tab visibility flag | true |
| classroomVisible | Tab visibility flag | true |
| landingPageAttachments | Images/videos from landing page | [ { "type": "image", "imageOriginalUrl": "https://..." } ] |

Bonus outputs include owner social links (Instagram, YouTube, Facebook, Twitter, LinkedIn, website), supportEmail (extracted or inferred from landing text), favicon/logoBigUrl, privacy/membership/plan, and created/updated timestamps. You can export the dataset as CSV, JSON, or Excel from the Apify “Output” tab.

### Key features

- 🚀 Discover & enrich in one run: Start from Skool discovery pages and enrich each group via its public /about page. Ideal for Skool community data export and quick research snapshots.
- 🔁 Live, streaming saves: Results are pushed as soon as each row is enriched, so you can monitor progress and download partial data instantly.
- 🧠 Accurate pricing normalization: Monthly/annual prices and currencies are parsed and normalized to major units, including zero-decimal currencies.
- 🧱 Dedup across inputs: Safely input multiple discovery URLs — the scraper tracks seen group IDs to avoid duplicates.
- 🧰 Developer-friendly Apify actor: Built on Playwright and the Apify SDK for reliable Skool web scraper automation. Easily integrate the dataset into pipelines and workflows.
- 🌐 Smart connection handling: Optional Apify Proxy support with an automatic “ladder” that escalates to datacenter or residential routes when needed for resilient Skool group scraping automation.
- 💾 Flexible exports: Export Skool group data to CSV, JSON, or Excel formats directly from the dataset for analysis or outreach.

### How to use 🎓 Skool Group Scraper - step by step

1) Sign in to your Apify account and open the actor.

2) Add discovery URLs:
   - Paste one or more Skool discovery links into “urls”. The UI supports a simple list (one per line), and the actor accepts strings or objects with a url/URL property.

3) Set a limit:
   - Configure “maxItems” to cap how many communities to collect per discovery URL (1–500, default 100).

4) (Optional) Configure proxy:
   - Leave “proxyConfiguration” off for a direct connection. Turn it on only if you want to use Apify Proxy from the start.

5) Start the run:
   - Click Start. The actor loads each discovery page, fetches community lists, enriches via /about, and streams rows to the dataset.

6) Watch live results:
   - As each community finishes enrichment, a new row appears in the Output dataset with members, pricing, owner info, media attachments, and tab visibility flags.

7) Export your data:
   - Open the Output tab to export as CSV, JSON, or Excel.

Pro tip: Chain this Skool group data extractor with other Apify tasks or your own scripts to power ongoing Skool group scraping automation and analytics.

### Use cases

| Use case name | Description |
| --- | --- |
| Market research & benchmarking | Compare pricing models, membership sizes, and positioning across niches to inform strategy and content roadmaps. |
| Community scouting for partnerships | Identify relevant communities with owner details and engagement visibility flags to prioritize outreach. |
| Competitor monitoring | Track new and trending groups (by discovery pages) and analyze public landing copy and media. |
| Data enrichment for analytics | Enrich internal datasets with structured group IDs, slugs, owners, and counts for dashboards or reports. |
| Pipeline-ready data collection (API) | Use the Apify dataset API to pull clean JSON for downstream processing and BI. |
| Academic & social research | Study community growth patterns and public-facing metadata without authentication or cookies. |

### Why choose 🎓 Skool Group Scraper?

- 🎯 Precision from public pages: Focused on discovery + About enrichment for clean, reliable fields.
- ⚡ Scales with confidence: Handles multiple discovery URLs with de-duplication and concurrency-controlled enrichment.
- 🧩 Developer access: Built on Apify + Playwright for repeatable runs and easy dataset retrieval via API.
- 🔐 Safe-by-design: No login or cookies; collects only publicly available information.
- 🌐 Robust connection strategy: Optional Apify Proxy with an automatic ladder to handle picky connections.
- 💸 Cost-effective exports: Download CSV/JSON/Excel directly from your dataset — no extra tooling needed.

In short: a production-ready Skool members scraper tool for structured community intelligence — without the headaches of unstable browser extensions.

### Is it legal / ethical to use 🎓 Skool Group Scraper?

Yes — when done responsibly. This tool collects publicly available information from Skool discovery and About pages and does not access private or authenticated data.

Guidelines:
- Scrape only data you’re allowed to access and use.
- Comply with platform terms and applicable laws (e.g., GDPR/CCPA).
- Avoid personal/sensitive data and respect user privacy.
- Consult your legal team for edge cases in your jurisdiction.

### Input parameters & output format

#### Example JSON input
```json
{
  "urls": [
    "https://www.skool.com/discovery"
  ],
  "maxItems": 50,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
````

Parameter reference

| Parameter | Type | Required | Default | Description |
| --- | --- | --- | --- | --- |
| urls | array (stringList) | Yes | none | One or more Skool discovery page URLs to collect from. Each run walks the list and enriches groups with public profile-style details. |
| maxItems | integer | No | 100 | Cap of communities per discovery URL (1–500). Use a small number to preview or a higher number for a larger export. |
| proxyConfiguration | object | No | none (prefill shows useApifyProxy: false) | Optional Apify Proxy settings. Turn on if you want to route through Apify Proxy from the start; otherwise the actor handles connection hiccups automatically when possible. |

#### Example JSON output

```json
{
  "id": 123456,
  "name": "growth-hackers",
  "displayName": "Growth Hackers",
  "description": "Learn ethical growth tactics for SaaS.",
  "landingPageDescription": "Join us for weekly AMAs and workshops on acquisition, activation, and retention.",
  "supportEmail": "hello@growthhackers.io",
  "monthlyPrice": 49,
  "monthlyCurrency": "usd",
  "annualPrice": 490,
  "annualCurrency": "usd",
  "color": "#123ABC",
  "initials": "GH",
  "privacy": "public",
  "membership": "open",
  "plan": "pro",
  "landingPageAccessType": "open",
  "affiliatePercent": 0,
  "pluginAutoDmEnabled": 0,
  "pluginMinChatLevelEnabled": 0,
  "surveyEnabled": 0,
  "surveyQuestions": [],
  "surveyUpdatedAt": null,
  "logoUrl": "https://cdn.skool.com/.../logo-small.png",
  "logoBigUrl": "https://cdn.skool.com/.../logo-big.png",
  "coverSmallUrl": "https://cdn.skool.com/.../cover-small.jpg",
  "faviconUrl": "https://cdn.skool.com/.../favicon.ico",
  "customLinks": [],
  "totalMembers": 3127,
  "totalOnlineMembers": 214,
  "totalAdmins": 3,
  "totalPosts": 842,
  "totalRules": 5,
  "numCourses": 4,
  "numModules": 27,
  "audioChatVisible": true,
  "calendarVisible": true,
  "classroomVisible": true,
  "mapVisible": false,
  "landingPageAttachments": [
    {
      "id": "att_001",
      "type": "image",
      "imageFileId": "file_abc",
      "imageOriginalUrl": "https://cdn.skool.com/.../hero.png",
      "imageSmallUrl": "https://cdn.skool.com/.../hero_small.png",
      "imageBigUrl": "https://cdn.skool.com/.../hero_big.png",
      "videoId": null,
      "videoUrl": null,
      "videoThumbnailUrl": null
    }
  ],
  "ownerId": 98765,
  "ownerName": "Jane Doe",
  "ownerFirstName": "Jane",
  "ownerLastName": "Doe",
  "ownerBio": "Community builder and growth strategist.",
  "ownerLocation": "Austin, TX",
  "ownerDiscTop": null,
  "ownerActivityStatus": "active",
  "ownerMyersBriggs": null,
  "ownerOnline": true,
  "ownerLastOffline": null,
  "ownerPictureProfile": "https://cdn.skool.com/.../profile.jpg",
  "ownerPictureBubble": "https://cdn.skool.com/.../bubble.jpg",
  "ownerInstagram": "https://instagram.com/janedoe",
  "ownerYoutube": null,
  "ownerFacebook": null,
  "ownerTwitter": "https://twitter.com/janedoe",
  "ownerLinkedin": "https://www.linkedin.com/in/janedoe",
  "ownerWebsite": "https://janedoe.com",
  "ownerCreatedAt": "2023-01-15T12:34:56.000Z",
  "ownerUpdatedAt": "2026-02-20T09:12:00.000Z",
  "createdAt": "2024-05-10T08:00:00.000Z",
  "updatedAt": "2026-04-01T12:00:00.000Z",
  "createdBy": "system"
}
```

Notes:

- Fields may be null if not present on the public page (e.g., supportEmail, certain owner social links).
- Pricing fields are normalized; zero‑decimal currencies remain unscaled.

### FAQ

#### Do I need to log in to scrape Skool groups?

No. This Skool group scraper works without login or cookies by collecting data from public discovery and About pages.

#### What data does this actor collect?

It extracts structured group and owner metadata such as IDs, slugs, descriptions, pricing, member counts, owner profile fields, tab visibility flags, media attachments, and timestamps. It does not scrape private data, member lists, posts, or comments.

#### How many groups can I export per run?

You control this via “maxItems” (1–500) per discovery URL. You can add multiple discovery URLs; the actor de-duplicates groups across them.

#### Can I export results to CSV or JSON?

Yes. Open the Output dataset after the run and export to CSV, JSON, or Excel. This supports Skool group data export and downstream analysis.

#### Does it support proxies?

Yes. You can enable “proxyConfiguration” to use Apify Proxy from the start. If you leave it off, the actor applies a smart connection strategy that escalates routes when needed.

#### Is this suitable for automation workflows?

Yes. Results stream to an Apify dataset that you can pull via API for automated pipelines. It’s a solid base for Skool group scraping automation and “Skool API scraping”-style workflows using structured JSON.

#### Is it legal to scrape this data?

Yes, when done responsibly. The actor collects only publicly available information. You’re responsible for complying with Skool’s terms and relevant regulations.

#### Does it extract a Skool group member list?

No. This tool focuses on discovery and About-page enrichment (group metadata, pricing, owner details, and visibility/media fields). It does not export Skool group members or retrieve posts/comments.

### Final thoughts

The 🎓 Skool Group Scraper is built for structured, reliable Skool community discovery and About-page enrichment at scale. It delivers clean JSON rows with pricing, member counts, owner info, media, and visibility flags — streamed live to your dataset for fast Skool community data export. Whether you’re a marketer, developer, analyst, or researcher, use the Apify dataset and API to integrate results into dashboards, enrichment, or automation pipelines. Start extracting smarter insights from public Skool communities — quickly, accurately, and at scale.

# Actor input Schema

## `urls` (type: `array`):

✅ Add every discovery URL you want (one per line is fine). Example: the main Skool discovery page.

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

🎚️ Cap per discovery URL — keeps runs fast and predictable. Pick a smaller number to preview, or go higher for a big export.

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

👆 Turn **on** only if you want to run through **Apify Proxy** from the start. Leave **off** for the normal experience (we handle hiccups automatically when possible).

## Actor input object example

```json
{
  "urls": [
    "https://www.skool.com/discovery"
  ],
  "maxItems": 100,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# 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 = {
    "urls": [
        "https://www.skool.com/discovery"
    ],
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("scraper-engine/skool-group-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 = {
    "urls": ["https://www.skool.com/discovery"],
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("scraper-engine/skool-group-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 '{
  "urls": [
    "https://www.skool.com/discovery"
  ],
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call scraper-engine/skool-group-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "🎓 Skool Group Scraper",
        "description": "🎓 Skool Group Scraper extracts rich data from Skool groups — members, profiles, posts, comments, reactions, topics/events & engagement stats. 📊 Export CSV/JSON datasets for analysis or outreach. 🚀 Ideal for community insights, growth & lead gen.",
        "version": "1.0",
        "x-build-id": "M7gdIYJdqbISJFCnX"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scraper-engine~skool-group-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scraper-engine-skool-group-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/scraper-engine~skool-group-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scraper-engine-skool-group-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/scraper-engine~skool-group-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scraper-engine-skool-group-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",
                "required": [
                    "urls"
                ],
                "properties": {
                    "urls": {
                        "title": "🔗 Discovery page URLs",
                        "type": "array",
                        "description": "✅ Add every discovery URL you want (one per line is fine). Example: the main Skool discovery page.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxItems": {
                        "title": "🔢 How many communities max?",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "🎚️ Cap per discovery URL — keeps runs fast and predictable. Pick a smaller number to preview, or go higher for a big export.",
                        "default": 100
                    },
                    "proxyConfiguration": {
                        "title": "🔒 Proxy (optional)",
                        "type": "object",
                        "description": "👆 Turn **on** only if you want to run through **Apify Proxy** from the start. Leave **off** for the normal experience (we handle hiccups automatically when possible)."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
