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

Skool Email Scraper helps you collect emails from Skool creators, coaches, and community owners. Use the data for partnerships, program promotion, and sales outreach. Fast, scalable scraping with clean exports.

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

## Pricing

$14.99/month + usage

To use this Actor, you pay a monthly rental fee to the developer. The rent is subtracted from your prepaid usage every month after the free trial period.You also pay for the Apify platform usage, which gets cheaper the higher Apify subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#rental-actors

## 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 you to **extract** a wide range of **data** from the **Skool** platform. This includes email addresses, user names, group details, and other publicly available **contact** information.

The tool is designed to capture relevant **data** points that help you build targeted **contact** lists. It ensures that the **extract**ed **data** is accurate and up-to-date, making it a reliable resource for marketing and outreach.

The scraper can also identify and organize **data** based on specific criteria, providing a structured and efficient way to manage information. With its customizable settings, you can tailor the **extract**ion process to your specific needs.

Whether you are collecting **data** for research, marketing, or networking, this tool ensures a seamless and efficient experience. It is perfect for **extract**ing **emails** from **Skool** while maintaining compliance with legal and ethical standards.

Skool Email Scraper is a powerful tool designed to help you extract email addresses from the Skool platform efficiently and accurately. It simplifies the process of gathering contact information for networking, marketing, or research purposes.

With the Skool Email Scraper, you can automate the tedious task of manually collecting emails, saving time and effort. This tool is ideal for businesses, researchers, and marketers looking to connect with Skool users.

The Skool platform is a hub for communities and courses, making it a valuable source of contact information. Our email scraper ensures you can access this data while adhering to ethical and legal guidelines.

### Support and feedback

- **Bug reports**: Open a ticket in the repository Issues section
- **Custom features**: Contact our enterprise support team
  *Email: hello.scrapio@gmail.com*
### Extractable Data Table 📊
| Data Type | Description |
| --- | --- |
| Email addresses | Extract publicly available email addresses from Skool profiles and groups. |
| User names | Capture the names of users associated with the extracted emails. |
| Group details | Retrieve information about Skool groups, including names and descriptions. |
| Profile links | Collect direct links to user profiles for further analysis. |
| Contact information | Gather additional publicly available contact details from user profiles. |
| Activity data | Extract data related to user activity within groups or forums. |
| Custom fields | Identify and extract specific data points based on your requirements. |
| Metadata | Collect metadata such as timestamps and group categories for better organization. |

### 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 process of extracting emails from the **Skool** platform
- ⭐ Supports bulk data extraction for handling large datasets efficiently
- ⭐ **Customizable** settings to tailor the scraping process to your needs
- ⭐ Ensures accurate and up-to-date data collection for reliable results
- ⭐ User-friendly interface designed for both beginners and professionals
- ⭐ Complies with legal and ethical guidelines to ensure responsible use
- ⭐ Offers advanced filtering options to extract specific data points
- ⭐ Provides detailed logs and reports for transparency and auditing
- ⭐ Compatible with multiple devices and platforms for seamless operation
- ⭐ Includes regular updates to maintain compatibility with **Skool**
- ⭐ Offers robust error handling to minimize disruptions during scraping
- ⭐ **Secure**s your data with encryption and privacy-focused features

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

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

1. ✅ Log in to your **Skool** account and navigate to the desired group or profile
2. ✅ Download and install the **Skool** Email Scraper software on your device
3. ✅ Open the scraper and configure the settings to match your data extraction needs
4. ✅ **Input** the URL of the **Skool** group or profile you want to scrape
5. ✅ **Select** the data types you wish to extract such as emails or user names
6. ✅ **Start** the scraping process and monitor the progress through the dashboard
7. ✅ Once completed review the extracted data for accuracy and completeness
8. ✅ **Export** the data to your preferred format such as CSV or Excel
9. ✅ Use the extracted data for your marketing research or networking projects
10. ✅ Adjust the scraper settings if needed and repeat the process for other groups
11. ✅ Ensure compliance with **Skool**s terms of service and legal guidelines
12. ✅ Regularly update the scraper to maintain compatibility with **Skool**

### Use Cases 🎯

Marketing Campaigns
🎯 Build targeted email lists for outreach campaigns
🎯 **Identify** potential leads within specific **Skool** groups

Networking Opportunities
🎯 Connect with professionals and community members on **Skool**
🎯 Gather contact details for collaboration and partnerships

