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

🎓 Skool Group Scraper extracts public data from Skool communities—members, posts, topics, reactions & links—into clean CSV/JSON. 🔎 Perfect for community research, outreach, competitive analysis & content strategy. ⚡ Fast, reliable, API-ready.

- **URL**: https://apify.com/scrapier/skool-group-scraper.md
- **Developed by:** [Scrapier](https://apify.com/scrapier) (community)
- **Categories:** Developer tools, Lead generation, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $5.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 focused Skool community scraper that discovers groups from Skool discovery pages, enriches each with public About details (owner profile, landing-page copy, tabs visibility, media attachments), and streams results live to your Apify dataset. It solves the manual research problem by turning discovery browsing into a structured Skool group data extractor that outputs clean CSV/JSON for analysis, outreach, and reporting. Built for marketers, developers, data analysts, and researchers, this Skool group scraping bot enables repeatable, large-scale discovery and Skool group members export (member counts) without logins or extensions.

### What data / output can you get?

| Data field | Description | Example value |
| --- | --- | --- |
| id | Unique group ID | 123456 |
| name | Group slug used in URLs | marketing-mastery |
| displayName | Public display name of the group | Marketing Mastery |
| description | Short group description from discovery | Learn modern marketing… |
| monthlyPrice | Monthly membership price (normalized) | 49 |
| annualPrice | Annual membership price (normalized) | 490 |
| monthlyCurrency | ISO currency (lowercase) | usd |
| annualCurrency | ISO currency (lowercase) | usd |
| totalMembers | Total members count (public) | 1250 |
| ownerName | Group owner full name | Alex Johnson |
| ownerLocation | Owner location (if provided) | Austin, TX |
| landingPageAccessType | Access type for landing page | open |

Bonus fields include landingPageDescription, tabs visibility (audioChatVisible, calendarVisible, classroomVisible, mapVisible), logoUrl/coverSmallUrl/faviconUrl, landingPageAttachments with image/video URLs, granular owner metadata (bio, social links, pictures), and createdAt/updatedAt timestamps. Export your dataset in CSV, JSON, or Excel directly from Apify.

### Key features

- ⚡️ Bold discovery + About enrichment  
  Combines Skool discovery results with public About-page details for each group, yielding rich, structured records.

- 🔁 Live, streaming saves  
  Results are pushed to the dataset as each group finishes enrichment, so you can monitor progress in real time.

- 🧭 Resilient connection with smart proxy ladder  
  Starts direct by default and automatically escalates to datacenter/residential routes when needed. Or use your Apify Proxy from the start.

- 🔒 No login required  
  Works entirely with publicly available Skool pages—no cookies, sessions, or credentials.

- 🧰 Developer friendly & API-ready  
  Integrate via Apify API/SDK from your Skool group scraper Python scripts or automation pipelines. Ideal for data workflows and orchestration.

- 📦 Clean exports for analytics  
  Download your Skool community data export to CSV/JSON/Excel and feed BI tools, CRMs, or data warehouses.

- 🔁 Duplicate-safe across discovery pages  
  De-duplicates by group ID so you never save the same community twice in one run.

- 🧮 Accurate price normalization  
  Handles zero-decimal currencies and converts amounts to major units for consistent monthly/annual fields.

- 🛠️ Production-ready infrastructure  
  Built with Playwright on Apify for reliable, headless operation at scale—perfect for a Skool group automation tool.

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

1. Create or log in to your Apify account.
2. Open the Skool Group Scraper on Apify and click “Run”.
3. Paste your Discovery page URLs into the urls field (one or more Skool discovery links, such as https://www.skool.com/discovery).
4. Set maxItems to control how many communities to collect per discovery URL (default 100).
5. (Optional) Expand proxyConfiguration if you want to use Apify Proxy from the start; otherwise leave it off and the actor will auto-adjust if needed.
6. Start the run. The actor loads each discovery page, gathers groups, enriches About details, and streams rows to the Output dataset as they finish.
7. Export the finished dataset as CSV, JSON, or Excel for analysis and sharing.

Pro tip: Orchestrate runs via the Apify API and connect your Skool group export to CSV into Make.com, n8n, Zapier, or your Skool members extractor Python scripts for end-to-end automation.

### Use cases

| Use case | Description |
| --- | --- |
| Market research + benchmarking | Aggregate public group counts, pricing, and owner details to compare niches and track positioning trends. |
| Competitive analysis for communities | Map competing Skool communities with totalMembers and pricing to inform content and growth strategy. |
| Outreach & lead targeting | Build lists of groups (with ownerName, supportEmail when present, and landingPageDescription context) for targeted outreach. |
| Content strategy & partnerships | Identify collaboration opportunities by scanning descriptions, tabs visibility, and media attachments. |
| Academic & social research | Collect structured community-level metrics for longitudinal analyses without manual copy-paste. |
| Data engineering pipeline (API) | Automate discovery and export structured JSON to downstream apps or warehouses on a schedule. |

### Why choose 🎓 Skool Group Scraper?

This Skool group scraper tool focuses on precision, reliability, and clean data for automation-ready exports.

- 🎯 Accurate, structured fields: Normalized pricing, member counts, owner metadata, and media attachments.
- 🔄 Real-time streaming: Monitor progress as rows land in your dataset—no waiting for the entire run.
- 📈 Scales with your workflow: Control scope via maxItems and run across multiple discovery URLs.
- 💻 Built for developers: Use the Apify API/SDK from your Skool group scraper Python or JS pipelines.
- 🛡️ Public-only data: Designed for publicly available pages with no login or private data access.
- 💰 Cost-effective operations: Tune limits and concurrency for quick previews or large exports.
- 🧪 Better than extensions: Headless, server-side Playwright scraping is more stable than browser add-ons for a Skool group scraping bot.
- 🌐 Smart proxy handling: Optional user proxy with automatic laddering to handle picky routes.

In short: a resilient Skool community scraper that delivers structured results you can trust.

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

Yes—when done responsibly. This actor collects only publicly available information from Skool discovery and group About pages. It does not log in or access private data.

Guidelines for compliant use:
- Scrape only public pages you’re permitted to access and respect Skool’s terms.
- Avoid collecting or processing personal data beyond what is publicly provided by owners.
- Ensure your use complies with applicable regulations (e.g., GDPR, CCPA).
- Use the data for legitimate purposes (analysis, research) and avoid spam.
- When in doubt, consult your legal team for your specific use case.

### Input parameters & output format

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

Parameter reference:

- urls (array, required) — Paste one or more Skool discovery links. Each run walks the list, finds communities, and enriches them with public profile-style details. Default: none.
- maxItems (integer, optional) — Cap per discovery URL to keep runs fast and predictable. Minimum 1, maximum 500. Default: 100.
- proxyConfiguration (object, optional) — Turn on only if you want to run through Apify Proxy from the start. Prefill: {"useApifyProxy": false}.

#### Example JSON output

```json
[
  {
    "id": 123456,
    "name": "marketing-mastery",
    "displayName": "Marketing Mastery",
    "description": "Learn modern marketing in a community of practitioners.",
    "landingPageDescription": "Join Marketing Mastery to level up your skills with workshops, templates, and peer feedback.",
    "supportEmail": "support@marketingmastery.com",
    "monthlyPrice": 49,
    "monthlyCurrency": "usd",
    "annualPrice": 490,
    "annualCurrency": "usd",
    "color": "#FF6A00",
    "initials": "MM",
    "privacy": "public",
    "membership": "paid",
    "plan": "pro",
    "landingPageAccessType": "open",
    "affiliatePercent": 0,
    "pluginAutoDmEnabled": 0,
    "pluginMinChatLevelEnabled": 0,
    "surveyEnabled": 0,
    "surveyQuestions": [],
    "surveyUpdatedAt": null,
    "logoUrl": "https://cdn.skool.com/logo.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": 1250,
    "totalOnlineMembers": 78,
    "totalAdmins": 3,
    "totalPosts": 1420,
    "totalRules": 5,
    "numCourses": 4,
    "numModules": 22,
    "audioChatVisible": true,
    "calendarVisible": true,
    "classroomVisible": true,
    "mapVisible": false,
    "landingPageAttachments": [
      {
        "id": 1,
        "type": "image",
        "imageFileId": "file_abc123",
        "imageOriginalUrl": "https://cdn.skool.com/attachments/hero.jpg",
        "imageSmallUrl": "https://cdn.skool.com/attachments/hero-small.jpg",
        "imageBigUrl": "https://cdn.skool.com/attachments/hero-big.jpg",
        "videoId": null,
        "videoUrl": null,
        "videoThumbnailUrl": null
      }
    ],
    "ownerId": 98765,
    "ownerName": "Alex Johnson",
    "ownerFirstName": "Alex",
    "ownerLastName": "Johnson",
    "ownerBio": "Founder of Marketing Mastery.",
    "ownerLocation": "Austin, TX",
    "ownerDiscTop": null,
    "ownerActivityStatus": "active",
    "ownerMyersBriggs": null,
    "ownerOnline": false,
    "ownerLastOffline": "1714068000",
    "ownerPictureProfile": "https://cdn.skool.com/owners/alex/profile.jpg",
    "ownerPictureBubble": "https://cdn.skool.com/owners/alex/bubble.jpg",
    "ownerInstagram": "https://instagram.com/alex",
    "ownerYoutube": null,
    "ownerFacebook": null,
    "ownerTwitter": "https://twitter.com/alex",
    "ownerLinkedin": "https://linkedin.com/in/alex",
    "ownerWebsite": "https://alexjohnson.com",
    "ownerCreatedAt": "2020-05-01T12:00:00.000Z",
    "ownerUpdatedAt": "2026-04-01T12:00:00.000Z",
    "createdAt": "2021-01-10T08:00:00.000Z",
    "updatedAt": "2026-04-26T18:30:00.000Z",
    "createdBy": "system"
  }
]
```

Notes:

- Rows are pushed as they finish, so your dataset updates live during the run.
- Many owner- and media-related fields may be null if not publicly provided on the group’s About page.

### FAQ

#### Does this scrape group members or only group-level data?

✅ It extracts group-level data (e.g., totalMembers, pricing, owner metadata, tabs visibility, attachments) from discovery and About pages. It does not scrape individual member lists.

#### Do I need to log in or provide cookies?

❌ No. The actor accesses only publicly available discovery and About pages and does not require authentication.

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

✅ Yes. Open the run’s Dataset on Apify and export your Skool group export to CSV, JSON, or Excel with one click.

#### How many communities can I collect per run?

📈 Control this with maxItems, which caps the number of groups per discovery URL (default 100, min 1, max 500). Add multiple discovery URLs to expand coverage.

#### Does it support proxies?

🌐 Yes. By default it starts direct and will automatically switch routes if needed. You can also enable proxyConfiguration to use Apify Proxy from the start.

#### Can I integrate this with my Python scripts or API workflows?

💻 Absolutely. Access the dataset and run results via the Apify API/SDK, making it easy to build a Skool group scraper Python pipeline or connect to automation tools.

#### What discovery URLs are supported?

🔗 Provide one or more Skool discovery links in urls (e.g., the main Skool discovery page). The actor walks these, collects communities, and enriches them via each group’s About page.

#### Is scraping Skool communities legal?

🛡️ Yes—when you only collect public data and follow Skool’s terms and relevant regulations. Users are responsible for compliant usage in their jurisdiction.

### Final thoughts

The 🎓 Skool Group Scraper is built to turn Skool discovery browsing into structured, reliable datasets. It streams enriched group records—pricing, member counts, owner details, tabs, media—into clean CSV/JSON for research, outreach, and analytics. Whether you’re a marketer, researcher, or developer, you can automate discovery and Skool community data export at scale. Use the Apify API/SDK to plug this Skool group automation tool into your pipelines and start extracting smarter community insights today.

# 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": 10,
  "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("scrapier/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("scrapier/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 scrapier/skool-group-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=scrapier/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 public data from Skool communities—members, posts, topics, reactions & links—into clean CSV/JSON. 🔎 Perfect for community research, outreach, competitive analysis & content strategy. ⚡ Fast, reliable, API-ready.",
        "version": "1.0",
        "x-build-id": "1Ce4PRC8Lr9HlJb62"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapier~skool-group-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapier-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/scrapier~skool-group-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scrapier-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/scrapier~skool-group-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scrapier-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": 5000,
                        "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": 10
                    },
                    "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
