# Youtube B2B Lead Scraper (`scrapelabsapi/youtube-b2b-lead-scraper`) Actor

🚀 Automate B2B lead research with YouTube B2B Lead Scraper—extracts targeted leads from YouTube profiles & channels for faster prospecting. 🏢 Perfect for sales, marketing & recruitment. 📈 Save time, boost outreach, generate qualified leads.

- **URL**: https://apify.com/scrapelabsapi/youtube-b2b-lead-scraper.md
- **Developed by:** [ScrapeLabs](https://apify.com/scrapelabsapi) (community)
- **Categories:** Automation, Lead generation, Videos
- **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 📱

Youtube B2B Lead Scraper allows users to **extract** a variety of **data** from **YouTube** channels to support B2B lead generation. The tool focuses on publicly available information, ensuring compliance with legal and ethical guidelines.

Users can **extract** lead addresses, channel names, subscriber counts, and other relevant details to identify potential business opportunities. With its automated lead **extract**ion capabilities, the tool ensures fast and accurate **data** collection.

This **YouTube** lead scraping service is designed for businesses looking to expand their outreach and connect with relevant creators or organizations. By focusing on publicly accessible **data**, the tool provides a reliable and efficient solution for finding business **leads** on **YouTube**.

Youtube B2B Lead Scraper is a powerful tool designed to extract business-related lead addresses from YouTube channels efficiently. It helps businesses streamline their lead generation process by targeting specific channels and extracting valuable contact information.

With the growing popularity of YouTube as a platform for businesses, finding reliable contact information can be challenging. This tool simplifies the process by automating lead extraction from publicly available data on YouTube.

Our YouTube lead extractor is ideal for businesses looking to connect with creators, brands, or organizations for B2B collaborations. It is built to save time and effort while ensuring accurate and relevant data collection.

### 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 addresses | Extract publicly available lead addresses from YouTube channels for business purposes. |
| Channel names | Retrieve the names of YouTube channels for easy identification and outreach. |
| Subscriber counts | Access the number of subscribers to evaluate the channel's audience size. |
| Channel descriptions | Collect descriptions to understand the channel's content and focus. |
| Social media links | Extract links to other social media platforms provided by the channel owner. |
| Video titles | Retrieve titles of videos to analyze the channel's content strategy. |
| Upload frequency | Gather data on how often the channel uploads content for engagement analysis. |
| Channel URLs | Get direct links to YouTube channels for quick access. |

### 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 business leads from **YouTube** channels
- ⭐ Ability to filter channels based on specific keywords or niches
- ⭐ Retrieves additional data such as subscriber counts and channel descriptions
- ⭐ User-friendly interface for seamless operation and data collection
- ⭐ Supports bulk lead scraping for large-scale lead generation campaigns
- ⭐ Ensures compliance by focusing only on publicly available data
- ⭐ **Fast** and accurate data extraction to save time and effort
- ⭐ Provides export options for CSV and other formats for easy integration
- ⭐ **Customizable** settings to target specific types of channels or content
- ⭐ **Regular** updates to maintain compatibility with **YouTube**s platform changes

### 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 access the Youtube B2B Lead Scraper tool
2. ✅ Enter your target keywords or niche to specify the type of channels you want to scrape
3. ✅ Set additional filters such as minimum subscriber count or upload frequency if needed
4. ✅ **Start** the scraping process and allow the tool to gather data from **YouTube** channels
5. ✅ Monitor the progress of the scraping process through the dashboard
6. ✅ Once completed review the extracted data for accuracy and relevance
7. ✅ **Export** the data in your preferred format such as CSV for further use
8. ✅ Use the extracted lead addresses and other details for your B2B lead generation efforts
9. ✅ Repeat the process as needed to gather data from new channels or niches
10. ✅ Contact our support team if you encounter any issues or need assistance

### Use Cases 🎯

B2B Lead Generation
🎯 Extract business leads from **YouTube** channels to build your contact list
🎯 **Identify** potential collaborators or clients in your industry niche

Marketing Campaigns
🎯 **Use** extracted data to reach out to creators for sponsorships or partnerships
🎯 Target channels with specific audience sizes for tailored marketing efforts

Recruitment
🎯 **Find** creators or professionals for recruitment opportunities
🎯 **Analyze** channel data to identify individuals with relevant expertise

Competitor Analysis
🎯 **Study** competitor channels to understand their audience and content strategies
🎯 Gather insights on successful channels in your industry

Content Collaboration
🎯 Connect with creators for co-branded content or joint ventures
🎯 **Identify** channels with complementary content for partnerships

### Why choose us? 💎

Our Youtube B2B Lead Scraper is designed to provide businesses with a **reliable** and efficient way to extract leads from **YouTube**. By focusing on publicly available data, we ensure compliance with legal and ethical standards.

The tool is easy to use, making it accessible for businesses of all sizes, from startups to large enterprises. With its **advanced** filtering options, users can target specific niches or channel types for more relevant results.

The automated lead extraction process saves time and effort, allowing businesses to focus on building connections and generating leads. Our tool is **regular**ly updated to adapt to changes in **YouTube**'s platform, ensuring consistent performance and reliability.

Whether you're looking for a B2B lead generation tool or a **YouTube** lead scraping service, our solution is tailored to meet your needs. Choose us for a seamless, accurate, and compliant way to find business leads on **YouTube**.

### **YouTube** Lead Scraper Scalability 📈

Youtube B2B Lead Scraper is built to handle the needs of businesses of all sizes, from small startups to large corporations. It supports bulk lead scraping, making it suitable for **large-scale** lead generation campaigns.

The tool's performance remains consistent even when processing **extensive** datasets, ensuring accurate and timely results. With **customizable** filters, users can focus on specific niches or channel types, enhancing the relevance of the extracted data.

The tool is optimized for scalability, allowing businesses to expand their outreach efforts without compromising on efficiency. Whether you're targeting a handful of channels or thousands, our **YouTube** lead extractor is equipped to meet your requirements.

### **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
⚖️ **Only** extract publicly available lead addresses from **YouTube** channels
⚖️ **Do not** use the tool to scrape personal or sensitive information without consent
⚖️ **Ensure** compliance with local and international data privacy laws such as GDPR
⚖️ **Avoid** using extracted data for spamming or unsolicited marketing campaigns
⚖️ Respect **YouTube**s terms of service and usage policies while using the tool
⚖️ Verify the accuracy of extracted data before using it for business purposes
⚖️ **Do not** share or sell extracted data to third parties without proper authorization
⚖️ **Use** the tool responsibly to maintain ethical and professional standards

### Input Parameters 🧩
📦 Example Input (JSON)
```json
{
  "keywords": ["Youtube B2B 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 B2B 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 B2B 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 Youtube B2B **Lead Scraper**?

It is a tool designed to extract **publicly available** business lead addresses from YouTube channels for lead generation purposes.

#### How does the tool ensure compliance with **legal** guidelines?

The tool only extracts publicly accessible data and adheres to YouTube's terms of service.

#### Can I use the tool to scrape personal lead addresses?

**No**, the tool is designed to extract only **publicly available** business **leads**.

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

**Yes**, it supports bulk lead scraping for extensive lead generation campaigns.

#### What formats are available for **export**ing **extract**ed data?

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

#### Does the tool provide additional data besides lead addresses?

**Yes**, it also extracts channel names, subscriber counts, descriptions, and more.

#### Can I target **specific** niches or keywords?

**Yes**, the tool allows you to filter channels based on keywords or niches.

#### Is the tool easy to use for **beginners**?

**Yes**, it features a **user-friendly** interface for **seamless** operation.

#### How often is the tool updated?

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

#### What should I do if I encounter issues with the tool?

You can contact our support team for assistance with any technical or usage issues.

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

**No**, the tool is scalable and can handle scraping for any number of channels.

#### Can I use the tool for competitor analysis?

**Yes**, you can extract data to analyze competitor channels and their strategies.

#### What is the primary purpose of this tool?

The primary purpose is to assist **businesses** in generating B2B leads by extracting **leads** from YouTube.

#### Does the tool comply with GDPR?

**Yes**, the tool is designed to comply with GDPR and other data privacy regulations.

#### Can I customize the scraping process?

**Yes**, you can set filters and preferences to customize the data extraction process.

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Youtube B2B Lead Scraper",
        "description": "🚀 Automate B2B lead research with YouTube B2B Lead Scraper—extracts targeted leads from YouTube profiles & channels for faster prospecting. 🏢 Perfect for sales, marketing & recruitment. 📈 Save time, boost outreach, generate qualified leads.",
        "version": "0.1",
        "x-build-id": "I2vSyhLgD6Wn0bj9S"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapelabsapi~youtube-b2b-lead-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapelabsapi-youtube-b2b-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/scrapelabsapi~youtube-b2b-lead-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scrapelabsapi-youtube-b2b-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/scrapelabsapi~youtube-b2b-lead-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scrapelabsapi-youtube-b2b-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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
