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

🔎 Skool Group Community Infos Scraper pulls detailed Skool group data—members, categories, posts, engagement metrics, links & descriptions. 📊 Perfect for community analytics, market research, lead gen & competitive intel. ⚡ Fast, reliable, export-ready (CSV/JSON, API).

- **URL**: https://apify.com/scraper-engine/skool-group-community-infos-scrape.md
- **Developed by:** [Scraper Engine](https://apify.com/scraper-engine) (community)
- **Categories:** Developer tools, Lead generation, 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 Community Infos Scraper

Skool Group Community Infos Scraper collects structured data from public Skool group /about pages and outputs it to a live dataset for analysis and enrichment. It solves the manual copy-paste problem by extracting group metadata (including owner, tabs, survey, and engagement metrics) at scale for marketers, developers, data analysts, and researchers. With bulk input support and live, export-ready results, it enables community analytics, market research, lead generation, and competitive intelligence workflows at scale. 🚀

### What data / output can you get?

Below are examples of the structured fields this actor pushes to the dataset (one row per input URL or slug):

| Data type | Description | Example value |
| --- | --- | --- |
| slug | Group short name parsed from your input | "thatpickleballschool" |
| url | Normalized /about URL for the group | "https://www.skool.com/thatpickleballschool/about" |
| group_id | Internal Skool group ID | "123456" |
| group_name | Display name of the community | "That Pickleball School" |
| group_description | Cleaned description text from the group metadata | "Learn pickleball with pros. Weekly drills, community Q&A, and tournaments." |
| group_image | Best-guess group image (landing page or fallback logo/cover) | "https://cdn.skool.com/images/cover.jpg" |
| total_members | Member count reported by Skool | 2543 |
| total_posts | Total post count reported by Skool | 987 |
| privacy | Privacy setting from group metadata | "public" |
| tabs | Tabs configuration from group metadata | {"members":true,"courses":true,"calendar":false} |
| survey | Survey configuration from group metadata | {"welcome":{"questions":[{"type":"text","label":"How did you find us?"}]}} |
| owner_name | Convenience field derived from owner.name | "Jane Doe" |

Bonus fields you can also use:
- group_created_at, group_updated_at
- total_online_members, total_admins
- membership, num_courses, num_modules
- map_enabled
- owner (object with id, name, email, location, bio, picture_profile, created_at, updated_at)

Export your dataset to CSV, JSON, or Excel, or access it via the Apify API for downstream pipelines. 📤

### Key features

- ⚡ Direct-first fetching with smart fallback
  The actor tries a normal connection first for speed, then falls back to optional Apify Proxy (datacenter → residential) when needed. If residential succeeds, it sticks to it for the rest of the run.

- 📈 Batch scraping & bulk automation
  Provide multiple Skool group links or slugs in one run; each input becomes its own dataset row with live updates.

- 🧱 Structured JSON aligned to Skool data
  Extracts the same structured fields embedded in the page’s __NEXT_DATA__ payload, including tabs, survey, and owner blocks.

- 🔁 Resilient retries
  Controls per-request retry attempts on network hiccups via maxRetries, with incremental backoff and robust error handling.

- 🔒 Optional proxy ladder
  When proxyConfiguration is enabled, the actor prepares datacenter and residential proxy options as backup routes to reduce blocks.

- 👀 Live result streaming
  Rows are pushed to the dataset immediately as they’re collected, so you can watch progress in real time in the Output tab.

- 🚪 No login required
  Works on publicly accessible Skool /about pages only — no cookies or session management needed.

- 🧑‍💻 Developer-friendly
  Integrate outputs via the Apify API, connect to automation tools, and export in CSV/JSON for analytics or ETL workflows.

- 🧱 Production-ready reliability
  Built with aiohttp and robust parsing; detects blocked pages and gracefully reports errors when pages are unreachable.

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

1. Sign in to Apify
   Create or log into your Apify account to run the actor.

2. Open the actor
   Find “Skool Group Community Infos Scraper” in your workspace and click “Run”.

3. Add your inputs
   In the Input tab, paste Skool group links or slugs into urls. You can use:
   - Full links like https://www.skool.com/your-group/about
   - Slugs like your-group (short name only)

4. (Optional) Configure proxy
   Set proxyConfiguration if the site is slow or picky. When enabled, the actor will automatically attempt direct → datacenter → residential, and stick with a successful residential route for the remainder of the run.

5. (Optional) Tune retries
   Set maxRetries (default 3) to control how many times a single request is retried on network errors.

6. Start the run
   Click “Start”. The actor will queue your inputs and begin fetching. You’ll see logs indicating progress and fallback steps if needed.

7. Watch results live
   As each community is collected, a row appears in the Output dataset with slug, url, group_name, owner_name, and other fields. Errors are reported per row in error.

8. Export or integrate
   Download results as CSV/JSON/Excel from the dataset, or connect via the Apify API to feed your CRM, BI tools, or data pipelines.

Pro Tip: For larger batches or stricter sites, enable proxyConfiguration upfront — after a successful residential fetch, remaining inputs will use the same backup connection automatically.

### Use cases

| Use case name | Description |
| --- | --- |
| Community analytics for marketers | Aggregate group_name, total_members, and total_posts to profile audience size and engagement across niches. |
| Market research & competitive intel | Compare privacy, membership, tabs, and survey structures across competitors to map positioning and onboarding. |
| Lead generation & outreach | Enrich targets with owner_name and group_description, then export to CSV/JSON for CRM or email sequencing. |
| Academic research on online communities | Collect standardized metrics (total_members, total_posts) across public Skool groups for longitudinal studies. |
| Product strategy & UX benchmarking | Analyze tabs and survey patterns to understand how communities structure content and onboarding. |
| Automation & data pipelines (API) | Trigger runs programmatically and pull datasets via API for continuous enrichment workflows. |
| Vendor due diligence | Validate community legitimacy with group_id, group_created_at, owner metadata, and membership indicators. |

### Why choose Skool Group Community Infos Scraper?

This actor is built for precision, automation, and reliability — a focused Skool community scraper that scales to bulk workloads without brittle browser hacks.

- ✅ Accurate, structured fields aligned to Skool’s embedded JSON (__NEXT_DATA__)
- 🌍 Public-pages only, no login or cookies required for consistent operation
- 📊 Scales to batches with live row-level streaming into the dataset
- 🧑‍💻 Developer access via Apify API and export-ready CSV/JSON/Excel formats
- 🛡️ Optional proxy ladder (direct → datacenter → residential) with sticky residential after success
- 💰 Cost-effective: control network retry behavior with maxRetries to optimize runs
- 🔌 Easy integrations: export to analytics, CRMs, or automation platforms

Skool data scraper vs browser extensions: unlike unstable point-and-click tools, this actor runs on server-side infrastructure with robust error handling, consistent field names, and export-ready outputs.

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

Yes — when used responsibly. This actor targets only publicly available Skool group /about pages and does not access private or authenticated data.

Guidelines to follow:
- Scrape only public pages and avoid accessing private profiles or gated content.
- Respect Skool’s terms and applicable laws and regulations (e.g., GDPR, CCPA).
- Use the data for legitimate purposes (analytics, research) and avoid spam or misuse.
- Consult your legal team for edge cases or jurisdiction-specific requirements.

### Input parameters & output format

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

Parameter reference:

| Parameter | Type | Description | Default | Required |
| --- | --- | --- | --- | --- |
| urls | array | Paste Skool community/group links or slugs (one per line). Examples: “https://www.skool.com/your-group/about” or “your-group”. Bulk-friendly — each becomes a dataset row. | Not set | Yes |
| proxyConfiguration | object | Only if the site is slow or picky — turn this on for a smoother ride. When enabled, the actor tries the usual connection first, then extra options only if needed. | Not set | No |
| maxRetries | integer | How many times to retry a single request when the network hiccups (not when data is missing). Default is plenty for most runs. | 3 | No |

#### Example JSON output

Successful row:

```json
{
  "slug": "thatpickleballschool",
  "url": "https://www.skool.com/thatpickleballschool/about",
  "group_id": "123456",
  "group_name": "That Pickleball School",
  "group_description": "Learn pickleball with pros. Weekly drills, community Q&A, and tournaments.",
  "group_image": "https://cdn.skool.com/images/cover.jpg",
  "group_created_at": "2024-01-15T12:34:56.000Z",
  "group_updated_at": "2026-04-10T08:12:03.000Z",
  "total_members": 2543,
  "total_online_members": 87,
  "total_posts": 987,
  "total_admins": 3,
  "privacy": "public",
  "map_enabled": "N/A",
  "membership": "open",
  "num_courses": 4,
  "num_modules": 18,
  "tabs": {
    "members": true,
    "courses": true,
    "calendar": false
  },
  "survey": {
    "welcome": {
      "questions": [
        {
          "type": "text",
          "label": "How did you find us?"
        }
      ]
    }
  },
  "owner": {
    "id": "owner_789",
    "name": "Jane Doe",
    "email": "N/A",
    "location": "Austin, TX",
    "bio": "Coach and community lead.",
    "picture_profile": "https://cdn.skool.com/images/profile.jpg",
    "created_at": "2023-06-01T10:20:30.000Z",
    "updated_at": "2026-03-20T09:45:00.000Z"
  },
  "owner_name": "Jane Doe"
}
```

Error row (for an invalid or unreachable input):

```json
{
  "slug": "bad-input",
  "url": "",
  "group_name": "",
  "owner_name": "",
  "error": "bad URL or slug: invalid group slug: 'bad-input'"
}
```

Notes:

- On success, error is omitted.
- owner\_name is a convenience field derived from owner.name.
- Some fields may be absent or empty if not present in the page (e.g., tabs, survey, totals).
- map\_enabled is set to "N/A" by design.

### FAQ

#### Do I need to log in to use this scraper?

No. The actor works on publicly accessible Skool /about pages and does not require login, cookies, or session management.

#### What inputs are supported?

Provide Skool group /about URLs or slugs. Examples: “https://www.skool.com/your-group/about” or just “your-group”. Each input becomes a row in the Output dataset.

#### How does it handle blocking or slow pages?

By default, it tries a direct connection. If you enable proxyConfiguration, it prepares datacenter and residential proxy routes and falls back when necessary. After a successful residential fetch, remaining URLs use the same backup connection for the rest of the run.

#### What data fields are extracted?

It collects structured group metadata, including group\_id, group\_name, group\_description, group\_image, counts (total\_members, total\_posts, etc.), privacy, tabs, survey, and a detailed owner block (plus owner\_name for convenience). See the Output section for a full example.

#### Can I run it at scale with many URLs?

Yes. The urls input supports bulk lists, and the actor streams each result to the dataset as soon as it’s collected. Use maxRetries and optional proxies to improve reliability for large batches.

#### How can I export or integrate the results?

You can download the dataset as CSV, JSON, or Excel, or access it via the Apify API for automation and integration into CRMs, BI tools, or ETL pipelines.

#### What happens if a page can’t be reached?

The actor pushes a row with error describing the issue (e.g., “page not reachable — try optional proxy in input” or “couldn’t load after retries”). This ensures you always get per-input visibility.

#### Is this scraping legal?

Yes, when done responsibly. The actor targets public pages only. You are responsible for complying with Skool’s terms and applicable laws such as GDPR or CCPA.

### Closing CTA / Final thoughts

Skool Group Community Infos Scraper is built to turn public Skool community pages into clean, structured insights — fast. It delivers accurate metadata (including tabs, survey, and owner), supports bulk runs, and exports to CSV/JSON for marketers, developers, analysts, and researchers. Use the Apify API to automate enrichment pipelines or connect results to your analytics stack. Start extracting smarter, scalable community insights 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("scraper-engine/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("scraper-engine/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 scraper-engine/skool-group-community-infos-scrape --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=scraper-engine/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 Scraper pulls detailed Skool group data—members, categories, posts, engagement metrics, links & descriptions. 📊 Perfect for community analytics, market research, lead gen & competitive intel. ⚡ Fast, reliable, export-ready (CSV/JSON, API).",
        "version": "0.1",
        "x-build-id": "wSPEZWTHQy2TwPmSu"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scraper-engine~skool-group-community-infos-scrape/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scraper-engine-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/scraper-engine~skool-group-community-infos-scrape/runs": {
            "post": {
                "operationId": "runs-sync-scraper-engine-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/scraper-engine~skool-group-community-infos-scrape/run-sync": {
            "post": {
                "operationId": "run-sync-scraper-engine-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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```