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

Extract targeted leads from Reddit using the Reddit Lead Scraper. Collect usernames, post data, profile links, karma metrics, and community activity automatically. Ideal for audience research, prospect discovery, outreach campaigns, and market insights.

- **URL**: https://apify.com/scraper-engine/reddit-lead-scraper.md
- **Developed by:** [Scraper Engine](https://apify.com/scraper-engine) (community)
- **Categories:** Lead generation, Social media, Automation
- **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 allows users to **extract** various types of **data** from **Reddit**. It focuses on gathering publicly available lead addresses from posts, comments, and user profiles.

The tool ensures that only relevant and accurate **data** is collected, enabling users to build targeted lead lists. In addition to lead addresses, the scraper can gather supplementary information such as post titles, subreddit names, and timestamps.

This **data** is essential for creating context around the collected **leads** and understanding their relevance. By automating the process, the scraper eliminates the need for manual **data** collection, making it an efficient solution for **Reddit** **data** **extract**ion.


### Support and feedback

- **Bug reports**: Open a ticket in the repository Issues section
- **Custom features**: Contact our enterprise support team
  *Lead: dev.scraperengine@gmail.com *

### Extractable Data Table 📊
| Data Type | Description |
| --- | --- |
| Lead addresses | Extract publicly available lead addresses from Reddit posts, comments, and profiles. |
| Post titles | Collect the titles of posts where leads are found for better context. |
| Subreddit names | Identify the subreddit where the data was sourced to understand its relevance. |
| Timestamps | Retrieve the date and time of posts or comments containing leads. |
| Usernames | Capture the usernames of Reddit users associated with the extracted leads. |
| Post URLs | Save the direct URLs of posts or comments containing lead addresses. |
| Comment text | Extract the text of comments where leads are mentioned for additional insights. |
| Upvote counts | Gather the number of upvotes on posts or comments to gauge their popularity. |

### Key Features of **Reddit** Lead Scraper

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

- ⭐ **Automated** lead extraction from **Reddit** posts comments and profiles
- ⭐ User-friendly interface for easy setup and operation
- ⭐ Ability to filter data by subreddit keywords or specific users
- ⭐ Export extracted data in multiple formats such as CSV or JSON
- ⭐ Compliance with **Reddit**s API and ethical data usage guidelines
- ⭐ Support for large-scale data extraction with high accuracy
- ⭐ **Customizable** scraping parameters to meet specific needs
- ⭐ Real-time data extraction for up-to-date lead lists
- ⭐ Integrated error handling to ensure smooth operation
- ⭐ Detailed logs for tracking scraping activities and results
- ⭐ **Secure** data handling to protect user information
- ⭐ **Regular** updates to maintain compatibility with **Reddit**s platform

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

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

1. ✅ **Sign up** for an account on the **Reddit** Lead Scraper platform
2. ✅ Download and install the **Reddit** Lead Scraper software on your device
3. ✅ Log in to the tool using your registered credentials
4. ✅ Enter the subreddit or keywords you want to target for lead scraping
5. ✅ Set up filters such as specific users post types or date ranges
6. ✅ **Start** the scraping process by clicking the Run button
7. ✅ Monitor the progress of the scraper through the real-time dashboard
8. ✅ Once completed export the extracted data in your preferred format
9. ✅ **Review** the exported data to ensure accuracy and relevance
10. ✅ Use the data responsibly in compliance with legal and ethical guidelines
11. ✅ Adjust scraping parameters if needed for future extractions
12. ✅ Contact customer support for assistance with advanced configurations

### Use Cases 🎯

Marketing and Lead Generation
🎯 Build targeted lead lists for marketing campaigns
🎯 **Identify** potential leads based on subreddit activity
🎯 Reach out to niche communities for product promotions

Academic Research and Analysis
🎯 Gather data for studies on **Reddit** user behavior
🎯 **Analyze** trends in subreddit discussions
🎯 **Collect** leads for academic surveys or interviews

Networking and Collaboration
🎯 Connect with influencers or experts in specific subreddits
🎯 **Identify** potential collaborators for projects or events
🎯 Expand professional networks through targeted outreach

Content Curation and Insights
🎯 Extract leads from discussions on trending topics
🎯 **Identify** active contributors in niche subreddits
🎯 Gather insights for content creation or curation

### Why choose us? 💎

**Reddit** Lead Scraper stands out as one of the **best** **Reddit** scrapers for leads due to its reliability and efficiency. The tool is designed to simplify the process of extracting leads from **Reddit**, saving users time and effort.

Our software is equipped with **advanced** features such as automated data extraction, customizable filters, and real-time monitoring. These features ensure that users can gather relevant and accurate data to meet their specific needs.

We prioritize compliance with **Reddit**'s API and ethical guidelines, ensuring responsible data usage. Our platform also provides excellent customer support to assist users with any technical issues or questions.

Whether you are a marketer, researcher, or developer, **Reddit** Lead Scraper offers a **scalable** and **user-friendly** solution for your data extraction needs. With **regular** updates and a commitment to quality, we ensure that our tool remains compatible with **Reddit**'s platform.

Choose **Reddit** Lead Scraper for a **reliable**, efficient, and ethical lead scraping experience.

### **Reddit** Lead Scraper Scalability 📈

**Reddit** Lead Scraper is designed to handle data extraction tasks of any scale. Whether you need to scrape a small subreddit or gather data from multiple subreddits, the tool can adapt to your requirements.

Our software supports high-volume data extraction without compromising on accuracy or performance. With **customizable** parameters, users can tailor the scraping process to focus on specific keywords, subreddits, or timeframes.

The tool also includes robust error handling to ensure smooth operation during **large-scale** extractions. As your data needs grow, **Reddit** Lead Scraper can scale with you, providing consistent results.

Our platform is optimized for efficiency, allowing you to extract and process large datasets quickly. By leveraging **advanced** technology, we ensure that our tool remains reliable and effective, even for the most demanding projects.

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

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

#### Legal & Ethical Guidelines
⚖️ **Ensure** compliance with **Reddit**s terms of service when using the scraper
⚖️ **Only** extract publicly available data from **Reddit** posts comments and profiles
⚖️ **Avoid** using the tool for unauthorized or unethical purposes
⚖️ **Do not** sell or distribute extracted data without proper permissions
⚖️ Respect the privacy of **Reddit** users and avoid scraping sensitive information
⚖️ **Use** the extracted data responsibly and in accordance with applicable laws
⚖️ **Avoid** overloading **Reddit**s servers by adhering to API rate limits
⚖️ Consult legal counsel if unsure about the legality of your data usage

### Input Parameters 🧩
📦 Example Input (JSON)
```json
{
  "keywords": ["Reddit Lead Scraper"],
  "country": "Global",
  "maxLeadNumbers": 20,
  "platform": "Reddit",
  "engine": "legacy"
}
````

### Input Table

| Data Type | Description |
| --- | --- |
| keywords | Keywords to find relevant profiles |
| country | Country setting (Global) |
| maxLeadNumbers | Maximum leads 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 Lead 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",
    "lead": "before@gmail.com"
  }
]
```

### Output Table

| Data Type | Description |
| --- | --- |
| network | Identifies Reddit as the source |
| keyword | Keyword that triggered the result (Reddit Lead Scraper) |
| title | Profile title or username |
| description | Public bio snippet with contact info |
| url | Direct Reddit profile link |
| lead | Extracted lead address |

### FAQ ❓

#### What is Reddit **Lead Scraper**?

Reddit Lead Scraper is a tool designed to extract lead addresses and related data from Reddit efficiently and responsibly.

#### Is it **legal** to scrape leads from Reddit?

Scraping **publicly available** data from Reddit is generally legal, but you must comply with Reddit's terms of service and relevant laws.

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

**Yes**, you can use the tool to gather **leads** for marketing, provided you comply with legal and ethical guidelines.

#### Does the scraper work on all subreddits?

**Yes**, the scraper can extract data from any subreddit, as long as the data is publicly accessible.

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

You can export the extracted data in formats such as **CSV** or **JSON** for easy integration with other tools.

#### Is the tool compatible with Reddit's API?

**Yes**, Reddit Lead Scraper is designed to work within the limits of Reddit's API to ensure **compliance**.

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Reddit Lead Scraper",
        "description": "Extract targeted leads from Reddit using the Reddit Lead Scraper. Collect usernames, post data, profile links, karma metrics, and community activity automatically. Ideal for audience research, prospect discovery, outreach campaigns, and market insights.",
        "version": "0.1",
        "x-build-id": "oLmaLG6nEA2fgyOl1"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scraper-engine~reddit-lead-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scraper-engine-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/scraper-engine~reddit-lead-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scraper-engine-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/scraper-engine~reddit-lead-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scraper-engine-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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```