# Skool Email Scraper (`scrapeengine/skool-email-scraper`) Actor

📧 Skool Email Scraper pulls member emails from Skool communities fast and accurately. 🚀 Perfect for B2B lead gen, outreach, and research. 🔍 Save time, boost targeting, and scale campaigns with confidence.

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

## Pricing

from $3.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** Email Scraper 📱

The **Skool** Email Scraper allows users to **extract** a wide range of **data** from **Skool** communities. This includes **contact** information, user details, and other relevant **data** points that can be used for marketing, lead generation, or research purposes.

The scraper is designed to ensure accuracy and efficiency, providing users with clean and organized **data**. With its advanced features, the tool can **extract** **data** in bulk, making it ideal for large-scale projects.

The **Skool** Email Scraper also supports customizable **extract**ion settings, allowing users to tailor the process to their specific needs. This ensures that only the most relevant and valuable **data** is collected.

The tool is perfect for businesses, marketers, and researchers looking to leverage **Skool**'s platform for their **data**-driven initiatives.

Skool Email Scraper is a powerful tool designed to extract valuable email data from Skool communities efficiently. It enables users to gather contact information for marketing, lead generation, and data analysis purposes.

With the Skool Email Scraper, businesses and marketers can automate the process of email scraping, saving time and effort. This tool is ideal for those looking to streamline their outreach and communication strategies.

The Skool Email Scraper is user-friendly and highly customizable, making it suitable for both beginners and advanced users. Its versatility ensures it can adapt to various data extraction needs.

### Support and feedback

- **Bug reports**: Open a ticket in the repository Issues section
- **Custom features**: Contact our enterprise support team
  *Email: scrapier.io@gmail.com *
### Extractable Data Table 📊
| Data Type | Description |
| --- | --- |
| Email Addresses | Extract email addresses of users from Skool communities for outreach and marketing purposes. |
| Usernames | Collect usernames of members for better identification and segmentation. |
| Profile Links | Retrieve direct links to user profiles for further analysis or contact. |
| Group Memberships | Identify the groups users belong to for targeted marketing strategies. |
| Activity Data | Extract user activity metrics to understand engagement levels. |
| Location Information | Gather location data if available for geo-targeted campaigns. |
| Custom Fields | Extract additional custom fields provided by users in their profiles. |
| Join Dates | Retrieve the dates users joined groups for timeline analysis. |

### Key Features of **Skool** Email Scraper

Here are the **standout features** that make the **Skool** Email Scraper a **top-tier tool** for **marketers**, **agencies**, and **researchers**:

- ⭐ Automates the email scraping process for **Skool** communities
- ⭐ Supports bulk data extraction for large-scale projects
- ⭐ **Customizable** settings to tailor the scraping process to specific needs
- ⭐ Ensures accurate and up-to-date data collection
- ⭐ User-friendly interface suitable for beginners and advanced users
- ⭐ Provides clean and organized data output in various formats
- ⭐ Includes advanced filtering options to refine data extraction
- ⭐ Compatible with multiple operating systems and devices
- ⭐ Ensures data security and compliance with ethical guidelines
- ⭐ Offers robust customer support for troubleshooting and assistance

### How to use **Skool** Email Scraper 🚀

Follow this **simple, step-by-step guide** to start extracting **Skool** emails today:

1. ✅ Download and install the **Skool** Email Scraper software on your device
2. ✅ Log in to your **Skool** account through the scraper interface
3. ✅ **Select** the specific **Skool** group or community you want to scrape data from
4. ✅ **Configure** the scraper settings to specify the data types you wish to extract
5. ✅ Set up filters to refine the scraping process for more targeted results
6. ✅ **Start** the scraping process and monitor its progress through the dashboard
7. ✅ Once the scraping is complete review the extracted data for accuracy
8. ✅ **Export** the data in your preferred format such as CSV or Excel
9. ✅ Use the data for your marketing lead generation or research purposes
10. ✅ Regularly update the scraper to ensure compatibility with **Skool**s platform

### Use Cases 🎯

Marketing Campaigns
🎯 Extract email addresses to build targeted email lists
🎯 **Use** user activity data to identify highly engaged prospects
🎯 Leverage location information for geo-targeted campaigns

Lead Generation
🎯 **Identify** potential leads based on group memberships
🎯 **Collect** profile links for direct outreach and connection
🎯 **Use** join dates to prioritize recent and active leads

Data Analysis
🎯 **Analyze** user activity data to understand engagement trends
🎯 Segment users based on custom fields for detailed insights
🎯 **Study** group memberships to identify popular topics and interests

Business Development
🎯 Gather contact information to expand your professional network
🎯 **Identify** key influencers within **Skool** communities
🎯 **Use** extracted data to tailor your outreach strategies

### Why choose us? 💎

