# Youtube Channel Lead Scraper (`scraperforge/youtube-channel-lead-scraper`) Actor

🔎 Lead Scraper helps you extract high-intent leads from YouTube channels with precision—finding key details for outreach fast. 🚀 Perfect for B2B sales, marketing & recruitment. 📈 Subscribe for smarter lead generation!

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

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 Channel Lead Scraper allows users to collect valuable **contact** information from **YouTube** channels. It focuses on **extract**ing publicly available **data** while adhering to ethical guidelines.

This tool can retrieve lead addresses listed in the 'About' section of channels, making it easier to connect with creators and businesses. Additionally, users can gather channel names, URLs, and subscriber counts for a comprehensive **data**set.

By automating the **data** **extract**ion process, the scraper ensures efficiency and accuracy. It is suitable for both small-scale and large-scale **data** collection projects, offering flexibility and scalability.

With this tool, users can streamline their outreach efforts and build targeted **contact** lists quickly.

Youtube Channel Lead Scraper is a powerful tool designed to help users extract lead addresses and contact information from YouTube channels with ease. It simplifies the process of finding contact details for creators and businesses on the platform.

This lead extractor for YouTube channels is ideal for marketers, researchers, and businesses looking to connect with content creators. It automates the process of gathering contact information, saving time and effort.

With the YouTube lead finder tool, users can efficiently collect lead addresses from channel descriptions and about sections. It ensures accurate and reliable data extraction for various professional needs.

### 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 | Extracts publicly available lead addresses from YouTube channel 'About' sections. |
| Channel Name | Retrieves the name of the YouTube channel for identification purposes. |
| Channel URL | Collects the direct URL to the YouTube channel for easy access. |
| Subscriber Count | Gathers the number of subscribers for each channel to assess popularity. |
| Channel Description | Extracts the description provided by the channel owner in the 'About' section. |
| Video Count | Retrieves the total number of videos uploaded by the channel. |
| Category | Identifies the category or niche of the YouTube channel. |
| Country | Collects the country information if specified by the channel owner. |

### 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 scrape channel names URLs and subscriber counts for detailed insights
- ⭐ User-friendly interface for easy operation and navigation
- ⭐ Supports bulk data scraping for large-scale projects
- ⭐ Ensures compliance with legal and ethical standards for data collection
- ⭐ **Customizable** search filters to target specific niches or categories
- ⭐ **Fast** and efficient data scraping with minimal manual intervention
- ⭐ Option to export extracted data in multiple formats like CSV or JSON
- ⭐ **Regular** updates to ensure compatibility with **YouTube**s platform changes
- ⭐ **Secure** and reliable tool with data privacy considerations

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

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

1. ✅ Create an account on the platform hosting the Youtube Channel Lead Scraper
2. ✅ Log in to the dashboard and navigate to the scraper tool
3. ✅ Enter the keywords or URLs of the **YouTube** channels you want to scrape
4. ✅ Set your preferences for data extraction such as lead addresses or subscriber counts
5. ✅ **Start** the scraping process and monitor the progress in real time
6. ✅ Once completed review the extracted data for accuracy and completeness
7. ✅ **Export** the data to your preferred format such as CSV or JSON
8. ✅ Use the extracted information for outreach marketing or research purposes

### Use Cases 🎯

Marketing and Outreach
🎯 Build targeted lead lists for influencer marketing campaigns
🎯 Connect with **YouTube** creators for brand collaborations

Research and Analysis
🎯 **Analyze** **YouTube** channel data for market research
🎯 **Identify** trends and patterns in specific niches or categories

Business Development
🎯 **Find** potential partners or collaborators on **YouTube**
🎯 Reach out to channels for sponsorship opportunities

Content Creation
🎯 **Identify** and connect with creators for guest appearances
🎯 Collaborate with **YouTube** channels to expand your audience

### Why choose us? 💎

Our Youtube Channel Lead Scraper stands out for its efficiency, reliability, and **user-friendly** design. It is tailored to meet the needs of marketers, researchers, and businesses seeking to connect with **YouTube** creators.

By using **advanced** algorithms, the tool ensures accurate and comprehensive data extraction. We prioritize user experience by offering a simple interface and customizable options.

