# Skool Community Scraper (`crustapi/skool-community-scraper`) Actor

Extract data from thousands of Skool.com communities, including owner names, emails, social links, pricing, member counts, course stats, and landing page copy. Export data, run via API, schedule and monitor runs, or integrate with other tools.

- **URL**: https://apify.com/crustapi/skool-community-scraper.md
- **Developed by:** [Crust](https://apify.com/crustapi) (community)
- **Categories:** AI, Agents, Lead generation
- **Stats:** 5 total users, 4 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

### What is Skool Community Scraper?

This tool is designed to **extract data from communities on Skool.com**. Use this scraper to find Skool communities by keyword, category, or URL, and pull every public detail about the community and its owner.

With Skool Community Scraper, you can:

- 🔍 Discover Skool communities **automatically** across all 10 Skool categories
- 🗺️ Scrape **up to 20,000+ communities** in a single run, not just the ones you already know
- 🧑‍💼 Extract **owner profiles** including name, bio, location, email, and all social links
- 💰 Get **pricing data**: monthly price, annual price, currency, and free/paid status
- 📊 Collect **member, post, course, and module counts** for every community
- 📝 Pull **full landing page copy**: headlines, descriptions, CTAs, and custom links
- 🔑 Access data **without logging in**: no Skool account needed
- 📦 Export data as **JSON, CSV, Excel, HTML, or XML**
- 🔗 Integrate via **API, webhooks, Zapier, Make, Google Sheets**, or any Apify integration

### What Skool data can I extract?

With this Skool Scraper, you can extract the following data from any public community on Skool.com:

| | |
|---|---|
| 🏷️ Community name and slug | 🌐 Community URL |
| 📝 Description and landing page copy | 🎨 Logo, cover image, and brand color |
| 👥 Total members and online members | 📈 Total posts and admin count |
| 📚 Course and module counts | 🔐 Privacy and membership type |
| 💲 Monthly price and annual price | 💱 Currency |
| 📧 Support email | 🔗 Custom external links |
| 👤 Owner first and last name | 🆔 Owner username and profile URL |
| 📖 Owner bio and location | 🖼️ Owner profile picture |
| 📸 Instagram profile link | 🐦 Twitter / X profile link |
| 💼 LinkedIn profile link | 📘 Facebook profile link |
| ▶️ YouTube channel link | 🌍 Personal website link |
| 📅 Community creation date | 🔄 Last updated date |
| 🏆 Discovery rank | 📂 Category |

### How much does scraping Skool communities cost?

Scraping Skool communities costs **$3.70 for every 1,000 communities**, or about **$0.0037 per community**. You also pay a small Apify platform compute fee on top of that.

| What you're scraping | Actor cost | Estimated total |
|---|---|---|
| 100 communities (test run) | $0.37 | Under $1 |
| Top ~10,000 (all categories) | $37 | ~$40 |
| Full platform scan (15K to 20K+) | $55 to $74 | ~$60–80 |

If you're on the Apify Free plan, you can scrape a few thousand communities before needing to upgrade. Higher Apify subscription tiers get discounted compute rates automatically.

### How to use Skool Community Scraper?

Skool Community Scraper is easy to use, even if you've never scraped data from the web before:

1. [Create a free Apify account](https://console.apify.com/sign-up).
2. Go to **Skool Community Scraper** in the Apify Store.
3. On the **Input** tab, enter search keywords, or leave the defaults to scrape top-ranked communities across all categories.
4. *(Optional)* Set the **Max communities** field to cap how many communities you want.
5. *(Optional)* Enable or disable **Include owner details** depending on whether you need owner profiles.
6. Click **Start** and wait for the scraper to finish.
7. Download the results as JSON, CSV, Excel, or XML.

### 📥 Input

Skool Community Scraper supports the following types of input:

#### Search by keyword

Use the **Search for communities by keyword** field to find communities by topic. Each keyword returns up to 1,000 matching communities. For example:

````

marketing
real estate
AI automation
coaching

```

You can combine multiple keywords in the same run to cover broader topics.

#### Scrape top-ranked communities (default)

Leave both the search and URL fields empty. The scraper will automatically paginate through all 10 Skool categories (Money, Tech, Health, Sports, Self-improvement, Relationships, Hobbies, Music, Spirituality, and All) and return the top communities in each.

#### Scrape specific communities by name or URL

Open the **Advanced** section and paste community names or full URLs into the **Specific community URLs or names** field. The scraper accepts any of these formats:

```

skoolers
https://www.skool.com/ai-automation-society
https://www.skool.com/hormozi/about

````

#### Max communities

Set **Max communities to scrape** to control how many results you want. Use `0` for unlimited. We recommend starting with `50` or `100` to preview your data before a full scan.

#### Include owner details

Enable this to visit each community's about page and extract the owner's name, bio, email, social links, course count, and full landing page copy. Disable it for a faster scan with basic community data only.

### 📤 Output sample

The results are saved to a dataset. You can find them on the **Output** tab of the actor run, and export them to JSON, CSV, Excel, XML, or HTML.

The Overview table view is ordered Apollo-style: Community Name, URL, Description, Members, Pricing, Owner Name, Owner Profile, Email, Bio, Socials, Stats, Category, and Rank.

### 📘 Extracted Skool community sample

Here's an example JSON output for a single scraped community:

```json
{
    "id": "e44528d24bfe4d65b0a412441feaa489",
    "name": "skoolers",
    "displayName": "Skoolers",
    "description": "Private club for Skool owners. Let's build communities together.",
    "landingPageDescription": "Imagine a place where top community builders hang out and share what works...",
    "communityUrl": "https://www.skool.com/skoolers",
    "supportEmail": "sam@skool.com",
    "monthlyPrice": null,
    "annualPrice": null,
    "monthlyCurrency": null,
    "totalMembers": 184608,
    "totalOnlineMembers": 1854,
    "totalAdmins": 12,
    "totalPosts": 79502,
    "numCourses": 4,
    "numModules": 61,
    "privacy": 1,
    "membership": 1,
    "discoveryRank": 5,
    "category": "All",
    "customLinks": [
        {"url": "https://example.com", "label": "Join our Discord"}
    ],
    "calendarVisible": true,
    "classroomVisible": true,
    "logoUrl": "https://assets.skool.com/f/...",
    "coverSmallUrl": "https://assets.skool.com/f/...",
    "ownerId": "59e737d659f24e69a3810c6191054efd",
    "ownerName": "sam",
    "ownerFirstName": "Sam",
    "ownerLastName": "Ovens",
    "ownerBio": "CEO @ Skool",
    "ownerLocation": "Los Angeles, CA",
    "ownerPictureProfile": "https://assets.skool.com/f/...",
    "ownerProfileUrl": "https://www.skool.com/u/sam",
    "ownerInstagram": null,
    "ownerYoutube": "https://www.youtube.com/@skool-news",
    "ownerFacebook": null,
    "ownerTwitter": null,
    "ownerLinkedin": null,
    "ownerWebsite": null,
    "createdAt": "2019-12-04T04:52:35.870973Z",
    "updatedAt": "2025-10-30T12:16:04.043493Z"
}
````

### 🧑‍💼 Who uses Skool Community Scraper?

- **Agency owners.** Find every Skool community in your niche. See who's charging what, how many members they have, and grab the owner's contact info for cold outreach.
- **Course creators.** Research what top communities offer, what they charge, and reverse-engineer their landing page copy.
- **Lead generation teams.** Export owner names, emails, bios, and social profiles for thousands of community leaders. Plug straight into your outreach stack.
- **Growth marketers.** Identify high-growth communities, pricing trends, and underserved niches before your competitors do.
- **Investors and analysts.** Track the Skool ecosystem at scale. 200,000+ communities, 25M+ members, and growing fast.

### ❓ FAQ

#### Is it legal to scrape Skool communities?

Yes. We only extract publicly visible data from Skool community pages. No login is required and no private data is accessed. For more information, see Apify's blog posts on the [legality of web scraping](https://blog.apify.com/is-web-scraping-legal/) and [ethical scraping](https://blog.apify.com/web-scraping-ethics/).

#### Do I need a Skool account to use this scraper?

No. Everything is scraped from public Skool pages. You don't need to log in or provide any credentials.

#### How many communities are on Skool?

As of 2026, Skool hosts 200,000+ communities serving 25M+ members, per Skool's founder. Our deep scan surfaces up to 20,000+ of the most active, publicly discoverable communities.

#### How is this different from other Skool scrapers?

Most Skool scrapers require you to paste in community URLs you already have. This scraper **discovers communities for you** by scanning all 10 Skool categories and running keyword search expansion. It finds communities ranked up to #57,000+ that are invisible on the discovery page, and extracts 45 data fields per community including full landing page copy.

#### Can I schedule recurring scrapes?

Yes. Use Apify's built-in scheduler for daily, weekly, or monthly runs. This is great for tracking community growth, pricing changes, and new launches over time.

#### Will I get the same communities if I run the scraper twice?

Mostly, yes. Skool's discovery rankings are stable day to day, so a "top 100" run today will look about 95% the same tomorrow. The good news: every re-run refreshes the data on those communities (member counts, pricing, owner info, posts), which is great for tracking growth over time. If you want fresh communities each run, add search keywords or scrape a larger pool.

#### What if a community is private or deleted?

The scraper skips it and continues. You'll never get a broken run or partial data.

#### Can I export Skool data using the API?

Yes. You can access the scraped data through the Apify API. The API is organized around RESTful HTTP endpoints that let you manage, schedule, and run Apify actors and programmatically access datasets. For details, see the [Apify API docs](https://docs.apify.com/api/v2).

#### Does Skool Community Scraper integrate with other services?

Yes. You can connect Skool Community Scraper with almost any cloud service or web app. For example, integrate with Make, Zapier, Slack, Airbyte, GitHub, Google Sheets, Google Drive, and more. You can also use webhooks to perform an action whenever an event occurs, for example to get a notification once a run successfully finishes.

#### Skool Community Scraper not working?

We're always working on improving the performance of this actor. If you have technical feedback or found a bug, create an issue on the actor's **Issues** tab and we'll look into it.

***

Built by CrustAPI

⭐ If this scraper saved you time, leave a review. It helps more people find it.

# Actor input Schema

## `searchTerms` (type: `array`):

Search Skool for communities matching these keywords. Each keyword returns up to 1,000 matching communities. Leave empty to scrape top-ranked communities from all categories instead.

## `maxCommunities` (type: `integer`):

How many communities to scrape. Set to 0 for unlimited. Start with 50 or 100 to preview your data before running a full scan.

## `includeOwnerDetails` (type: `boolean`):

Visit each community's about page to extract owner name, bio, email, social links, course count, and full landing page copy. Adds ~2s per community but gives you 3x more data fields. Disable for a faster scan with basic data only.

## `startUrls` (type: `array`):

Only use this if you want to scrape specific communities by name or URL. Leave empty to use the discovery rankings or search terms above.

Examples: skoolers, https://www.skool.com/ai-automation-society

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

Number of browser tabs running in parallel during owner detail extraction. Higher is faster but uses more memory. 12 is the sweet spot for most runs.

## Actor input object example

```json
{
  "maxCommunities": 100,
  "includeOwnerDetails": true,
  "concurrency": 12
}
```

# Actor output Schema

## `communities` (type: `string`):

The full list of scraped Skool communities as JSON items. Each item includes community metadata, owner profile, pricing, member stats, and social links.

## `communitiesCsv` (type: `string`):

The scraped communities in CSV format, ready to import into Excel, Google Sheets, or your CRM.

## `overview` (type: `string`):

Browse the scraped communities in the Apify dataset UI with the curated Overview table view.

# 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 = {
    "maxCommunities": 100
};

// Run the Actor and wait for it to finish
const run = await client.actor("crustapi/skool-community-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 = { "maxCommunities": 100 }

# Run the Actor and wait for it to finish
run = client.actor("crustapi/skool-community-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 '{
  "maxCommunities": 100
}' |
apify call crustapi/skool-community-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Skool Community Scraper",
        "description": "Extract data from thousands of Skool.com communities, including owner names, emails, social links, pricing, member counts, course stats, and landing page copy. Export data, run via API, schedule and monitor runs, or integrate with other tools.",
        "version": "0.0",
        "x-build-id": "bhgKcWm6DDpvb8G0U"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/crustapi~skool-community-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-crustapi-skool-community-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/crustapi~skool-community-scraper/runs": {
            "post": {
                "operationId": "runs-sync-crustapi-skool-community-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/crustapi~skool-community-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-crustapi-skool-community-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "searchTerms": {
                        "title": "Search for communities by keyword (optional)",
                        "type": "array",
                        "description": "Search Skool for communities matching these keywords. Each keyword returns up to 1,000 matching communities. Leave empty to scrape top-ranked communities from all categories instead.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxCommunities": {
                        "title": "Max communities to scrape",
                        "minimum": 0,
                        "type": "integer",
                        "description": "How many communities to scrape. Set to 0 for unlimited. Start with 50 or 100 to preview your data before running a full scan.",
                        "default": 100
                    },
                    "includeOwnerDetails": {
                        "title": "Include owner details (name, email, socials)",
                        "type": "boolean",
                        "description": "Visit each community's about page to extract owner name, bio, email, social links, course count, and full landing page copy. Adds ~2s per community but gives you 3x more data fields. Disable for a faster scan with basic data only.",
                        "default": true
                    },
                    "startUrls": {
                        "title": "Specific community URLs or names (optional)",
                        "type": "array",
                        "description": "Only use this if you want to scrape specific communities by name or URL. Leave empty to use the discovery rankings or search terms above.\n\nExamples: skoolers, https://www.skool.com/ai-automation-society",
                        "items": {
                            "type": "string"
                        }
                    },
                    "concurrency": {
                        "title": "Parallel browsers for enrichment",
                        "minimum": 1,
                        "maximum": 20,
                        "type": "integer",
                        "description": "Number of browser tabs running in parallel during owner detail extraction. Higher is faster but uses more memory. 12 is the sweet spot for most runs.",
                        "default": 12
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