The **Skool** Email Scraper stands out as the **best** email scraping software for **Skool** users due to its efficiency and reliability. Our tool is built with **advanced** algorithms that ensure accurate and up-to-date data extraction.

It is designed to be **user-friendly**, making it accessible to both beginners and experienced users. With customizable settings, you can tailor the scraping process to meet your specific needs.

Our software supports bulk data extraction, saving you time and effort on large-scale projects. Additionally, we prioritize data security and compliance, ensuring that your scraping activities adhere to ethical guidelines.

Our dedicated customer support team is always available to assist you with any issues or questions. By choosing the **Skool** Email Scraper, you gain access to a powerful tool that enhances your marketing, lead generation, and data analysis efforts.

### **Skool** Email Scraper Scalability 📈

The **Skool** Email Scraper is designed to handle projects of all sizes, making it highly scalable for various needs. Whether you're a small business or a large enterprise, our tool can adapt to your data extraction requirements.

It supports bulk scraping, allowing you to collect large volumes of data **efficient**ly. The **customizable** settings enable you to refine the process, ensuring that you extract only the most relevant information.

Our software is optimized for speed and performance, ensuring smooth operation even with **extensive** datasets. As your data needs grow, the **Skool** Email Scraper can scale with you, providing consistent and reliable results.

This makes it an ideal solution for businesses looking to expand their marketing and lead generation efforts.

### **Skool** Email Scraper Legal Guidelines ⚖️

**Yes**—scraping **Skool** is **legal** as long as you follow **ethical** and **compliant** practices. The **Skool** Email Scraper extracts only **publicly available** information from **public** **Skool** profiles, making it **safe** and **compliant** for **research**, **marketing**, and **analysis**.

#### Legal & Ethical Guidelines
⚖️ Always comply with **Skool**s terms of service when using the scraper
⚖️ **Obtain** user consent before collecting their data for marketing purposes
⚖️ **Avoid** scraping sensitive or personal information without proper authorization
⚖️ **Use** the extracted data responsibly and for legitimate purposes only
⚖️ **Do not** share or sell the scraped data to third parties without consent
⚖️ **Ensure** that your scraping activities adhere to local and international data protection laws
⚖️ Regularly review and update your practices to remain compliant with legal guidelines
⚖️ Respect the privacy and rights of **Skool** users during the data extraction process

