# Youtube Leads Generator (`scrapers-hub/youtube-leads-generator`) Actor

🚀 YouTube Leads Generator (youtube-leads-generator) helps you find targeted prospects fast—extracting channel details and contact signals for smarter outreach. 🎯 Perfect for B2B sales, marketing, and lead generation.

- **URL**: https://apify.com/scrapers-hub/youtube-leads-generator.md
- **Developed by:** [Scrapers Hub](https://apify.com/scrapers-hub) (community)
- **Categories:** Lead generation, Social media, Automation
- **Stats:** 1 total users, 0 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.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/docs.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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 Leads Generator - B2B & B2C Email Finder (Free 100 Emails) 🔍

**YouTube Leads Generator - B2B & B2C Email Finder (Free 100 Emails)** is an Apify actor that extracts high-quality YouTube channel leads with contact emails, subscriber counts, and channel details—ideal if you need fast results for influencer marketing, partnerships, and outreach. Whether you’re a marketer, sales team member, recruiter, or data enthusiast, this YouTube lead generator helps you turn relevant channel keywords into a usable email list for B2B email list generator and B2C email finder workflows, saving you hours of manual work.

---

### Why choose YouTube Leads Generator - B2B & B2C Email Finder (Free 100 Emails)?

| Feature | Benefit |
| --- | --- |
| ✅ **All-in-one YouTube lead extraction** | Extract emails and channel data (subscribers, videos, joined date, description) in one run |
| ✅ **Email-first or channel-first mode** | Use “Only Scrape Leads With Email” to focus on channels that include an email address |
| ✅ **Reliability-focused retries** | Includes retries and fallbacks for resilience when scraping channel pages |
| ✅ **Built-in proxy support** | Supports proxy configuration to improve reliability for large lead batches |
| ✅ **Structured dataset output** | Saves results to a dataset with consistent fields for easy downstream use |
| ✅ **Scale across multiple keywords** | Generate lead databases per keyword with a global cap for the free tier |

---

### Key features

- 📧 **Email extraction from channel text**: Extracts email addresses found in the channel description and channel page content
- 🔍 **B2B and B2C email finder support**: Captures both consumer and business-style emails, filtering out common invalid placeholders
- 🏷️ **Keyword-based lead generation**: Use your keywords to discover relevant YouTube channels and generate targeted results
- 🌍 **Country targeting**: Select a target country (used as a country filter) to steer lead relevance
- 🛡️ **Proxy resilience options**: Supports proxy configuration for more reliable scraping under real-world conditions
- 🔄 **Retry logic for robustness**: Uses retries for channel fetching and handles rate limiting or unavailable responses
- 💾 **Real-time dataset saving**: Pushes lead records immediately so you keep progress even if a run stops early
- 📊 **Rich channel metadata**: Includes subscriber count, video count, joined date, channel description, social links, and image URLs

---

### Input

Provide input via an `input.json` file. Example structure:

```json
{
  "keywords": ["fitness", "tech reviewer"],
  "country": "United States",
  "maxLeadsPerKeyword": 20,
  "scrapeLeadsWithEmail": true
}
````

#### Input Fields

| Field | Required | Description |
| --- | --- | --- |
| `keywords` | Yes | List of keywords to search for YouTube channels (for example: `tech reviewer`, `fitness`, `gaming`). |
| `country` | No | Select the target country for leads. If omitted, the default is `United States`. |
| `maxLeadsPerKeyword` | No | Maximum number of leads to collect for each keyword. For free users, there’s also a global cap of 100 emails total per run. |
| `scrapeLeadsWithEmail` | No | If enabled, the actor returns only channels that have an email address in their description. |

***

### Output

The actor saves each lead record into the **YouTube Leads Dataset** in structured JSON fields.

```json
{
  "keyword": "fitness",
  "channel_name": "Example Channel",
  "channel_handle": "examplehandle",
  "emails": ["contact@example.com"],
  "channel_url": "https://www.youtube.com/@examplehandle",
  "subscriber_count": "123,456",
  "video_count": "789",
  "joined_date": "Joined January 1, 2020",
  "channel_description": "Channel description text...",
  "social_links": {
    "twitter": "https://twitter.com/example",
    "linkedin": "https://www.linkedin.com/in/example"
  },
  "custom_url": "https://www.youtube.com/@examplehandle",
  "avatar_url": "https://example.com/avatar.jpg"
}
```

#### Output Fields

| Field | Type | Description |
| --- | --- | --- |
| `keyword` | string | The keyword that generated this lead. |
| `channel_name` | string | The channel name. |
| `channel_handle` | string | The channel handle (vanity handle without the `@` prefix). |
| `emails` | array | All extracted email addresses for the channel. |
| `channel_url` | string | Normalized channel URL for the lead. |
| `subscriber_count` | string | Subscriber count as shown on the channel. |
| `video_count` | string | Video count as shown on the channel. |
| `joined_date` | string | Joined date text from channel metadata. |
| `channel_description` | string | Channel description text. |
| `social_links` | object | Social links found from the channel “about” external links (e.g., `twitter`, `instagram`, `linkedin`, etc.). |
| `custom_url` | string | The channel’s custom vanity URL value. |
| `avatar_url` | string | URL to the channel avatar image. |

**Note:** The actor also tracks success internally via a `success` and `error_message` structure while scraping channels, but only leads that meet the save conditions are pushed to the dataset.

***

### How to use YouTube Leads Generator - B2B & B2C Email Finder (Free 100 Emails) (via Apify Console)

1. **Open Apify Console**\
   Sign in at https://console.apify.com and open the **Actors** tab.

2. **Find the actor card**\
   Search for **YouTube Leads Generator - B2B & B2C Email Finder (Free 100 Emails)** and open its details page.

3. **Add your INPUT**\
   In the **INPUT** section, paste your `input.json` data with:
   your `keywords`, your chosen `country`, and whether you want `scrapeLeadsWithEmail`.

4. **Optional: pick your lead volume**\
   Set `maxLeadsPerKeyword` to control how many leads are attempted per keyword. On the free tier, the run is capped at **100 emails total per run**.

5. **Run the actor**\
   Click **Run**. During execution, you’ll see progress in logs as it processes keywords and enriches channels.

6. **Review results in the OUTPUT tab**\
   When the run finishes, open the dataset named **Scraped Leads** (inside **YouTube Leads Dataset**).

7. **Export your lead list**\
   Export the dataset as JSON or CSV from the dataset UI and plug it into your outreach stack.

No coding required—get accurate YouTube lead generator results in minutes 🚀

***

### Advanced features & SEO optimization

- 🔁 **Designed for “YouTube to email leads” workflows**: The actor is built specifically for lead generation via email by combining keyword-based channel discovery with email extraction from channel content.
- 📌 **Engineered for “find verified emails” style use**: It extracts email addresses from publicly available channel text and filters out common invalid placeholder patterns.
- 🧭 **Flexible for both B2B and B2C**: Works for business outreach as well as consumer/influencer contact use cases, producing a structured `emails` list per channel.
- 🛡️ **Resilient scraping behavior**: Includes retries and delay logic for resilience when encountering rate limits or temporary failures.
- 💾 **Dataset-ready output**: Produces a consistent dataset table (keyword, channel identifiers, emails, and key stats) for easy importing.

***

### Best use cases

- 📈 **Sales teams building outreach email lists**: Generate a structured YouTube to email leads database for faster campaign setup.
- 🎯 **Influencer marketing managers**: Find YouTube prospecting tool contacts with emails plus subscriber and video counts for better targeting.
- 🧠 **Market researchers & analysts**: Collect channel descriptions, social links, and metadata to study audience and niche trends.
- 🤝 **Partnership and affiliate teams**: Build a B2B and B2C lead database by keyword and region for collaboration outreach.
- ✉️ **Email marketing ops**: Produce sales outreach email list inputs ready for segmentation and CRM ingestion.
- 💼 **Recruiters sourcing talent from creators**: Identify channels in your niche and collect business contact emails for engagement.

***

### Technical specifications

- **Supported Input Formats**
  - ✅ `keywords` as an array of strings
  - ✅ `country` as a string from the provided enum list (default: `United States`)
  - ✅ `maxLeadsPerKeyword` as an integer (default: `20`)
  - ✅ `scrapeLeadsWithEmail` as a boolean (default: `false`)

- **Proxy Support**
  - ✅ Supports proxy configuration for both lead discovery pages and YouTube channel enrichment to improve reliability.

- **Retry Mechanism**
  - ✅ Uses retries (configured as `max_retries = 3` in the actor) and handles temporary issues like rate limiting.

- **Dataset Structure**
  - ✅ Outputs lead records into **YouTube Leads Dataset → Scraped Leads** with fields such as:
    `keyword`, `channel_name`, `channel_handle`, `emails`, `channel_url`, `subscriber_count`, `video_count`, `joined_date`, `channel_description`, `social_links`, `custom_url`, `avatar_url`.

- **Limitations**
  - ❗ Free tier is capped at **100 emails total per run** (global limit).
  - ❗ Results depend on publicly available contact info on the channels.

***

### FAQ

#### Does YouTube Leads Generator - B2B & B2C Email Finder (Free 100 Emails) return emails for every channel?

✅ No. It extracts emails from publicly available channel text and, when enabled, can restrict results to channels that have an email address in their description (`scrapeLeadsWithEmail`).

#### What does “Only Scrape Leads With Email” do?

✅ When `scrapeLeadsWithEmail` is set to `true`, the actor only saves leads for channels that have an email address (from the channel’s extracted content/description).

#### Is there a limit on the number of emails I can get?

✅ Yes on the free tier: the actor enforces a global cap of **100 emails total per run**.

#### Can I target a specific country?

✅ Yes. Use the `country` input to select a target country for lead generation. If the provided country is not found in the internal mapping, it proceeds without applying a country code filter.

#### How are results stored?

✅ The actor saves leads into the **YouTube Leads Dataset** dataset named **Scraped Leads**, with structured fields including `emails`, channel metadata, and URLs.

#### Can I integrate this into my workflow (CRM, spreadsheet, analytics)?

✅ Yes. Because the actor outputs structured dataset rows (JSON, and typically exportable to CSV), it’s easy to load into CRMs, spreadsheets, or analysis pipelines.

#### Does it require any login or API keys from me?

✅ No. You just provide the actor input via Apify Console and run the actor. Proxy handling is managed through the actor’s built-in support.

#### Is it legal to use the collected emails for outreach?

✅ The actor collects information only from **publicly available sources**, but whether and how you can use it for outreach is your responsibility. Make sure you comply with applicable laws (for example GDPR/CCPA), spam regulations, and platform terms.

***

### Support & feature requests

Want to improve your YouTube lead generator results with YouTube Leads Generator - B2B & B2C Email Finder (Free 100 Emails)? Tell us what would help.

- 💡 **Feature Requests**: For example, CSV export enhancements, additional filters for outreach targeting, or custom email handling logic.
- 📧 **Contact**: Email us at <dataforleads@gmail.com>

Thanks—your feedback helps shape future upgrades to this YouTube email finder and B2B email list generator experience.

***

### *YouTube Leads Generator - B2B & B2C Email Finder (Free 100 Emails)* — Final thoughts

*If you’re looking for a most comprehensive, SEO-optimized YouTube prospecting tool that turns channel keywords into a usable email list, this is built for that exact job-to-be-done.*\
*Run it with your keywords today and export your leads when you’re ready.* 🚀

***

### Disclaimer

**This tool accesses publicly accessible sources only.** It does not access private profiles, authenticated data, or password-protected pages.

It is your responsibility to ensure your use complies with applicable laws (including GDPR/CCPA), spam regulations, and platform terms of service. For any data removal request, contact us at <dataforleads@gmail.com>.

Use YouTube Leads Generator - B2B & B2C Email Finder (Free 100 Emails) responsibly, ethically, and for legitimate purposes only.

# Actor input Schema

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

List of keywords to search for YouTube channels (e.g., 'tech reviewer', 'fitness', 'gaming').

## `country` (type: `string`):

Select the target country for leads.

## `maxLeadsPerKeyword` (type: `integer`):

Maximum number of leads to collect for each keyword. Free users are capped at 100 emails total per run.

## `scrapeLeadsWithEmail` (type: `boolean`):

If enabled, only returns channels that have an email address in their description.

## Actor input object example

```json
{
  "keywords": [
    "fitness"
  ],
  "country": "United States",
  "maxLeadsPerKeyword": 20,
  "scrapeLeadsWithEmail": 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": [
        "fitness"
    ],
    "country": "United States",
    "maxLeadsPerKeyword": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapers-hub/youtube-leads-generator").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": ["fitness"],
    "country": "United States",
    "maxLeadsPerKeyword": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("scrapers-hub/youtube-leads-generator").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": [
    "fitness"
  ],
  "country": "United States",
  "maxLeadsPerKeyword": 20
}' |
apify call scrapers-hub/youtube-leads-generator --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Youtube Leads Generator",
        "description": "🚀 YouTube Leads Generator (youtube-leads-generator) helps you find targeted prospects fast—extracting channel details and contact signals for smarter outreach. 🎯 Perfect for B2B sales, marketing, and lead generation.",
        "version": "1.0",
        "x-build-id": "WDu3YBe7AYsJ27G1z"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapers-hub~youtube-leads-generator/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapers-hub-youtube-leads-generator",
                "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/scrapers-hub~youtube-leads-generator/runs": {
            "post": {
                "operationId": "runs-sync-scrapers-hub-youtube-leads-generator",
                "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/scrapers-hub~youtube-leads-generator/run-sync": {
            "post": {
                "operationId": "run-sync-scrapers-hub-youtube-leads-generator",
                "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": "Search Keywords",
                        "minItems": 1,
                        "uniqueItems": true,
                        "type": "array",
                        "description": "List of keywords to search for YouTube channels (e.g., 'tech reviewer', 'fitness', 'gaming').",
                        "items": {
                            "type": "string"
                        }
                    },
                    "country": {
                        "title": "Target Country",
                        "enum": [
                            "United States",
                            "United Kingdom",
                            "Canada",
                            "Australia",
                            "India",
                            "Germany",
                            "France",
                            "Spain",
                            "Italy",
                            "Brazil",
                            "Mexico",
                            "Japan",
                            "South Korea",
                            "China",
                            "Singapore",
                            "United Arab Emirates",
                            "Netherlands",
                            "Sweden",
                            "Norway",
                            "Denmark",
                            "Switzerland",
                            "Belgium",
                            "Austria",
                            "Ireland",
                            "New Zealand",
                            "South Africa"
                        ],
                        "type": "string",
                        "description": "Select the target country for leads.",
                        "default": "United States"
                    },
                    "maxLeadsPerKeyword": {
                        "title": "Max Leads Per Keyword",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Maximum number of leads to collect for each keyword. Free users are capped at 100 emails total per run.",
                        "default": 20
                    },
                    "scrapeLeadsWithEmail": {
                        "title": "Only Scrape Leads With Email",
                        "type": "boolean",
                        "description": "If enabled, only returns channels that have an email address in their description.",
                        "default": false
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