Research and Analysis
🎯 **Collect** data for academic or market research purposes
🎯 **Analyze** user activity and engagement within **Skool** groups

Business Development
🎯 **Identify** potential clients or partners within niche communities
🎯 Expand your network by reaching out to **Skool** users

Content Creation
🎯 **Find** influencers or subject matter experts on **Skool**
🎯 Gather insights for creating targeted content strategies

### Why choose us? 💎

Our **Skool** Email Scraper is designed to provide a seamless and efficient data extraction experience. We prioritize accuracy and compliance, ensuring that the data you collect is **reliable** and ethically sourced.

With **advanced** features and customizable settings, our tool caters to a wide range of user needs, from marketers to researchers. We offer robust customer support to assist you at every step of the process.

Our scraper is **regular**ly updated to maintain compatibility with the **Skool** platform, ensuring uninterrupted performance. We also focus on data security, implementing encryption and privacy measures to protect your information.

Whether you are a beginner or a professional, our **user-friendly** interface makes it easy to get started. Choose our **Skool** Email Scraper for a **reliable**, efficient, and compliant solution to your data extraction needs.

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

The **Skool** Email Scraper is built to handle data extraction tasks of any size. Whether you need to scrape a few profiles or thousands of users, our tool is equipped to manage the workload **efficient**ly.

It supports bulk data extraction, ensuring that you can gather large volumes of information without compromising on accuracy. Our scraper is optimized for performance, allowing you to extract data quickly and effectively.

With **customizable** settings, you can scale the extraction process to meet your specific requirements. The tool is also compatible with various devices and platforms, making it a versatile solution for users with different needs.

Whether you are working on a small project or a **large-scale** campaign, our **Skool** Email Scraper provides the scalability you need.

### **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
⚖️ **Ensure** that you comply with **Skool**s terms of service when using the scraper
⚖️ **Do not** use the scraper to extract private or sensitive information from users
⚖️ **Only** collect data that is publicly available on the **Skool** platform
⚖️ **Avoid** using the extracted data for spamming or unethical practices
⚖️ Respect user privacy and do not share collected data without consent
⚖️ **Use** the scraper responsibly and for legitimate purposes only
⚖️ Familiarize yourself with local data protection laws before using the tool
⚖️ Regularly review updates to **Skool**s policies to ensure continued compliance

### 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 **publicly available** data from the Skool platform.

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

**Yes**, it is legal as long as you adhere to Skool's terms of service and only collect **publicly available** information.

#### What data can I **extract** using this tool?

You can extract email addresses, user names, group details, profile links, and other **publicly available** contact information.

#### Is the scraper compatible with all devices?

**Yes**, the Skool Email Scraper is compatible with multiple devices and platforms.

#### How accurate is the **extract**ed data?

The scraper is designed to ensure high accuracy by extracting up-to-date and relevant information.

#### Can I customize the scraping process?

**Yes**, the tool offers customizable settings to tailor the extraction process to your needs.

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

**Yes**, the scraper is designed to comply with legal and ethical guidelines, but users must ensure their use aligns with local laws.

#### How do I **export** the **extract**ed data?

You can export the data in various formats, such as **CSV** or Excel, directly from the tool.

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

**Yes**, we offer robust customer support to assist you with any issues or questions.

#### Can I scrape data from **private** groups?

**No**, the scraper only extracts data that is **publicly available** on the Skool platform.

#### Is the tool updated regularly?

**Yes**, our scraper receives **regular updates** to maintain compatibility with Skool.

#### What happens if Skool changes its platform structure?

Our team ensures the scraper is updated promptly to adapt to any changes in Skool's structure.

#### Can I use the scraper for bulk data **extract**ion?

**Yes**, the tool supports bulk data extraction for handling large datasets efficiently.

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

**Yes**, the tool features a **user-friendly** interface designed for both beginners and professionals.

#### What precautions should I take while using the scraper?

Ensure **compliance** with Skool's terms of service and local data protection laws, and use the tool responsibly.

# 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("scrapio/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("scrapio/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 scrapio/skool-email-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=scrapio/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 helps you collect emails from Skool creators, coaches, and community owners. Use the data for partnerships, program promotion, and sales outreach. Fast, scalable scraping with clean exports.",
        "version": "0.1",
        "x-build-id": "O8xYfjhwMihripnz0"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapio~skool-email-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapio-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/scrapio~skool-email-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scrapio-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/scrapio~skool-email-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scrapio-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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```