### Input Parameters 🧩
📦 Example Input (JSON)
```json
{
  "keywords": ["Skool Email Scraper"],
  "country": "Global",
  "maxEmailNumbers": 20,
  "platform": "Skool",
  "engine": "legacy"
}
````

### Input Table

| Data Type | Description |
| --- | --- |
| keywords | Keywords to find relevant profiles |
| country | Country setting (Global) |
| maxEmailNumbers | Maximum emails to collect (default 20) |
| platform | Platform to scrape (Skool) |
| engine | Engine type (legacy) |
| proxyConfiguration | Optional proxy settings |

### Output Format 📤

📝 Example Output (JSON)

```json
[
  {
    "network": "Skool",
    "keyword": "Skool Email Scraper",
    "title": "Google's Single-Benefit Marketing Strategy for Chrome ...",
    "description": "✓For years, once we created a Gmail account, we couldn't change the username (the part before @ gmail.com ). ... Grand Rapids Marketing Co. Read more",
    "url": "https://www.linkedin.com/posts/phill-agnew_heres-how-google-marketed-chrome-browser-activity-7404878510214914048-dLxI",
    "email": "before@gmail.com"
  }
]
```

### Output Table

| Data Type | Description |
| --- | --- |
| network | Identifies Skool as the source |
| keyword | Keyword that triggered the result (Skool Email Scraper) |
| title | Profile title or username |
| description | Public bio snippet with contact info |
| url | Direct Skool profile link |
| email | Extracted email address |

### FAQ ❓

#### What is the Skool **Email Scraper**?

The Skool Email Scraper is a tool designed to extract email addresses and other data from Skool communities.

#### Is the Skool **Email Scraper** easy to use?

**Yes**, the Skool Email Scraper features a **user-friendly** interface suitable for beginners and advanced users.

#### What data can I **extract** with the Skool **Email Scraper**?

You can extract email addresses, usernames, profile links, group memberships, activity data, and more.

#### Is the Skool **Email Scraper** **legal** to use?

**Yes**, as long as you comply with Skool's terms of service and data protection laws.

#### Can I customize the scraping process?

**Yes**, the Skool Email Scraper offers customizable settings to tailor the data extraction process.

#### Does the scraper support bulk data **extract**ion?

**Yes**, the Skool Email Scraper is designed to handle large-scale data extraction projects.

#### What formats can I **export** the data in?

You can export the data in formats such as **CSV** or Excel for easy analysis.

#### Is **customer support** available?

**Yes**, we provide dedicated customer support to help you with any issues or questions.

#### Can I use the Skool **Email Scraper** for **lead generation**?

**Yes**, the scraper is ideal for collecting contact information for lead generation purposes.

#### Does the scraper ensure data accuracy?

**Yes**, the Skool Email Scraper is built with advanced algorithms to ensure accurate and up-to-date data.

#### Is the Skool **Email Scraper** compatible with all devices?

**Yes**, the scraper is compatible with multiple operating systems and devices.

#### How often should I update the scraper?

We recommend updating the scraper regularly to ensure compatibility with Skool's platform.

#### Can I scrape data from multiple Skool groups?

**Yes**, the scraper allows you to extract data from multiple groups efficiently.

#### Is there a **limit** to the amount of data I can scrape?

The Skool Email Scraper supports bulk data extraction, making it suitable for large-scale projects.

#### Does the scraper comply with data protection laws?

**Yes**, the scraper is designed to ensure **compliance** with local and international data protection regulations.

# Actor input Schema

## `keywords` (type: `array`):

List of keywords to search for on Skool (e.g., \['marketing', 'founder', 'business']). The actor will search Google for Skool profiles/posts containing these keywords and extract email addresses.

## `platform` (type: `string`):

Select platform.

## `location` (type: `string`):

Optional: Add location to search query (e.g., 'London', 'New York'). Leave empty to search globally.

## `emailDomains` (type: `array`):

Optional: Filter results to only include emails from specific domains (e.g., \['@gmail.com', '@outlook.com']). Leave empty to collect all email domains.

## `maxEmails` (type: `integer`):

Maximum number of emails to collect per keyword (default: 20).

## `engine` (type: `string`):

Choose scraping engine. 🚀 Cost Effective (New): Uses residential proxies with async requests for faster, cheaper scraping. 🔧 Legacy: Uses GOOGLE\_SERP proxy with traditional selectors - more reliable but slower and more expensive.

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

Choose which proxies to use. By default, no proxy is used. If Google rejects or blocks the request, the actor will automatically fallback to datacenter proxy, then residential proxy with 3 retries.

## Actor input object example

```json
{
  "keywords": [
    "marketing"
  ],
  "platform": "Skool",
  "location": "",
  "emailDomains": [
    "@gmail.com"
  ],
  "maxEmails": 20,
  "engine": "legacy",
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "keywords": [
        "marketing"
    ],
    "emailDomains": [
        "@gmail.com"
    ],
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapeengine/skool-email-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 = {
    "keywords": ["marketing"],
    "emailDomains": ["@gmail.com"],
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("scrapeengine/skool-email-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 '{
  "keywords": [
    "marketing"
  ],
  "emailDomains": [
    "@gmail.com"
  ],
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call scrapeengine/skool-email-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Skool Email Scraper",
        "description": "📧 Skool Email Scraper pulls member emails from Skool communities fast and accurately. 🚀 Perfect for B2B lead gen, outreach, and research. 🔍 Save time, boost targeting, and scale campaigns with confidence.",
        "version": "0.1",
        "x-build-id": "VXc7HmerEf9B8lxCv"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapeengine~skool-email-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapeengine-skool-email-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/scrapeengine~skool-email-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scrapeengine-skool-email-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/scrapeengine~skool-email-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scrapeengine-skool-email-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "keywords"
                ],
                "properties": {
                    "keywords": {
                        "title": "Keywords",
                        "type": "array",
                        "description": "List of keywords to search for on Skool (e.g., ['marketing', 'founder', 'business']). The actor will search Google for Skool profiles/posts containing these keywords and extract email addresses.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "platform": {
                        "title": "Platform",
                        "enum": [
                            "Skool"
                        ],
                        "type": "string",
                        "description": "Select platform.",
                        "default": "Skool"
                    },
                    "location": {
                        "title": "Location Filter",
                        "type": "string",
                        "description": "Optional: Add location to search query (e.g., 'London', 'New York'). Leave empty to search globally.",
                        "default": ""
                    },
                    "emailDomains": {
                        "title": "Email Domains Filter",
                        "type": "array",
                        "description": "Optional: Filter results to only include emails from specific domains (e.g., ['@gmail.com', '@outlook.com']). Leave empty to collect all email domains.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxEmails": {
                        "title": "Maximum Emails per Keyword",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Maximum number of emails to collect per keyword (default: 20).",
                        "default": 20
                    },
                    "engine": {
                        "title": "Engine",
                        "enum": [
                            "legacy"
                        ],
                        "type": "string",
                        "description": "Choose scraping engine. 🚀 Cost Effective (New): Uses residential proxies with async requests for faster, cheaper scraping. 🔧 Legacy: Uses GOOGLE_SERP proxy with traditional selectors - more reliable but slower and more expensive.",
                        "default": "legacy"
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Choose which proxies to use. By default, no proxy is used. If Google rejects or blocks the request, the actor will automatically fallback to datacenter proxy, then residential proxy with 3 retries."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```