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

Patreon Email Scraper extracts publicly available email addresses from Patreon creator profiles and linked pages. Build targeted creator contact lists by niche or category. Ideal for brands and agencies running outreach campaigns.

- **URL**: https://apify.com/scraper-engine/patreon-email-scraper.md
- **Developed by:** [Scraper Engine](https://apify.com/scraper-engine) (community)
- **Categories:** Lead generation, Automation, Other
- **Stats:** 2 total users, 1 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

### **Patreon** Email Scraper 📱

**Patreon** Email Scraper allows users to **extract** essential **contact** information from **Patreon** profiles. This includes email addresses, supporter details, and creator information for outreach and marketing purposes.

The tool is designed to provide structured and accurate **data**, enabling users to build comprehensive email **data**bases. Extractable **data** includes supporter **emails**, creator profiles, and campaign details.

Users can also gather insights into supporter demographics and engagement levels. With its advanced capabilities, the scraper ensures efficient **data** **extract**ion while adhering to legal and ethical guidelines.

It is suitable for businesses, marketers, and creators looking to enhance their outreach strategies through targeted email campaigns.

Patreon Email Scraper is a powerful tool designed to help users extract valuable email data from Patreon creators and supporters efficiently. It simplifies the process of gathering contact information for networking and outreach purposes.

With the Patreon email extraction tool, users can automate the process of building contact lists from Patreon profiles. This saves time and ensures accuracy in collecting user data.

Email scraper for Patreon creators enables businesses and individuals to access important contact details for marketing campaigns and collaborations. It is tailored to meet the needs of creators and marketers alike.

### 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 email addresses of Patreon creators and supporters for outreach purposes. |
| Creator profiles | Gather detailed information about Patreon creators, including their public profile data. |
| Supporter details | Extract data about supporters, including their email and engagement metrics. |
| Campaign information | Retrieve information about creator campaigns, such as titles and descriptions. |
| Demographics | Collect demographic data about supporters, including location and interests. |
| Engagement metrics | Analyze supporter engagement levels, such as pledge amounts and activity. |
| Creator statistics | Access statistics related to creator performance and supporter numbers. |
| Custom data fields | Extract specific custom fields added by creators to their profiles or campaigns. |

### 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** extraction of **Patreon** emails and user data for efficient contact list building
- ⭐ Supports gathering creator profiles and campaign information for detailed insights
- ⭐ **Advanced** filtering options to target specific supporter demographics and engagement levels
- ⭐ User-friendly interface for seamless operation and quick data extraction
- ⭐ Compliance-focused design to ensure ethical and legal scraping practices
- ⭐ **High**-speed data processing for large-scale email database generation
- ⭐ **Customizable** settings to tailor data extraction to specific user needs
- ⭐ **Secure** handling of extracted data to protect user privacy and confidentiality
- ⭐ Detailed analytics and reporting for extracted data to enhance marketing strategies
- ⭐ **Regular** updates to maintain compatibility with **Patreon** platform changes
- ⭐ Ability to export data in various formats for easy integration into CRM tools
- ⭐ Scalable solution suitable for individuals small businesses and large organizations

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

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

1. ✅ **Sign up** for the **Patreon** Email Scraper tool and **log in** to your account
2. ✅ Enter the specific **Patreon** profiles or campaigns you want to scrape data from
3. ✅ **Select** the type of data you wish to extract such as emails or supporter details
4. ✅ Set filters to target specific demographics or engagement metrics if needed
5. ✅ **Start** the scraping process and monitor progress through the dashboard
6. ✅ **Review** the extracted data in the results section for accuracy and completeness
7. ✅ **Export** the data to your preferred format for integration into other tools
8. ✅ Use the data for targeted email campaigns outreach or marketing strategies

### Use Cases 🎯

Marketing Campaigns
🎯 **Use** **Patreon** email extraction tool to build contact lists for targeted email marketing
🎯 Reach out to creators and supporters to promote products or services

Networking and Collaboration
🎯 Connect with **Patreon** creators for partnerships and collaborations
🎯 Utilize email scraper for **Patreon** creators to find potential collaborators

Supporter Insights
🎯 **Analyze** supporter demographics and engagement metrics for strategic planning
🎯 Scrape **Patreon** supporter emails to understand audience preferences

Database Building
🎯 Generate comprehensive email databases for CRM integration
🎯 **Use** **Patreon** email automation tool to streamline contact list creation

Creator Outreach
🎯 **Identify** and contact creators for sponsorship opportunities
🎯 Leverage **Patreon** contact list generator for creator-focused campaigns

### Why choose us? 💎

**Patreon** Email Scraper is the **best** solution for extracting valuable email data from **Patreon** profiles quickly and efficiently. Our tool is designed with **user-friendly** features and **advanced** capabilities to meet the needs of creators, marketers, and businesses.

With the ability to automate the scraping process, users can save time and focus on their outreach strategies. Our software ensures compliance with legal guidelines, making it a **reliable** choice for ethical data extraction.

We offer **regular** updates to adapt to changes in the **Patreon** platform, ensuring uninterrupted service. Whether you need to scrape **Patreon** supporter emails or gather creator profiles, our tool provides accurate and structured data.

By choosing us, you gain access to a **scalable** solution that caters to individuals, small businesses, and large organizations. Our commitment to privacy and security ensures that your extracted data is handled responsibly.

Trust **Patreon** Email Scraper to enhance your marketing campaigns, networking efforts, and database building processes.

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

**Patreon** Email Scraper is designed to handle data extraction tasks of all sizes, making it a scalable solution for individuals and organizations. Whether you need to scrape a few profiles or thousands of supporter emails, our tool ensures **efficient** performance.

The software is equipped with **advanced** processing capabilities to handle **large-scale** data extraction without compromising speed or accuracy. It is suitable for small businesses looking to grow their outreach and large enterprises managing **extensive** marketing campaigns.

With **customizable** settings, users can tailor the scraping process to their specific needs, ensuring flexibility and adaptability. Our tool supports exporting data in various formats, making it easy to integrate into CRM systems or other tools.

Choose **Patreon** Email Scraper for a scalable and reliable solution to your data extraction needs.

### **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 when using the scraper
⚖️ **Obtain** permission from creators before using their email data for outreach
⚖️ **Avoid** scraping data from private or restricted profiles without authorization
⚖️ **Use** extracted data responsibly and avoid spamming or unethical practices
⚖️ Respect user privacy and handle extracted data securely to prevent breaches
⚖️ Follow local data protection laws such as GDPR or CCPA when using the tool
⚖️ **Do not** resell or distribute extracted data without proper consent
⚖️ **Use** the scraper for legitimate purposes such as marketing or networking

### 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 email and user data from Patreon profiles for outreach and marketing purposes.

#### How does the email scraper for Patreon creators work?

The scraper automates the process of gathering email and profile data from creators and supporters on Patreon.

#### Is the Patreon email **extract**ion tool **legal**?

**Yes**, as long as you comply with Patreon’s terms of service and relevant data protection laws.

#### Can I scrape Patreon supporter emails with this tool?

**Yes**, the tool allows you to extract supporter **emails** and engagement metrics for analysis.

#### Does the scraper support **large-scale** data **extract**ion?

**Yes**, Patreon Email Scraper is scalable and can handle data extraction tasks of all sizes.

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

You can export the extracted data in formats such as **CSV**, Excel, or **JSON** for easy integration.

#### Is the tool user-friendly?

**Yes**, the scraper features a simple interface for **seamless** operation and quick data extraction.

#### Can I target **specific** demographics with the scraper?

**Yes**, the tool includes **filtering** options to focus on specific supporter demographics and engagement levels.

#### Is the **extract**ed data **secure**?

**Yes**, the tool ensures **secure** handling of data to protect user privacy and confidentiality.

#### Do you offer support for the Patreon email automation tool?

**Yes**, we provide customer support to assist users with any issues or questions.

#### Can I use the scraper for networking purposes?

**Yes**, the tool is ideal for connecting with creators and supporters for collaborations.

#### Does the tool comply with GDPR and CCPA?

**Yes**, the scraper is designed to adhere to global data protection laws such as GDPR and CCPA.

#### How often is the tool updated?

The scraper is regularly updated to ensure compatibility with changes in the Patreon platform.

#### Can I customize the scraping process?

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

#### Is the Patreon email database builder suitable for businesses?

**Yes**, it is designed for individuals, small **businesses**, and large organizations alike.

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

```

## MCP server setup

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