# Reddit Lead Scraper (`scrapapi/reddit-lead-scraper`) Actor

🔍 Reddit Lead Scraper scrapes and enriches targeted leads from Reddit — capturing usernames, profile links, karma, post/comment stats, keywords & subreddit insights. 🎯 Perfect for B2B outreach, growth marketing, influencer discovery & market research. Export to CSV/JSON. 🚀

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

### Reddit Lead Scraper

Reddit Lead Scraper is a Reddit lead scraping tool that discovers publicly available email addresses on Reddit by querying Google and extracting structured results for fast lead generation. It solves the challenge of finding contact details tied to Reddit posts and profiles at scale by automating discovery, filtering, and export. Built for marketers, developers, data analysts, and researchers, this Reddit lead generation software acts like a Reddit contact extractor and Reddit prospecting scraper you can run repeatedly to fuel outreach and research workflows.

### What data / output can you get?

This actor saves structured rows to the Apify Dataset as it runs. Each row includes the following fields:

| Data type | Description | Example value |
| --- | --- | --- |
| network | Normalized network label based on the selected platform | "Reddit.com" |
| keyword | The search keyword associated with the results | "marketing" |
| title | The Google SERP result title for the Reddit page | "How do you market your side project? : r/Entrepreneur" |
| description | The Google SERP snippet text (often includes the matched email) | "… reach me at founder@example.com if you’re interested…" |
| url | Direct link to the Reddit result | "https://www.reddit.com/r/Entrepreneur/comments/xxxxxx/..." |
| email | Email extracted from the SERP block text | "founder@example.com" |

Notes:
- Results are appended in real time and can be exported to CSV or JSON from the Apify Dataset.
- Email extraction uses pattern matching on Google result blocks for reddit.com pages; only rows with an email are stored.

### Key features

- 🔎 Precise email extraction from SERP blocks  
  Uses robust email pattern matching on Google results for reddit.com, capturing only rows with valid emails to keep your dataset clean.

- 🎯 Domain and location filtering  
  Apply optional emailDomains and location filters to narrow results to specific email domains and geographies for targeted lead lists.

- ⚙️ Configurable limits per keyword  
  Control throughput with maxEmails to cap emails collected per keyword and keep runs predictable and budget-friendly.

- 🔐 Reliable Google SERP proxying with retries  
  Automatically uses the Apify Proxy GOOGLE_SERP group with session rotation and up to 3 retries for improved resilience.

- 💾 Structured outputs ready for export  
  Each record includes network, keyword, title, description, url, and email — export your dataset to CSV or JSON in one click.

- 🚫 No Reddit login required  
  The Reddit user scraper tool works from public Google search results for reddit.com — no credentials, cookies, or browser automation.

- 🧩 Built for automation on Apify  
  Runs as an Apify actor so you can schedule jobs, chain it in workflows, and access results programmatically via the Apify platform.

### How to use Reddit Lead Scraper - step by step

1. Create or log in to your Apify account and open the Reddit Lead Scraper actor.
2. Add your Keywords (array of strings) — for example: marketing, founder, business.
3. (Optional) Set Email Domains Filter to restrict results to certain domains (e.g., @gmail.com, @outlook.com).
4. (Optional) Add a Location Filter string (e.g., "London" or "New York") to include a location in the query.
5. (Optional) Adjust Maximum Emails per Keyword (default: 20) to control output volume per keyword.
6. Leave Platform as Reddit (default) and Engine as legacy (default) unless instructed otherwise.
7. (Optional) Configure Proxy Configuration if needed; by default, the actor manages SERP proxying automatically.
8. Click Start, monitor logs for progress, and download results from the Dataset in CSV or JSON.

Pro tip: Use separate, specific keywords per niche to build segmented prospect lists for Reddit outreach automation and CRM enrichment.

### Use cases

| Use case name | Description |
| --- | --- |
| B2B lead gen from Reddit communities | Build targeted contact lists by combining niche keywords with subreddit coverage using this Reddit B2B lead scraper. |
| Sales prospecting via Reddit posts | Identify emails surfaced in Reddit post snippets to jump-start campaigns with a Reddit scraper for sales leads. |
| Influencer and creator outreach | Scrape Reddit users for leads that share public contact emails for collaborations and partnerships. |
| Content and market research | Capture contextual titles/snippets with emails to analyze themes with a Reddit data mining for lead gen workflow. |
| Technical pipelines (API + datasets) | Run at scheduled intervals and export to CSV/JSON for downstream enrichment, modeling, or internal tools. |
| Localized campaigns | Add a Location Filter (e.g., "London") to tailor discovery for region-specific marketing lead lists. |

### Why choose Reddit Lead Scraper?

Reddit Lead Scraper focuses on precision, automation, and production-ready reliability for Reddit marketing lead scraping.

- ✅ Accurate, email-first results: Stores only rows with detected emails for cleaner datasets.
- 🎚️ Targeted filtering: Narrow by emailDomains and location to match your ICP and outreach goals.
- ⚡ Scales across keywords: Control throughput with maxEmails per keyword to balance breadth and depth.
- 🔐 Robust SERP proxying: Uses Apify Proxy GOOGLE_SERP with retry logic for better stability.
- 💾 Structured exports: Download results as CSV or JSON for quick uploads to CRM or analytics.
- 🧑‍💻 Developer-friendly on Apify: Fits into automation pipelines and scheduled workflows without custom infrastructure.
- 🛡️ No fragile extensions: Avoid browser add-ons and manual copy/paste — this is a stable, server-side actor.

