# Youtube Lead Scraper (`scrapemesh/youtube-lead-scraper`) Actor

🚀 Extract targeted YouTube leads Grab channel details & contact-ready insights fast for B2B outreach, sales, and research. ✅ Automate prospecting, save time, and grow your pipeline.

- **URL**: https://apify.com/scrapemesh/youtube-lead-scraper.md
- **Developed by:** [ScrapeMesh](https://apify.com/scrapemesh) (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

### **YouTube** Lead Scraper 📱

The Youtube Lead Scraper allows users to **extract** various types of **data** from **YouTube** channels. It focuses on publicly available **contact** information, ensuring compliance with legal guidelines.

This tool can retrieve **leads** listed in channel descriptions, about sections, and other accessible areas. Users can also gather additional meta**data** related to the channels, such as subscriber count or video statistics.

By automating the process, the scraper saves time and effort while delivering organized **data** in a structured format. This makes it an essential tool for businesses, marketers, and researchers aiming to connect with **YouTube** creators or analyze channel **data** effectively.

Youtube Lead Scraper is a powerful tool designed to extract contact information from YouTube channels efficiently and accurately. It enables users to gather leads from channel descriptions, about sections, and other publicly available areas.

Extracting leads from YouTube can be a challenging task without the right tools. This scraper simplifies the process by automating the extraction and ensuring high-quality results.

Whether you are looking to build partnerships, conduct marketing campaigns, or reach out to influencers, this Youtube Lead Scraper provides a reliable solution. It is designed for scalability and ease of use.

### Support and feedback

- **Bug reports**: Open a ticket in the repository Issues section
- **Custom features**: Contact our enterprise support team
  *Lead: scrapier.io@gmail.com *
### Extractable Data Table 📊
| Data Type | Description |
| --- | --- |
| Lead Address | Extract publicly available lead addresses from channel descriptions and about sections. |
| Channel Name | Retrieve the name of the YouTube channel for identification purposes. |
| Subscriber Count | Gather the number of subscribers for each channel to assess reach. |
| Channel URL | Get the direct URL of the YouTube channel for easy access. |
| Video Count | Collect the total number of videos uploaded by the channel. |
| Channel Description | Extract the description text provided by the channel owner. |
| Creation Date | Retrieve the date the channel was created for historical insights. |
| Social Media Links | Extract links to social media profiles shared in the channel's about section. |

### Key Features of **YouTube** Lead Scraper

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

- ⭐ **Automated** extraction of lead addresses from **YouTube** channels
- ⭐ Ability to gather additional channel metadata like subscriber count and video statistics
- ⭐ User-friendly interface designed for quick and efficient data scraping
- ⭐ Supports bulk scraping for processing multiple channels simultaneously
- ⭐ Delivers structured data in formats compatible with analytics tools
- ⭐ Ensures compliance with legal and ethical guidelines for data extraction
- ⭐ **Customizable** scraping options to target specific data types or keywords
- ⭐ Scalable design suitable for both small and large-scale data collection

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

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

1. ✅ **Sign up** or **log in** to the platform hosting the Youtube Lead Scraper
2. ✅ Access the scraper tool from the dashboard or menu options
3. ✅ **Input** the **YouTube** channel URLs or keywords to target specific channels
4. ✅ **Select** the data types you want to extract such as leads or subscriber counts
5. ✅ Adjust scraping settings like batch size or timeout intervals if needed
6. ✅ Click the start button to initiate the scraping process
7. ✅ Monitor the progress through the tools interface or logs
8. ✅ Download the extracted data in your preferred format once the process is complete
9. ✅ **Review** the results to ensure accuracy and completeness
10. ✅ Use the data for your intended purpose such as outreach or analysis

### Use Cases 🎯

Influencer Marketing
🎯 **Identify** influencers by extracting leads from **YouTube** channels
🎯 Reach out to creators for collaborations or sponsorships

Business Outreach
🎯 **Find** potential business partners by gathering contact information
🎯 Expand your network by connecting with **YouTube** creators

Market Research
🎯 **Analyze** channel metadata like subscriber count and video statistics
🎯 Understand trends by studying data across multiple channels

Content Collaboration
🎯 Discover creators with similar interests for joint projects
🎯 **Use** extracted data to propose content ideas or partnerships

### Why choose us? 💎

Our Youtube Lead Scraper stands out for its efficiency, accuracy, and **user-friendly** design. It automates the complex task of extracting leads from **YouTube** channels, saving users valuable time and effort.

The tool is built to handle large-scale data collection, making it suitable for businesses and researchers alike. We prioritize compliance with legal guidelines, ensuring ethical data extraction practices.

With customizable options, users can target specific channels or data types, tailoring the scraping process to their needs. Our solution is ideal for influencer marketing, business outreach, and market research, helping users connect with creators or analyze channel data effectively.

We are committed to providing a **reliable** and **scalable** tool that delivers high-quality results every time.

### **YouTube** Lead Scraper Scalability 📈

The Youtube Lead Scraper is designed to handle both small and **large-scale** data extraction projects. It supports batch processing, allowing users to scrape multiple channels simultaneously without compromising speed or accuracy.

The tool adapts to varying workloads, ensuring consistent performance even during intensive operations. Users can customize settings to optimize scraping for specific needs, whether targeting a few channels or thousands.

By delivering structured data in compatible formats, the scraper simplifies integration with analytics tools and workflows. Its scalable design makes it suitable for individual users, businesses, and researchers looking to extract leads from **YouTube** **efficient**ly.

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

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

#### Legal & Ethical Guidelines
⚖️ **Ensure** compliance with **YouTube**s terms of service when using the scraper
⚖️ Extract only publicly available data to avoid violating privacy laws
⚖️ **Do not** use the scraper for unauthorized or unethical purposes
⚖️ **Obtain** consent before using extracted data for outreach or marketing
⚖️ **Avoid** scraping data from channels that explicitly prohibit data extraction
⚖️ Follow local and international data protection regulations when handling extracted information
⚖️ **Use** the tool responsibly to prevent misuse or harm to **YouTube** creators
⚖️ Regularly review legal requirements to ensure continued compliance

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

### Output Format 📤

📝 Example Output (JSON)

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

### FAQ ❓

#### What is the Youtube **Lead Scraper**?

It is a tool designed to extract lead addresses and other data from YouTube channels efficiently.

#### How does the scraper work?

The scraper automates the process of collecting **publicly available** contact information from YouTube channels.

#### Is the tool **legal** to use?

**Yes**, as long as it is used in **compliance** with YouTube's terms of service and data protection laws.

#### Can I **extract** leads from multiple channels?

**Yes**, the scraper supports batch processing for extracting data from multiple channels simultaneously.

#### What formats are supported for data **export**?

Extracted data can be exported in formats compatible with analytics tools, such as **CSV** or **JSON**.

#### Is the scraper user-friendly?

**Yes**, it features an intuitive interface designed for ease of use.

#### Can I customize the scraping process?

**Yes**, users can adjust settings to target specific data types or channels.

#### Does the tool ensure data accuracy?

**Yes**, the scraper is designed to deliver high-quality and accurate results.

#### What are the system requirements?

The tool is web-based and does not require specific system configurations.

#### Is there a free version of the scraper?

Some platforms may offer a free version with limited features for basic usage.

#### Can I use the scraper for influencer marketing?

**Yes**, it is ideal for identifying and reaching out to influencers on YouTube.

#### Does the tool support **large-scale** data collection?

**Yes**, it is scalable and suitable for processing large amounts of data.

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

**Yes**, the tool organizes data in a structured format for easy analysis.

#### Can I scrape social media links from channels?

**Yes**, the scraper can extract social media links shared in the channel's about section.

#### Is technical support available?

Support may be available depending on the platform hosting the scraper tool.

# Actor input Schema

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

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Youtube Lead Scraper",
        "description": "🚀 Extract targeted YouTube leads Grab channel details & contact-ready insights fast for B2B outreach, sales, and research. ✅ Automate prospecting, save time, and grow your pipeline.",
        "version": "0.1",
        "x-build-id": "8lnbXSN8IvxwKd6b4"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapemesh~youtube-lead-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapemesh-youtube-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/scrapemesh~youtube-lead-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scrapemesh-youtube-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/scrapemesh~youtube-lead-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scrapemesh-youtube-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 Youtube (e.g., ['marketing', 'founder', 'business']). The actor will search Google for Youtube profiles/posts containing these keywords and extract email addresses.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "platform": {
                        "title": "Platform",
                        "enum": [
                            "Youtube"
                        ],
                        "type": "string",
                        "description": "Select platform.",
                        "default": "Youtube"
                    },
                    "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```