# Skool Group Community Infos Scraper (`scrapier/skool-group-community-infos-scrape`) Actor

🔍 Skool Group Community Infos Scrape extracts rich data from Skool communities — names, bios, admins, members count, topics, posts & engagement. 📊 Export to CSV/JSON for research, marketing & growth. 🚀 Perfect for market intel, lead gen, and competitor analysis.

- **URL**: https://apify.com/scrapier/skool-group-community-infos-scrape.md
- **Developed by:** [Scrapier](https://apify.com/scrapier) (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 $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 Community Infos Scraper

Skool Group Community Infos Scraper is a focused Apify actor that collects structured data from public Skool group /about pages — delivering group info, owner profile, tabs, survey, and engagement metrics. It solves the manual, error-prone process of researching Skool communities by turning links into clean, analyzable records. Built for marketers, developers, analysts, and researchers, it streams results live to your dataset so you can monitor progress and export to CSV/JSON at scale.

### What data / output can you get?

Here are the core fields the actor saves to the dataset for each Skool community:

| Data type | Description | Example value |
| --- | --- | --- |
| slug | Group short name derived from input | adonis-gang |
| url | Normalized /about page URL | https://www.skool.com/adonis-gang/about |
| group_id | Internal group identifier | 123456 |
| group_name | Display name of the community | Adonis Gang |
| group_description | Cleaned “About” text | A private community for disciplined self-improvement. |
| group_image | Primary image or cover/logo fallback | https://cdn.skool.com/images/group-cover.jpg |
| group_created_at | Group creation timestamp | 2024-02-01T12:34:56.000Z |
| group_updated_at | Last update timestamp | 2024-04-15T09:00:00.000Z |
| total_members | Member count | 1240 |
| total_online_members | Online now | 86 |
| total_posts | Total posts in the community | 560 |
| total_admins | Admin count | 3 |
| privacy | Group privacy setting | public |
| membership | Membership type/mode | open |
| num_courses | Number of courses | 5 |
| num_modules | Number of modules | 28 |
| tabs | Parsed tabs metadata (object) | {"home": true, "classroom": true, "calendar": true} |
| survey | Parsed survey metadata (object) | {"enabled": true, "questions": [...] } |
| owner | Owner object with profile metadata | {"id":"u_987","name":"John Doe",...} |
| owner_name | Owner’s display name (for table view) | John Doe |
| error | Error message if collection failed | couldn’t load after retries |

Notes:
- Results stream live to the Apify dataset as each community is processed.
- Export your dataset to CSV or JSON from the Apify console or via API.

### Key features

- 🧠 Accurate data parsing from __NEXT_DATA__
  Extracts Skool’s embedded JSON payload for clean, structured fields (group info, tabs, survey, owner) without brittle HTML scraping.

- 🔓 Public-only, no login required
  Works on publicly available Skool group /about pages — no cookies or authentication needed.

- 🔄 Smart connection handling with proxy ladder
  Tries direct connection first; if blocked, automatically falls back to datacenter and then residential proxies (with retries). After a successful residential fetch, the actor switches to residential-only for the rest of the run.

- 📥 Live, row-by-row output
  Saves each community immediately using Actor.push_data so you can watch the Output table populate in real time.

- 📦 Bulk-friendly input
  Paste multiple links or slugs — each entry becomes a new dataset row. Ideal for large research lists.

- ♻️ Resilient retries
  Adjustable retry logic via maxRetries for handling transient network issues.

- 🧑‍💻 Developer-ready on Apify
  Results are stored in an Apify dataset for easy programmatic access and CSV/JSON export through the platform.

- 🪶 Lightweight & fast
  Uses efficient HTTP requests (no headless browser), tuned headers, and backoff for stable performance.

### How to use Skool Group Community Infos Scraper - step by step

1. Create or log in to your Apify account.
2. Open the Skool Group Community Infos Scraper actor.
3. Add your input:
   - In urls, paste one Skool group per line. You can use either:
     - Full URL: https://www.skool.com/your-group/about
     - Slug only: your-group
4. (Optional) Configure proxyConfiguration:
   - Enable useApifyProxy if pages are slow or blocking. The actor will still try direct first, then datacenter, then residential automatically when needed.
5. (Optional) Set maxRetries to control per-request retry attempts on network hiccups (default 3).
6. Start the run. Rows will appear live in the Output tab as each community is collected.
7. Export results from the dataset as CSV or JSON, or fetch them via the Apify API.

Pro tip: Schedule runs or chain this dataset into downstream automations via the Apify API to keep your Skool community snapshots fresh.

### Use cases

| Use case name | Description |
| --- | --- |
| Market research + benchmarking | Analyze competitor communities by tracking member counts, activity (total_posts), and privacy/membership settings. |
| Lead generation + outreach | Enrich target lists with group_name, owner_name, and descriptive context from group_description for tailored messaging. |
| Community ops + growth | Monitor total_members and total_posts across multiple groups to identify engagement trends and opportunities. |
| Academic & social research | Collect structured, public community data (privacy, tabs, survey) for longitudinal studies or datasets. |
| Data enrichment pipelines (API) | Feed the dataset into your ETL to merge Skool community insights with CRM or analytics systems. |
| Product discovery & topic mapping | Use tabs and survey structures to map topics and onboarding patterns across niches. |

### Why choose Skool Group Community Infos Scraper?

Built for precision, reliability, and scale, this actor turns public Skool group pages into structured, analytics-ready data.

- ✅ Accuracy-first parsing: Reads Skool’s __NEXT_DATA__ to capture fields consistently.
- 🔁 Robust connection strategy: Direct → datacenter → residential with retries and sticky residential mode for stability.
- 🚀 Bulk at scale: Paste many URLs or slugs; rows stream in live as they’re saved.
- 🧑‍💻 Developer-friendly: Results land in an Apify dataset for straightforward CSV/JSON export and API access.
- 🔒 Safe by design: Targets public /about pages only — no login or cookies.
- 💸 Efficient operations: Lightweight HTTP client, tuned headers, and backoff for reliable runs.
- 🧱 Production-ready: Error notes are included in the error field so you can triage edge cases fast.

Summary: a stable, no-login Skool community scraper that returns the fields you need — without the maintenance headaches of fragile alternatives.

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

Yes — when used responsibly. This actor is designed for public Skool group /about pages only and does not access private or authenticated content.

Guidelines:
- Collect only publicly available information.
- Respect Skool’s terms of service and applicable laws in your jurisdiction.
- Avoid using the data for spam or abusive practices.
- For edge cases or regulated use, consult your legal team.

### Input parameters & output format

Example JSON input
```json
{
  "urls": [
    "https://www.skool.com/thatpickleballschool/about",
    "adonis-gang"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true
  },
  "maxRetries": 3
}
````

All input fields:

- urls (array, required)
  - Description: Paste Skool community/group links (one per line). Accepts full /about URLs or slugs.
  - Default: none
- proxyConfiguration (object, optional)
  - Description: Only if the site is slow or picky — enable to use Apify Proxy as a fallback. The actor tries the usual connection first, then extra options only if needed.
  - Default: useApifyProxy prefilled to false in UI (no proxy by default)
- maxRetries (integer, optional)
  - Description: How many times to retry a single request when the network hiccups (not when data is missing).
  - Default: 3
  - Min/Max: 0–10

Example JSON output

```json
[
  {
    "slug": "adonis-gang",
    "url": "https://www.skool.com/adonis-gang/about",
    "group_id": "123456",
    "group_name": "Adonis Gang",
    "group_description": "A private community for disciplined self-improvement.",
    "group_image": "https://cdn.skool.com/images/group-cover.jpg",
    "group_created_at": "2024-02-01T12:34:56.000Z",
    "group_updated_at": "2024-04-15T09:00:00.000Z",
    "total_members": 1240,
    "total_online_members": 86,
    "total_posts": 560,
    "total_admins": 3,
    "privacy": "public",
    "map_enabled": "N/A",
    "membership": "open",
    "num_courses": 5,
    "num_modules": 28,
    "tabs": {
      "home": true,
      "classroom": true,
      "calendar": true
    },
    "survey": {
      "enabled": true,
      "questions": ["What brings you here?"]
    },
    "owner": {
      "id": "u_987",
      "name": "John Doe",
      "email": "N/A",
      "location": "USA",
      "bio": "Community builder",
      "picture_profile": "https://cdn.skool.com/avatars/john.jpg",
      "created_at": "2023-05-10T10:00:00.000Z",
      "updated_at": "2024-04-10T10:00:00.000Z"
    },
    "owner_name": "John Doe"
  },
  {
    "slug": "invalid-input",
    "url": "",
    "group_name": "",
    "owner_name": "",
    "error": "bad URL or slug: invalid group slug: 'invalid-input/'"
  }
]
```

Notes:

- On failures, error contains a human-readable message and other fields may be empty.
- When data is missing upstream, some fields (e.g., owner.email) may return "N/A" or empty strings as shown in the code.

### FAQ

#### Do I need to log in or provide cookies to use this scraper?

No. The actor targets public Skool group /about pages and does not require login or cookies. It uses standard HTTP requests with tuned headers.

#### What input formats are supported for communities?

You can paste either full /about URLs (e.g., https://www.skool.com/your-group/about) or just the slug (e.g., your-group). The actor normalizes both to the correct /about page.

#### What data fields are returned?

Each dataset row includes slug, url, group\_name, group\_id, group\_description, group\_image, timestamps, totals (members, posts, admins, online), privacy, membership, tabs, survey, owner (object), and a convenience owner\_name field. If a page can’t be collected, error is set.

#### How does it handle blocked or hard-to-reach pages?

It tries direct first. If you enable proxyConfiguration with useApifyProxy, it can fall back to datacenter and then residential proxies (with retries). After a successful residential attempt, it sticks with residential for the rest of the run.

#### How many communities can I run at once?

The input is bulk-friendly — add as many links or slugs as you need. The actor processes them sequentially with short delays and streams each result to the dataset as soon as it’s saved.

#### Can I access the results programmatically?

Yes. Results are written to an Apify dataset, so you can download CSV/JSON from the console or fetch them via the Apify API for downstream automation.

#### What happens when a line is invalid or a page is unreachable?

The actor still pushes a row with slug (or a placeholder), empty core fields, and an error message (e.g., bad URL or slug, page not reachable, couldn’t load after retries). This helps you audit inputs and connectivity.

#### Does it scrape private or members-only content?

No. It’s built for publicly available /about pages only. It won’t access private content or require authentication.

### Closing CTA / Final thoughts

Skool Group Community Infos Scraper is built to turn public Skool group /about pages into clean, structured community insights — fast. Paste your list, run once, and export a dataset with names, bios, owners, tabs, surveys, and engagement metrics.

Whether you’re a marketer, analyst, researcher, or developer, you’ll get reliable CSV/JSON output and live-progress visibility. Developers can plug the Apify dataset into existing pipelines via API for automated enrichment. Start extracting smarter Skool community insights at scale today.

# Actor input Schema

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

📝 Paste **Skool community / group links** (one per line).

**Examples:**
• `https://www.skool.com/your-group/about`
• `your-group` (short name only)

✅ **Bulk friendly** — add as many as you need; each one becomes its own row in the output table.

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

🌐 **Only if the site is slow or picky** — turn this on for a smoother ride. Leave off for the simplest setup.

🔁 When enabled, the actor tries the usual connection first, then extra options only if needed.

## `maxRetries` (type: `integer`):

⏱️ How many times to retry a single request when the network hiccups (not when data is missing). **Default is plenty for most runs.**

## Actor input object example

```json
{
  "urls": [
    "https://www.skool.com/thatpickleballschool/about",
    "https://www.skool.com/adonis-gang/about"
  ],
  "proxyConfiguration": {
    "useApifyProxy": false
  },
  "maxRetries": 3
}
```

# 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/thatpickleballschool/about",
        "https://www.skool.com/adonis-gang/about"
    ],
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapier/skool-group-community-infos-scrape").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/thatpickleballschool/about",
        "https://www.skool.com/adonis-gang/about",
    ],
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("scrapier/skool-group-community-infos-scrape").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/thatpickleballschool/about",
    "https://www.skool.com/adonis-gang/about"
  ],
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call scrapier/skool-group-community-infos-scrape --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Skool Group Community Infos Scraper",
        "description": "🔍 Skool Group Community Infos Scrape extracts rich data from Skool communities — names, bios, admins, members count, topics, posts & engagement. 📊 Export to CSV/JSON for research, marketing & growth. 🚀 Perfect for market intel, lead gen, and competitor analysis.",
        "version": "0.1",
        "x-build-id": "Kp35FyTTE7jmPUOcw"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapier~skool-group-community-infos-scrape/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapier-skool-group-community-infos-scrape",
                "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-community-infos-scrape/runs": {
            "post": {
                "operationId": "runs-sync-scrapier-skool-group-community-infos-scrape",
                "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-community-infos-scrape/run-sync": {
            "post": {
                "operationId": "run-sync-scrapier-skool-group-community-infos-scrape",
                "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": "🔗 Community links to collect",
                        "type": "array",
                        "description": "📝 Paste **Skool community / group links** (one per line).\n\n**Examples:**\n• `https://www.skool.com/your-group/about`\n• `your-group` (short name only)\n\n✅ **Bulk friendly** — add as many as you need; each one becomes its own row in the output table.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "proxyConfiguration": {
                        "title": "🛡️ Proxy (optional)",
                        "type": "object",
                        "description": "🌐 **Only if the site is slow or picky** — turn this on for a smoother ride. Leave off for the simplest setup.\n\n🔁 When enabled, the actor tries the usual connection first, then extra options only if needed."
                    },
                    "maxRetries": {
                        "title": "🔁 Retry attempts",
                        "minimum": 0,
                        "maximum": 10,
                        "type": "integer",
                        "description": "⏱️ How many times to retry a single request when the network hiccups (not when data is missing). **Default is plenty for most runs.**",
                        "default": 3
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```