# Reddit Email Scraper (`scrapeengine/reddit-email-scraper`) Actor

📧 Reddit Email Scraper extracts emails from Reddit threads and user content fast and reliably. Perfect for lead gen, outreach, and market research—save hours of manual work. 🚀 Easy setup, targeted results, and cleaner data.

- **URL**: https://apify.com/scrapeengine/reddit-email-scraper.md
- **Developed by:** [ScrapeEngine](https://apify.com/scrapeengine) (community)
- **Categories:** Lead generation, Automation, Social media
- **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

### **Reddit** Email Scraper 📱

**Reddit** Email Scraper allows users to **extract** a variety of **data** types from **Reddit**, focusing on publicly available email addresses. This tool is designed to navigate **Reddit**'s complex structure and retrieve valuable information efficiently.

Users can **extract** **emails** from posts, comments, and user profiles, depending on their specific needs. Additionally, meta**data** such as usernames, post titles, and timestamps can also be collected.

The scraper ensures that all **data** is gathered in compliance with **Reddit**'s terms of service and privacy policies. This makes it an ideal solution for businesses, researchers, and developers looking to harness **Reddit**'s **data** for legitimate purposes.

With its advanced capabilities, **Reddit** Email Scraper provides a reliable way to gather and organize **data** from one of the internet's largest social platforms.

Reddit Email Scraper is a powerful tool designed to extract email addresses from Reddit with precision and efficiency. As one of the most popular platforms for discussions and communities, Reddit holds a wealth of valuable data for businesses and researchers.

By using Reddit Email Scraper, users can access email addresses shared publicly in posts, comments, or user profiles. This tool simplifies the process of gathering contact information for outreach or analysis.

Scraping Reddit for emails can be challenging due to the platform's dynamic nature and vast amount of content. Reddit Email Scraper overcomes these challenges with advanced algorithms and automation.

### 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 publicly available email addresses from posts, comments, or user profiles. |
| Usernames | Retrieve usernames associated with posts or comments containing email addresses. |
| Post titles | Collect titles of posts where emails are found for context. |
| Post content | Extract the full content of posts containing email addresses. |
| Comment content | Gather comments that include email addresses for additional insights. |
| Timestamps | Record the time and date of posts or comments containing emails. |
| Subreddit names | Identify the subreddit from which the data was extracted. |
| Post or comment URLs | Capture the direct links to posts or comments containing email addresses. |

### Key Features of **Reddit** Email Scraper

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

- ⭐ **Automated** scraping of publicly available email addresses from **Reddit**
- ⭐ **Advanced** filtering options to target specific subreddits or keywords
- ⭐ User-friendly interface for easy setup and operation
- ⭐ Compliance with **Reddit**s terms of service and privacy policies
- ⭐ Ability to extract metadata such as usernames timestamps and subreddit names
- ⭐ **Customizable** scraping parameters to meet specific data collection needs
- ⭐ Supports large-scale data extraction with high accuracy
- ⭐ Export data in multiple formats such as CSV or JSON for easy analysis
- ⭐ Real-time scraping capabilities for up-to-date data collection
- ⭐ **Secure** and efficient data processing to protect user privacy

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

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

1. ✅ **Sign up** for an Apify account or **log in** if you already have one
2. ✅ Navigate to the **Reddit** Email Scraper actor in the Apify store
3. ✅ Click the Try for free button to access the scraper interface
4. ✅ Enter your target subreddit keywords or specific **Reddit** URLs in the input fields
5. ✅ **Configure** additional settings such as filters for posts or comments
6. ✅ Set the desired output format such as CSV or JSON for the extracted data
7. ✅ Click the **Start** button to initiate the scraping process
8. ✅ Monitor the progress of the scraper in the Apify dashboard
9. ✅ Download the extracted data once the scraping process is complete
10. ✅ **Review** the data for accuracy and use it for your intended purpose

### Use Cases 🎯

Marketing Campaigns
🎯 **Collect** email addresses for targeted email marketing campaigns
🎯 **Identify** potential leads from specific subreddits related to your niche

Academic Research
🎯 Gather data for studies on online communities and user behavior
🎯 Extract emails to contact **Reddit** users for surveys or interviews

Business Development
🎯 **Find** potential business partners or collaborators on **Reddit**
🎯 **Identify** industry-specific discussions and collect contact information

Content Analysis
🎯 **Analyze** posts and comments containing email addresses for trends
🎯 **Study** user interactions and engagement in specific subreddits

### Why choose us? 💎

**Reddit** Email Scraper stands out as a **reliable** and efficient tool for extracting email addresses from **Reddit**. With its **advanced** automation and filtering capabilities, users can target specific subreddits, keywords, or post types.

This ensures that the data collected is relevant and useful for your needs. Our tool is designed with user-friendliness in mind, making it accessible to both technical and non-technical users.

Additionally, **Reddit** Email Scraper complies with **Reddit**'s terms of service and privacy policies, ensuring ethical data collection practices. Whether you are a marketer, researcher, or developer, our scraper provides the flexibility and scalability you need.

By choosing **Reddit** Email Scraper, you gain access to a powerful tool that simplifies data extraction while maintaining accuracy and security. Our dedicated support team is always available to assist you, ensuring a smooth and hassle-free experience.

### **Reddit** Email Scraper Scalability 📈

**Reddit** Email Scraper is built to handle data extraction tasks of any scale, from small projects to **large-scale** operations. Its **advanced** algorithms ensure **efficient** performance, even when processing **extensive** datasets.

The tool is designed to adapt to your specific needs, allowing you to customize scraping parameters for targeted data collection. Whether you need to extract a few emails or thousands, **Reddit** Email Scraper can handle the workload with ease.

Additionally, the scraper is hosted on Apify's robust platform, ensuring reliable performance and minimal downtime. This makes it an ideal solution for businesses and researchers who require scalable and dependable email scraping tools for **Reddit**.

By leveraging our tool, you can focus on analyzing the data while we handle the complexities of data extraction.

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

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

#### Legal & Ethical Guidelines
⚖️ **Ensure** that all data collection activities comply with **Reddit**s terms of service
⚖️ **Only** scrape publicly available information and avoid accessing private user data
⚖️ **Do not** use the scraper for spamming or any other unethical practices
⚖️ **Obtain** user consent before using their email addresses for marketing purposes
⚖️ Respect user privacy and avoid sharing collected data without permission
⚖️ Abide by local and international data protection laws such as GDPR or CCPA
⚖️ Regularly review **Reddit**s policies to ensure continued compliance
⚖️ **Use** the scraper responsibly to maintain the integrity of **Reddit**s community

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

### Output Format 📤

📝 Example Output (JSON)

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

### FAQ ❓

#### What is Reddit **Email Scraper**?

Reddit Email Scraper is a tool designed to extract **publicly available** email addresses and related data from Reddit.

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

**Yes**, as long as you comply with Reddit's terms of service and only collect **publicly available** data.

#### Can I target **specific** subreddits?

**Yes**, you can configure the scraper to focus on specific subreddits or keywords.

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

The data can be exported in formats such as **CSV** or **JSON** for easy analysis.

#### Is the tool user-friendly?

**Yes**, Reddit Email Scraper features a simple interface that is easy to use for both beginners and experts.

#### Can I scrape comments as well as posts?

**Yes**, the scraper can extract email addresses from both posts and comments.

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

**Yes**, the tool is designed to ensure **compliance** with data protection laws like GDPR and CCPA.

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

The scraper uses advanced algorithms to ensure high accuracy in data collection.

#### Can I use the scraper for **large-scale** projects?

**Yes**, Reddit Email Scraper is scalable and can handle large datasets efficiently.

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

**Yes**, our **dedicated support** team is available to assist you with any issues or questions.

#### How do I get started with Reddit **Email Scraper**?

Simply sign up for an Apify account, access the scraper, and configure your settings to begin.

#### Is my data **secure** during the scraping process?

**Yes**, the tool ensures **secure** data processing to protect user privacy.

#### Can I customize the scraping parameters?

**Yes**, the scraper allows you to customize parameters such as target subreddits and keywords.

#### What if I encounter issues while using the scraper?

You can reach out to our support team for assistance with any technical or operational problems.

#### Is there a free trial available?

**Yes**, you can try Reddit Email Scraper for free on the Apify platform.

# Actor input Schema

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

List of keywords to search for on Reddit (e.g., \['marketing', 'founder', 'business']). The actor will search Google for Reddit 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": "Reddit",
  "location": "",
  "emailDomains": [
    "@gmail.com"
  ],
  "maxEmails": 20,
  "engine": "legacy",
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# API

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

## JavaScript example

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

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

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

// Run the Actor and wait for it to finish
const run = await client.actor("scrapeengine/reddit-email-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "keywords": ["marketing"],
    "emailDomains": ["@gmail.com"],
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("scrapeengine/reddit-email-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "keywords": [
    "marketing"
  ],
  "emailDomains": [
    "@gmail.com"
  ],
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call scrapeengine/reddit-email-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Reddit Email Scraper",
        "description": "📧 Reddit Email Scraper extracts emails from Reddit threads and user content fast and reliably. Perfect for lead gen, outreach, and market research—save hours of manual work. 🚀 Easy setup, targeted results, and cleaner data.",
        "version": "0.1",
        "x-build-id": "tRs7oAI6to5jtQorm"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapeengine~reddit-email-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapeengine-reddit-email-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/scrapeengine~reddit-email-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scrapeengine-reddit-email-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/scrapeengine~reddit-email-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scrapeengine-reddit-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 Reddit (e.g., ['marketing', 'founder', 'business']). The actor will search Google for Reddit profiles/posts containing these keywords and extract email addresses.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "platform": {
                        "title": "Platform",
                        "enum": [
                            "Reddit"
                        ],
                        "type": "string",
                        "description": "Select platform.",
                        "default": "Reddit"
                    },
                    "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```