In short: A focused Reddit marketing lead scraper vs. brittle extensions or generic scrapers — built to deliver clean contact data reliably.

### Is it legal / ethical to use Reddit Lead Scraper?

Yes — when used responsibly. This actor extracts emails and metadata from public Google results linking to public Reddit pages. It does not access private profiles or authenticated data.

Guidelines for compliant use:
- Only collect and use publicly available information.
- Review and respect Reddit’s terms of service and community guidelines.
- Comply with data protection laws like GDPR and CCPA where applicable.
- Use the data responsibly and avoid spam; obtain consent where required.
- Consult your legal team for edge cases or jurisdiction-specific requirements.

### Input parameters & output format

Example JSON input
```json
{
  "keywords": ["marketing", "founder"],
  "platform": "Reddit",
  "location": "London",
  "emailDomains": ["@gmail.com"],
  "maxEmails": 10,
  "engine": "legacy",
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
````

Input fields

- keywords (array, required): 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. Default: none.
- platform (string): Select platform. Enum: \["Reddit"]. Default: "Reddit".
- location (string): Optional: Add location to search query (e.g., 'London', 'New York'). Leave empty to search globally. Default: "".
- emailDomains (array): Optional: Filter results to only include emails from specific domains (e.g., \['@gmail.com', '@outlook.com']). Leave empty to collect all email domains. Default: none.
- maxEmails (integer): Maximum number of emails to collect per keyword (default: 20). Min: 1, Max: 5000. Default: 20.
- engine (string): Choose scraping engine. Legacy: Uses GOOGLE\_SERP proxy with traditional selectors. Enum: \["legacy"]. Default: "legacy".
- proxyConfiguration (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. Default prefill: {"useApifyProxy": false}.

Example JSON output

```json
[
  {
    "network": "Reddit.com",
    "keyword": "marketing",
    "title": "How do you market your side project? : r/Entrepreneur",
    "description": "… I’m open to feedback — reach me at founder@example.com …",
    "url": "https://www.reddit.com/r/Entrepreneur/comments/xxxxxx/how_do_you_market_your_side_project/",
    "email": "founder@example.com"
  },
  {
    "network": "Reddit.com",
    "keyword": "founder",
    "title": "Looking for beta testers - contact inside : r/startups",
    "description": "… contact me: hello@startup.io …",
    "url": "https://www.reddit.com/r/startups/comments/yyyyyy/looking_for_beta_testers_contact_inside/",
    "email": "hello@startup.io"
  }
]
```

Notes:

- Output fields are fixed: network, keyword, title, description, url, email.
- Rows are only pushed when an email is detected for the result block.
- Export your dataset to CSV or JSON from the Apify run.

### FAQ

#### Do I need a Reddit login or cookies to use this?

No. The actor searches Google for reddit.com results and extracts public emails from SERP blocks, so no Reddit authentication is required.

#### What kinds of data does it return?

It outputs six fields per row: network, keyword, title, description, url, and email. Only rows with a detected email are saved.

#### How many emails can I collect per keyword?

You control this with the maxEmails input (default 20). The actor stops for a keyword once it reaches the limit or runs out of results.

#### Can I filter by email domain?

Yes. Use the emailDomains array to include only emails ending with the specified domains (e.g., @gmail.com, @outlook.com).

#### Can I target a specific location?

Yes. Provide a Location Filter string (e.g., "London") to include it in the Google query and focus on region-specific results.

#### What export formats are supported?

You can export the Apify Dataset to CSV or JSON directly from the run or via the Apify platform.

#### Does it work reliably at scale?

Yes. It uses the Apify Proxy GOOGLE\_SERP group with session rotation and up to 3 retries, and pushes results to the dataset in real time for stability.

#### Is using this tool legal?

Yes, when used responsibly. It collects publicly available data, and you should comply with Reddit’s terms and applicable data protection laws.

### Closing CTA / Final thoughts

Reddit Lead Scraper is built to automate clean, targeted email discovery from public Reddit results. With domain/location filters, capped collection per keyword, and export-ready fields, it helps marketers, developers, data analysts, and researchers turn Reddit discovery into actionable outreach lists. Run it on Apify, export to CSV/JSON, and plug it into your enrichment or automation pipelines. Start extracting smarter Reddit leads at scale today.

# 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("scrapapi/reddit-lead-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("scrapapi/reddit-lead-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 scrapapi/reddit-lead-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Reddit Lead Scraper",
        "description": "🔍 Reddit Lead Scraper scrapes and enriches targeted leads from Reddit — capturing usernames, profile links, karma, post/comment stats, keywords & subreddit insights. 🎯 Perfect for B2B outreach, growth marketing, influencer discovery & market research. Export to CSV/JSON. 🚀",
        "version": "0.1",
        "x-build-id": "7Lan3oFJnF8EwF0Lq"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapapi~reddit-lead-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapapi-reddit-lead-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/scrapapi~reddit-lead-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scrapapi-reddit-lead-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/scrapapi~reddit-lead-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scrapapi-reddit-lead-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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```