# YouTube Leads Generator (`scrapevanta/youtube-leads-generator`) Actor

YouTube Leads Generator extracts targeted business and creator data from YouTube, helping you find high-quality leads fast. Collect channel details, emails, social links, subscriber counts, and contact information to power outreach, sales, marketing, and lead generation campaigns.

- **URL**: https://apify.com/scrapevanta/youtube-leads-generator.md
- **Developed by:** [ScrapeVanta](https://apify.com/scrapevanta) (community)
- **Categories:** Lead generation, Developer tools, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $5.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 Leads Generator - B2B & B2C Email Finder (Free 100 Emails) 🎯

Cold outreach falls apart when you can’t quickly find the right contact emails for YouTube creators and businesses. **YouTube Leads Generator - B2B & B2C Email Finder (Free 100 Emails)** automatically pulls YouTube channel details and extracts email addresses from publicly available sources, so you can build a prospect list fast. It’s ideal for YouTube lead generator workflows, whether you need a YouTube email finder for B2B prospecting emails or a B2C email finder for creator outreach. Sales teams, influencer marketers, and researchers use it to turn keyword ideas into real leads in one run—starting with up to **100 emails/run** on the free tier.

---

### See the Data: Sample Output

Here's a real record from a single run:

```json
{
  "keyword": "fitness",
  "channel_name": "StudioPulse",
  "channel_handle": "studiopulse",
  "emails": [
    "contact@studiopulse.com",
    "partnerships@studiopulse.com"
  ],
  "channel_url": "https://www.youtube.com/@studiopulse",
  "subscriber_count": "128,402 subscribers",
  "video_count": "612 videos",
  "joined_date": "Joined March 2016",
  "channel_description": "Training plans, equipment reviews, and community challenges. Contact us for partnerships and sponsorships.",
  "social_links": {
    "twitter": "https://twitter.com/studiopulse",
    "linkedin": "https://linkedin.com/company/studiopulse"
  },
  "custom_url": "https://www.youtube.com/@studiopulse",
  "avatar_url": "https://yt3.googleusercontent.com/abc123=s88-c-k-c0x00ffffff-no-rj",
  "success": true,
  "error_message": null
}
````

The dataset is written to **YouTube Leads Dataset** as rows per successfully scraped channel.

| Field | Type | What It Tells You |
|---|---|---|
| `keyword` | string | The keyword you used to discover this channel (useful for grouping and analysis). |
| `channel_name` | string | The channel name you can reference in outreach. |
| `channel_handle` | string | The channel handle for quick verification and deduping. |
| `emails` | array | All email addresses extracted for the channel—your primary outreach targets. |
| `channel_url` | string | The normalized channel URL to confirm the right profile. |
| `subscriber_count` | string | Channel size signal for prioritizing leads. |
| `video_count` | string | How active the channel is (content volume indicator). |
| `joined_date` | string | Tenure signal you can use for segmentation and scoring. |
| `channel_description` | string | Context for personalization in sales or influencer marketing emails. |
| `social_links` | object | Useful cross-links (like Twitter, LinkedIn, etc.) for extra validation. |
| `custom_url` | string | The channel’s custom URL value (as provided by the actor). |
| `avatar_url` | string | Avatar image URL for dashboards and human review. |
| `success` | boolean | Indicates whether the channel was successfully scraped and processed. |
| `error_message` | string | Explains failures when `success` is false (or `null` on success). |

Export your full dataset as JSON, CSV, or Excel from the Apify dashboard.

***

### Setting It Up

Drop this into your `input.json` and you're ready to go:

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

| Parameter | Required | What It Does |
|---|---|---|
| `keywords` | ✅ | List of keywords to search for YouTube channels (your lead discovery terms). |
| `country` | ⬜ | Picks the target country for leads (defaults to `United States`). |
| `maxLeadsPerKeyword` | ⬜ | Limits how many leads the actor collects for each keyword (free tier is capped at **100 emails total per run**). |
| `scrapeLeadsWithEmail` | ⬜ | When enabled, returns only channels that have an email address in their description. |

***

### What It Does

This actor searches for YouTube channels using your keywords, then extracts emails and channel metadata into a clean dataset.

#### Finds B2B and B2C contact emails from channel info

**YouTube Leads Generator - B2B & C2 Email Finder (Free 100 Emails)** extracts email addresses and also captures a channel’s description, which is helpful for tailoring your YouTube sales leads outreach. It supports both B2B email finder tool needs and B2C email finder use cases, depending on what contact details the channel publishes.

#### Builds a keyword-based YouTube lead generator dataset

You provide `keywords`, and the actor processes them one by one, writing results as it goes. Each saved record includes the `keyword` so you can analyze which discovery terms produce the best leads.

#### Produces structured output you can act on immediately

For each lead, the dataset includes channel identity (`channel_name`, `channel_handle`, `channel_url`), growth signals (`subscriber_count`, `video_count`), and enrichment fields (`joined_date`, `social_links`, `custom_url`, `avatar_url`). The email list is stored in `emails` for easy importing into your CRM.

#### Filters down to email-confirmed channels (optional)

If you enable `scrapeLeadsWithEmail`, the actor only returns channels where an email address was found in the description. This is great when you want a “prospecting email finder” style output with fewer non-contact leads.

#### Handles errors and partial results gracefully

Each pushed dataset record includes `success` and `error_message`, so you can understand which leads were scraped successfully. Even when some channels fail, successful results are still saved to your dataset.

Overall, **YouTube Leads Generator - B2B & B2C Email Finder (Free 100 Emails)** helps you go from keyword ideas to an actionable prospect list—quickly and in one run.

***

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

There are plenty of ways to pull data from YouTube—here’s why this one stands out for lead generation workflows.

#### Built for outreach-ready results (not just discovery)

This tool focuses on contact extraction plus channel context, so you get the emails and the metadata you need for personalization in influencer marketing and sales emails.

#### Clear free-tier value with a defined cap

The free tier is capped at **100 emails total per run**, which makes it easy to test the YouTube email finder workflow without committing to a larger scraping job.

#### Simple configuration for B2B and B2C prospecting

With just `keywords`, `country`, `maxLeadsPerKeyword`, and `scrapeLeadsWithEmail`, you can switch between “collect all matching channels” and “only channels with emails”—a practical fit for both B2B email finder tool and B2C email finder use cases.

***

### Real-World Use Cases

Here's how different teams put YouTube Leads Generator - B2B & B2C Email Finder (Free 100 Emails) to work:

**Sales Development Teams**\
Your reps start with a list of industry keywords, then run the actor to generate a cold email list generator-style dataset. You get emails plus subscriber and joined-date signals, making it easier to prioritize YouTube business leads before you send your first message.

**Influencer Marketing Managers**\
Instead of manually browsing creator pages to find contact info, you run the YouTube lead generator with `scrapeLeadsWithEmail: true` to keep only email-confirmed channels. The result: a faster shortlist for sponsorship outreach with better personalization from the channel description.

**Market Researchers & Data Analysts**\
You use the dataset to study creator ecosystems by keyword and country, then correlate channel size (subscribers/videos) with the presence of published contact emails. The included `keyword` field makes it straightforward to segment results by your YouTube sales leads targeting strategy.

**Automation & Integration Specialists**\
You schedule runs and pipe the dataset into downstream tools, using the structured fields to keep your pipeline consistent. This makes it easier to build repeatable prospecting email finder workflows across teams without reformatting each output.

**Freelance Researchers**\
Client briefs often require “find emails from YouTube” with clean, import-ready data. You run the actor, export the results, and deliver a ready-to-use lead list with both contact emails and channel metadata for vetting.

***

### How to Run It

No code required. Here's how to get your first results in under 5 minutes:

1. **Open the actor on Apify** — go to [console.apify.com](https://console.apify.com) and find **YouTube Leads Generator - B2B & B2C Email Finder (Free 100 Emails)**.
2. **Enter your inputs** — add your `keywords`, optionally set `country`, adjust `maxLeadsPerKeyword`, and choose `scrapeLeadsWithEmail`.
3. **Configure proxy settings (optional but recommended)** — use Apify’s proxy support for more reliable scraping at scale.
4. **Start the run and watch the live log** — follow progress as the actor processes each keyword.
5. **Open the Dataset tab** — results are written to the dataset as channels are processed.
6. **Export your results** — download JSON, CSV, or Excel from the dataset tab.
7. **Repeat with refined keywords** — test variations to improve lead quality and reduce non-contact results.

The whole setup takes under 5 minutes—results start appearing within seconds of launch.

***

### Export & Integration Options

Once your data is collected, YouTube Leads Generator - B2B & B2C Email Finder (Free 100 Emails) fits directly into your existing workflow.

You can export your dataset from the Apify dashboard in common formats like JSON, CSV, or Excel.

For operational workflows, you can connect via Apify’s API to pull results programmatically, and you can automate follow-up steps with tools like Zapier/Make or via webhooks when a run completes.

***

### Pricing

YouTube Leads Generator - B2B & B2C Email Finder (Free 100 Emails) runs on Apify, which includes a **free tier** — no credit card needed to start. The free tier is capped at **100 emails per run**, making it easy to validate the YouTube email finder workflow on real data. For heavier workloads, Apify offers paid options and pay-as-you-go compute—check Apify pricing for the latest plan details. Start free at [apify.com](https://apify.com) — scale up when you need to.

***

### Reliability & Limitations

| What We Handle | How |
|---|---|
| Lead limits | Free users are capped at **100 emails total per run**; `maxLeadsPerKeyword` limits per keyword. |
| Scraping resilience | Includes retries and fallbacks for resilience. |
| Contact completeness | Optionally filters to channels that include emails in their description via `scrapeLeadsWithEmail`. |
| Partial failures | Output records include `success` and `error_message`, and successful leads are still saved. |
| Targeting flexibility | Uses your `keywords` and `country` selection to shape results. |

**Limitations:** The actor extracts contact details only from publicly available information published for channels. If channels do not include emails in their description, `scrapeLeadsWithEmail: true` will naturally reduce results. Login-gated or non-public content is out of scope.

For enterprise-scale needs or custom configurations, reach out and we’ll help.

***

### Frequently Asked Questions

#### Is there a free plan?

Yes. The actor supports a free tier, and free runs are capped at **100 emails total per run**. That makes it a practical YouTube lead generator for quick testing and early prospect lists.

#### Do I need to log in or create an account on YouTube?

No. This actor is designed to work with public, viewable channel information and does not require you to provide YouTube login credentials.

#### How accurate is the extracted data?

The email extraction accuracy depends on what the channel publishes in publicly available channel description and related visible content. The actor does not guess—emails are extracted from the content it can read during the scrape.

#### How many results can I get per run?

You control how many leads are collected per keyword using `maxLeadsPerKeyword`. Additionally, free users are capped at **100 emails total per run**, while paid users can run without that hard cap.

#### How fresh is the data?

Data freshness depends on how recently the channel content was published and what’s currently accessible. If a channel updates its description or contact details, subsequent runs can reflect those changes.

#### Is this legal? Does it comply with GDPR / CCPA?

The actor works on **publicly available data**. Whether it complies with GDPR, CCPA, and relevant spam rules for your specific use depends on your processes and consent framework—make sure you use the data responsibly.

#### Can I export to Google Sheets or Excel?

Yes. You can export your dataset from the Apify dashboard, including JSON and formats you can open in spreadsheets. From there, you can import into tools like Excel and Google Sheets using standard workflows.

#### Can I schedule this to run automatically?

Yes. Apify supports scheduled runs so you can automate repeated lead generation runs based on your inputs and targeting needs.

#### Can I access results via the API?

Yes. You can pull results programmatically using Apify API integrations. This is useful for building repeatable workflows for cold email list generator-style pipelines.

#### What happens when the actor encounters an error?

Each record includes `success` and `error_message`, so you can see which channels were processed successfully. Failed channels won’t stop successful results from being written to your dataset.

***

### Get Help & Use Responsibly

Got a question about YouTube Leads Generator - B2B & B2C Email Finder (Free 100 Emails) or a feature you'd like added? Reach out at <dataforleads@gmail.com>. We’re happy to help with troubleshooting and can also discuss feature ideas like improving email filtering logic or adding more export-friendly fields for your outreach workflow.

**This actor collects data only from publicly available data.** It does not access private accounts, login-gated pages, or password-protected content. You are responsible for complying with GDPR, CCPA, spam regulations, and the platform’s Terms of Service when using the exported results. For data removal requests, contact <dataforleads@gmail.com>. Use responsibly, ethically, and only for lawful purposes.

# 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("scrapevanta/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("scrapevanta/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 scrapevanta/youtube-leads-generator --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=scrapevanta/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 extracts targeted business and creator data from YouTube, helping you find high-quality leads fast. Collect channel details, emails, social links, subscriber counts, and contact information to power outreach, sales, marketing, and lead generation campaigns.",
        "version": "1.0",
        "x-build-id": "X562IKT2uha4P3bPR"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapevanta~youtube-leads-generator/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapevanta-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/scrapevanta~youtube-leads-generator/runs": {
            "post": {
                "operationId": "runs-sync-scrapevanta-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/scrapevanta~youtube-leads-generator/run-sync": {
            "post": {
                "operationId": "run-sync-scrapevanta-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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
