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

Skool Email Scraper extracts publicly available email addresses from Skool community profiles and pages. Build targeted contact lists by niche or group. Ideal for marketers and sales teams running outreach campaigns.

- **URL**: https://apify.com/scraper-engine/skool-email-scraper.md
- **Developed by:** [Scraper Engine](https://apify.com/scraper-engine) (community)
- **Categories:** Lead generation, Automation, Jobs
- **Stats:** 4 total users, 0 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$19.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 📱

**Skool** Email Scraper allows users to **extract** a variety of **data** points from **Skool** communities. This includes essential **contact** information such as email addresses, user names, and profile details.

The tool is designed to ensure accurate and efficient **data** **extract**ion while adhering to ethical guidelines. With **Skool** Email Scraper, you can gather information that is critical for marketing, networking, or research purposes.

The **extract**ed **data** can be used to build targeted **contact** lists or analyze user behavior within **Skool** communities. By automating the **data** **extract**ion process, this tool saves time and reduces manual effort.

It is an ideal solution for businesses, marketers, and researchers looking to leverage **Skool**'s platform for their needs.

Skool Email Scraper is the ultimate tool for extracting valuable contact information from Skool communities quickly and efficiently. It helps businesses and professionals gather leads and build their contact databases seamlessly.

With Skool Email Scraper, you can automate the process of email harvesting, saving time and effort while ensuring accuracy. This tool is designed to extract data without compromising the integrity of Skool's platform.

Skool is a growing platform for communities and courses, making it a prime source for targeted data extraction. Our email scraper tools are tailored to meet the specific needs of Skool users.

### Support and feedback

- **Bug reports**: Open a ticket in the repository Issues section
- **Custom features**: Contact our enterprise support team
  *Email: dev.scraperengine@gmail.com *
### Extractable Data Table 📊
| Data Type | Description |
| --- | --- |
| Email Addresses | Extract verified email addresses of users from Skool communities. |
| User Names | Capture the names of users associated with Skool profiles. |
| Profile Links | Retrieve direct links to user profiles for further exploration. |
| Community Names | Identify the names of Skool communities where users are active. |
| User Roles | Extract information about user roles within Skool communities. |
| Activity Data | Gather details about user activity and engagement levels. |
| Custom Fields | Extract additional custom data fields available on user profiles. |
| Location Information | Retrieve location details if available on user profiles. |

### 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 and user data from **Skool** communities
- ⭐ Supports bulk data extraction for handling large volumes of information efficiently
- ⭐ Ensures high accuracy in capturing verified email addresses and user details
- ⭐ Offers customizable settings to filter and refine extracted data
- ⭐ Provides seamless integration with other email scraping software tools
- ⭐ Includes advanced algorithms for bypassing common scraping restrictions
- ⭐ Delivers extracted data in organized formats such as CSV or JSON for easy use
- ⭐ Ensures compliance with **Skool**s terms of service and ethical data scraping practices
- ⭐ Features a user-friendly interface for easy setup and operation
- ⭐ Offers robust customer support to assist with any issues or queries

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

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

1. ✅ **Sign up** for an account and **log in** to the **Skool** Email Scraper tool
2. ✅ Enter the URL of the **Skool** community or profile you wish to scrape
3. ✅ **Select** the specific data types you want to extract such as emails or user names
4. ✅ Adjust the scraper settings to filter data based on your preferences
5. ✅ **Start** the scraping process and monitor the progress through the dashboard
6. ✅ Download the extracted data in your preferred format such as CSV or JSON
7. ✅ **Review** the data to ensure accuracy and completeness
8. ✅ Use the extracted data for your marketing research or networking needs
9. ✅ Repeat the process for additional **Skool** communities or profiles as needed
10. ✅ Contact customer support if you encounter any issues during the process

### Use Cases 🎯

Lead Generation
🎯 Extract emails from **Skool** to build targeted lead lists
🎯 **Identify** potential clients or collaborators within specific communities

Market Research
🎯 **Analyze** user profiles to understand audience demographics
🎯 Gather data on community engagement and activity levels

Networking Opportunities
🎯 **Find** professionals or experts in your field through **Skool** contact extraction
🎯 Build connections by reaching out to users with shared interests

Content Promotion
🎯 **Use** extracted emails to promote your courses or content to **Skool** users
🎯 Target specific communities for higher engagement rates

### Why choose us? 💎

Our **Skool** Email Scraper stands out as one of the **best** email scraper tools available for **Skool** data extraction. It is designed with **advanced** features to ensure accuracy, efficiency, and compliance with ethical guidelines.

We prioritize user satisfaction by offering a **user-friendly** interface and robust customer support. Our tool integrates seamlessly with other email scraping software, making it a versatile solution for professionals and businesses.

By automating the email scraping process, we help you save time and focus on your core objectives. Whether you're looking for a **Skool** contact extractor or a comprehensive email harvesting tool, our solution is tailored to meet your needs.

We continuously update our software to adapt to changes in **Skool**'s platform, ensuring uninterrupted performance. Choose us for **reliable**, **scalable**, and efficient email scraping solutions.

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

**Skool** Email Scraper is designed to handle data extraction tasks of any scale. Whether you need to scrape a small community or a large number of profiles, our tool can manage the workload **efficient**ly.

It supports bulk data extraction, allowing you to gather large volumes of information in a short time. Our software uses **advanced** algorithms to ensure consistent performance, even when dealing with high data demands.

By offering **customizable** settings, we enable users to scale their scraping efforts based on specific requirements. This makes our tool suitable for businesses, researchers, and marketers of all sizes.

With **Skool** Email Scraper, you can confidently expand your data extraction efforts without compromising on speed or accuracy.

### **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** compliance with **Skool**s terms of service when using the scraper
⚖️ **Do not** use the tool for illegal or unethical purposes such as spamming
⚖️ Respect user privacy and avoid extracting sensitive personal information
⚖️ **Obtain** necessary permissions before using extracted data for commercial purposes
⚖️ **Avoid** scraping data from private or restricted **Skool** communities without authorization
⚖️ **Use** the tool responsibly to prevent overloading **Skool**s servers
⚖️ **Adhere** to data protection laws and regulations applicable in your region
⚖️ Regularly review **Skool**s policies to stay updated on acceptable scraping practices

### 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 Skool **Email Scraper**?

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

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

**Yes**, it is legal to use as long as you comply with Skool's terms of service and relevant data protection laws.

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

You can extract email addresses, user names, profile links, community names, and more.

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

Our tool uses advanced algorithms to ensure high accuracy in data extraction.

#### Can I use this tool for bulk data **extract**ion?

**Yes**, Skool Email Scraper supports bulk data extraction for handling **large volumes** of information.

#### What formats are available for downloaded data?

Extracted data can be downloaded in formats such as **CSV** or **JSON**.

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

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

#### Does this tool comply with data protection laws?

**Yes**, our tool is designed to comply with applicable data protection laws and ethical guidelines.

#### Can I customize the data **extract**ion settings?

**Yes**, the tool offers customizable settings to filter and refine extracted data.

#### Is the tool easy to use for **beginners**?

**Yes**, Skool Email Scraper features a **user-friendly** interface for easy setup and operation.

#### Can I **extract** data from **private** Skool communities?

**No**, you should not scrape data from private or restricted communities without proper authorization.

#### How often is the software updated?

We regularly update the software to adapt to changes in Skool's platform and maintain performance.

#### What are the ethical guidelines for using this tool?

Users should respect privacy, avoid spamming, and comply with Skool's terms of service.

#### Is the tool scalable for large projects?

**Yes**, Skool Email Scraper is designed to handle data extraction tasks of any scale efficiently.

#### What happens if I encounter issues during scraping?

You can contact our customer support team for assistance with any issues or queries.

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

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=scraper-engine/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 extracts publicly available email addresses from Skool community profiles and pages. Build targeted contact lists by niche or group. Ideal for marketers and sales teams running outreach campaigns.",
        "version": "0.1",
        "x-build-id": "ZOwbz0WhxvwlxvoOU"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scraper-engine~skool-email-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scraper-engine-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/scraper-engine~skool-email-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scraper-engine-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/scraper-engine~skool-email-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scraper-engine-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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```