# Patreon Email Scraper (`scrapium/patreon-email-scraper`) Actor

📧 Patreon Email Scraper extracts email addresses from Patreon creators for lead gen, outreach & CRM enrichment. 🚀 Automate contact discovery, save time, and boost conversions with clean, export-ready results. 🔒 Privacy-minded, reliable automation.

- **URL**: https://apify.com/scrapium/patreon-email-scraper.md
- **Developed by:** [Scrapium](https://apify.com/scrapium) (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

### **Patreon** Email Scraper 📱

**Patreon** Email Scraper enables users to **extract** a wide range of **data** from **Patreon** profiles with ease. It is designed to collect accurate and relevant information while adhering to ethical guidelines.

This tool can retrieve email addresses, user names, and other essential details from public profiles. Additionally, it can gather **data** about creators' campaigns, supporter statistics, and more.

By automating the **data** **extract**ion process, this software ensures efficiency and precision. It is ideal for marketers, researchers, and businesses looking to connect with **Patreon** users.

With its advanced features, **Patreon** Email Scraper provides comprehensive **data** collection capabilities tailored to your needs.

Patreon Email Scraper is a powerful tool designed to help users extract valuable contact information from Patreon profiles efficiently. This tool is ideal for those looking to gather data for research, marketing, or networking purposes.

With Patreon Email Scraper, you can automate the process of collecting user data, saving time and effort. It is built to handle large-scale data extraction while maintaining accuracy and reliability.

Email scraping tools for Patreon are essential for businesses and individuals aiming to connect with creators or supporters on the platform. This scraper ensures compliance with ethical guidelines while delivering high-quality results.

### 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 public email addresses from Patreon profiles for communication purposes. |
| Usernames | Retrieve usernames of creators and supporters for identification. |
| Campaign details | Gather information about creators' campaigns, including titles and descriptions. |
| Supporter statistics | Extract data on the number of supporters and pledge amounts for campaigns. |
| Profile links | Collect links to Patreon profiles for further exploration. |
| Social media links | Retrieve social media links shared on Patreon profiles. |
| Profile bios | Extract biography or 'about' sections from user profiles. |
| Pledge tiers | Gather details about pledge tiers and their associated benefits. |

### Key Features of **Patreon** Email Scraper

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

- ⭐ **Automated** data extraction for efficiency and accuracy
- ⭐ User-friendly interface for easy operation and navigation
- ⭐ Ability to scrape large volumes of data quickly and reliably
- ⭐ **Customizable** scraping options to target specific data types
- ⭐ **Advanced** filtering to refine data collection results
- ⭐ Support for exporting data in multiple formats like CSV and JSON
- ⭐ **Regular** updates to ensure compatibility with **Patreon** platform changes
- ⭐ Compliance with ethical and legal guidelines for data scraping
- ⭐ **High**-speed performance to handle large-scale data scraping tasks
- ⭐ **Secure** and private data handling to protect user information
- ⭐ Detailed documentation and customer support for seamless usage
- ⭐ **Integration** capabilities with other tools and software

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

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

1. ✅ Download and install the **Patreon** Email Scraper software on your device
2. ✅ Launch the application and **log in** with your credentials
3. ✅ Enter the URL of the **Patreon** profile or campaign you wish to scrape
4. ✅ **Select** the specific data types you want to extract such as emails or usernames
5. ✅ Set any filters or preferences to refine your data extraction process
6. ✅ Click the **Start** Scraping button to begin the data collection process
7. ✅ Monitor the progress of the scraping task through the status bar
8. ✅ Once completed review the extracted data in the results section
9. ✅ **Export** the data to your preferred format such as CSV or JSON
10. ✅ Save the exported file to your device for further analysis or use
11. ✅ Repeat the process for additional profiles or campaigns as needed
12. ✅ Refer to the documentation or contact support for troubleshooting assistance

### Use Cases 🎯

Marketing Campaigns
🎯 **Collect** email addresses for targeted email marketing campaigns
🎯 **Identify** potential collaborators or influencers on **Patreon**

Research and Analysis
🎯 **Analyze** supporter statistics for market research purposes
🎯 **Study** campaign trends and patterns among creators

Networking Opportunities
🎯 Connect with creators and supporters for professional networking
🎯 Discover potential partners or sponsors for your projects

Content Creation Insights
🎯 Understand popular pledge tiers and their benefits
🎯 Explore successful campaign strategies for inspiration

### Why choose us? 💎

**Patreon** Email Scraper stands out as one of the **best** **Patreon** scraper tools available today. It combines **advanced** technology with a **user-friendly** interface to deliver exceptional performance.

Our software is designed to meet the needs of marketers, researchers, and businesses seeking to extract **Patreon** user data efficiently. With customizable options and robust filtering features, you can tailor data extraction to your specific requirements.

We prioritize data accuracy, security, and compliance with ethical guidelines to ensure a trustworthy experience. Our team provides **regular** updates and dedicated support to keep the tool compatible with **Patreon** platform changes.

Choose **Patreon** Email Scraper for **reliable**, efficient, and ethical data extraction solutions.

### **Patreon** Email Scraper Scalability 📈

**Patreon** Email Scraper is built to handle data extraction tasks of any size, making it highly scalable for diverse needs. Whether you need to scrape data from a few profiles or thousands, our tool ensures consistent performance and accuracy.

The software's **advanced** algorithms enable it to process large volumes of data quickly without compromising quality. It is designed to adapt to the growing demands of businesses and researchers.

With features like batch processing and export options, you can manage **extensive** data sets effortlessly. **Patreon** Email Scraper is the ideal solution for scaling your data extraction efforts **efficient**ly and effectively.

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

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

#### Legal & Ethical Guidelines
⚖️ **Ensure** compliance with **Patreon**s terms of service before using the scraper
⚖️ **Only** extract data that is publicly available and not private information
⚖️ **Avoid** using the scraper for spamming or unsolicited marketing purposes
⚖️ Respect the intellectual property rights of creators on the platform
⚖️ **Do not** share or sell extracted data without proper authorization
⚖️ **Use** the scraper responsibly and ethically to maintain platform integrity
⚖️ Consult legal experts if you are unsure about data scraping regulations in your region
⚖️ Always prioritize user privacy and data protection while using the tool

### Input Parameters 🧩
📦 Example Input (JSON)
```json
{
  "keywords": ["Patreon Email Scraper"],
  "country": "Global",
  "maxEmailNumbers": 20,
  "platform": "Patreon",
  "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 (Patreon) |
| engine | Engine type (legacy) |
| proxyConfiguration | Optional proxy settings |

### Output Format 📤

📝 Example Output (JSON)

```json
[
  {
    "network": "Patreon",
    "keyword": "Patreon 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 Patreon as the source |
| keyword | Keyword that triggered the result (Patreon Email Scraper) |
| title | Profile title or username |
| description | Public bio snippet with contact info |
| url | Direct Patreon profile link |
| email | Extracted email address |

### FAQ ❓

#### What is Patreon **Email Scraper**?

Patreon Email Scraper is a tool designed to extract public email addresses and other data from Patreon profiles.

#### Is it **legal** to scrape data from Patreon?

Data scraping is legal if it complies with Patreon’s terms of service and only extracts **publicly available** information.

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

You can extract **emails**, usernames, campaign details, supporter statistics, profile links, and more.

#### Can I use this tool for marketing purposes?

**Yes**, but ensure that your marketing campaigns comply with anti-spam laws and ethical guidelines.

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

You can export the data in formats like **CSV** or **JSON** through the export feature in the tool.

#### Is the scraper compatible with all Patreon profiles?

The scraper is designed to work with publicly accessible profiles and campaigns.

#### How often is the tool updated?

The tool is updated regularly to maintain compatibility with Patreon platform changes.

#### Can I scrape data in bulk?

**Yes**, the tool supports batch processing for large-scale data extraction tasks.

#### Is my data **secure** while using the scraper?

**Yes**, the tool prioritizes data security and ensures private handling of user information.

#### Do you offer **customer support**?

**Yes**, we provide dedicated customer support and detailed documentation for assistance.

#### What are the system requirements for the scraper?

The tool is compatible with most modern operating systems and requires an internet connection.

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

**Yes**, the tool offers customizable options to target specific data types and refine results.

#### Is there a free trial available?

Please check our website for information on free trials or demo versions.

#### What payment methods do you accept?

We accept major credit cards, PayPal, and other popular payment methods.

#### Can I integrate this tool with other software?

**Yes**, the scraper supports integration with various tools and platforms for **seamless** workflows.

# Actor input Schema

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

List of keywords to search for on Patreon (e.g., \['marketing', 'founder', 'business']). The actor will search Google for Patreon 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": "Patreon",
  "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("scrapium/patreon-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("scrapium/patreon-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 scrapium/patreon-email-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Patreon Email Scraper",
        "description": "📧 Patreon Email Scraper extracts email addresses from Patreon creators for lead gen, outreach & CRM enrichment. 🚀 Automate contact discovery, save time, and boost conversions with clean, export-ready results. 🔒 Privacy-minded, reliable automation.",
        "version": "0.1",
        "x-build-id": "za5a3tikNtYG16Reh"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapium~patreon-email-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapium-patreon-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/scrapium~patreon-email-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scrapium-patreon-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/scrapium~patreon-email-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scrapium-patreon-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 Patreon (e.g., ['marketing', 'founder', 'business']). The actor will search Google for Patreon profiles/posts containing these keywords and extract email addresses.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "platform": {
                        "title": "Platform",
                        "enum": [
                            "Patreon"
                        ],
                        "type": "string",
                        "description": "Select platform.",
                        "default": "Patreon"
                    },
                    "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```