This **YouTube** lead finder tool is constantly updated to adapt to changes on the platform, ensuring uninterrupted service. Our scraper is built with scalability in mind, allowing users to handle both small and large projects effortlessly.

Additionally, we adhere to strict ethical and legal guidelines, ensuring that all data collection is compliant with **YouTube**'s terms of service. Whether you need to extract leads from **YouTube** videos or gather channel statistics, our tool provides a complete solution.

Choose us for a **reliable**, efficient, and legally compliant lead scraping experience.

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

The Youtube Channel Lead Scraper is designed to handle projects of all sizes, from small-scale data collection to enterprise-level operations. Its robust infrastructure ensures fast and reliable performance, even when dealing with large datasets.

Users can customize their scraping preferences to focus on specific niches or categories, making the tool versatile and **efficient**. The scraper supports bulk data extraction, allowing you to gather information from thousands of channels in a single run.

Whether you are a small business or a large organization, the tool can scale to meet your needs. Regular updates and optimizations ensure that the scraper remains compatible with **YouTube**'s platform changes.

This scalability makes it an ideal solution for businesses and researchers looking to streamline their data collection processes.

### **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** that all data extracted is publicly available and not private information
⚖️ **Do not** use the tool to engage in spamming or unsolicited lead campaigns
⚖️ Comply with **YouTube**s terms of service and community guidelines
⚖️ Respect the privacy of **YouTube** creators and avoid misuse of their contact information
⚖️ **Use** the extracted data only for legitimate and ethical purposes
⚖️ Verify the accuracy of the data before using it for professional purposes
⚖️ **Avoid** reselling or redistributing the extracted data without proper authorization
⚖️ Stay informed about changes in data privacy laws and regulations

### Input Parameters 🧩
📦 Example Input (JSON)
```json
{
  "keywords": ["Youtube Channel 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 Channel 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 Channel 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 Channel **Lead Scraper**?

The Youtube Channel Lead Scraper is a tool designed to extract lead addresses and other contact information from YouTube channels efficiently.

#### Can I use this tool to scrape **private** information?

**No**, the tool only extracts **publicly available** data in **compliance** with ethical and legal standards.

#### Is the scraper compatible with all YouTube channels?

**Yes**, it works with any channel that has **publicly available** contact information.

#### How often is the tool updated?

The tool is regularly updated to ensure compatibility with YouTube's platform changes.

#### Can I **export** the **extract**ed data?

**Yes**, the tool allows you to export data in formats like **CSV** or **JSON**.

#### Is the tool suitable for **large-scale** data scraping?

**Yes**, it is designed to handle projects of all sizes, including bulk data extraction.

#### Does the tool comply with YouTube's terms of service?

**Yes**, the scraper adheres to YouTube's terms of service and only extracts **publicly available** information.

#### Can I customize the scraping process?

**Yes**, you can set preferences such as specific keywords or data types to extract.

#### Is technical support available?

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

#### What data types can the scraper **extract**?

The scraper can extract lead addresses, channel names, URLs, subscriber counts, and more.

#### How **secure** is the tool?

The scraper is built with security in mind and ensures data privacy for users.

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

**Yes**, the tool is ideal for building targeted lead lists for influencer marketing campaigns.

#### Is there a **limit** to the number of channels I can scrape?

The tool supports unlimited scraping, depending on your subscription plan.

#### Can I try the tool before purchasing?

**Yes**, a free trial or demo version may be available depending on the platform.

#### Does the scraper work on mobile devices?

The tool is primarily designed for desktop use but may be accessible on mobile via a web interface.

# 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("scraperforge/youtube-channel-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("scraperforge/youtube-channel-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 scraperforge/youtube-channel-lead-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Youtube Channel Lead Scraper",
        "description": "🔎 Lead Scraper helps you extract high-intent leads from YouTube channels with precision—finding key details for outreach fast. 🚀 Perfect for B2B sales, marketing & recruitment. 📈 Subscribe for smarter lead generation!",
        "version": "0.1",
        "x-build-id": "PkR1EyWTYzHmgguH9"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scraperforge~youtube-channel-lead-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scraperforge-youtube-channel-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/scraperforge~youtube-channel-lead-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scraperforge-youtube-channel-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/scraperforge~youtube-channel-lead-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scraperforge-youtube-channel-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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```