# Mass Youtube Channel Email Scraper (`scraperoka/mass-youtube-channel-email-scraper`) Actor

📧 Mass YouTube Channel Email Scraper extracts verified contact emails from YouTube channels at scale. 🚀 Perfect for B2B lead gen, outreach, and market research. Save time, boost response rates, and streamline your workflow.

- **URL**: https://apify.com/scraperoka/mass-youtube-channel-email-scraper.md
- **Developed by:** [Scraperoka](https://apify.com/scraperoka) (community)
- **Categories:** Lead generation, Automation, Social media
- **Stats:** 1 total users, 0 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.01 / 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 🚀

Manually visiting hundreds of YouTube channels to collect contact emails wastes hours you don’t have. **YouTube Leads Generator - B2B & B2C Email Finder** finds relevant channels by your keywords and extracts contact information in bulk. This YouTube lead generation tool is ideal for marketers, recruiters, and growth teams building lead lists fast, reaching thousands of records in minutes.

---

### What You Get: Sample Output

Here's a sample record from a single run:

```json
{
  "keyword": "fitness coach",
  "channel_name": "Active Fitness Daily",
  "channel_handle": "activefitnessdaily",
  "emails": ["coach@activefitnessdaily.com", "support@activefitnessdaily.com"],
  "channel_url": "https://www.youtube.com/@activefitnessdaily/about",
  "subscriber_count": "128K subscribers",
  "video_count": "2,340 videos",
  "joined_date": "Joined March 2016",
  "channel_description": "Strength training, nutrition tips, and coaching updates. 📩 coach@activefitnessdaily.com",
  "social_links": {
    "instagram": "https://instagram.com/activefitnessdaily",
    "linkedin": "https://linkedin.com/company/activefitnessdaily"
  },
  "custom_url": "https://www.youtube.com/@activefitnessdaily",
  "avatar_url": "https://yt3.ggpht.com/abc123=s88-c-k-c0x00ffffff-no-rj",
  "success": true,
  "error_message": null
}
````

| Field | Type | What It Tells You |
|---|---|---|
| `keyword` | string | Which keyword you used to discover this channel |
| `channel_name` | string | The channel’s display name for outreach personalization |
| `channel_handle` | string | The channel handle you can reuse in prospecting workflows |
| `emails` | array | All email addresses detected for this channel (great for multi-touch sequences) |
| `channel_url` | string | Direct link to the channel page for quick verification |
| `subscriber_count` | string | Audience size signal for lead prioritization |
| `video_count` | string | Output volume to estimate content cadence |
| `joined_date` | string | “Tenure” signal for relationship-building context |
| `channel_description` | string | Channel bio text (useful for segmentation and messaging) |
| `social_links` | object | Additional social profiles found from the channel about section |
| `custom_url` | string | The channel’s custom URL value (when available) |
| `avatar_url` | string | Avatar image URL for dashboard previews and enrichment pipelines |
| `success` | boolean | Whether the actor successfully produced a meaningful scrape result |
| `error_message` | string | Failure details when scraping didn’t succeed |

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

***

### Why YouTube Leads Generator - B2B & B2C Email Finder?

There are a lot of ways to pull data from YouTube — here’s what sets YouTube Leads Generator - B2B & B2C Email Finder apart.

#### Keyword-driven discovery for lead lists

You provide `keywords`, and the actor searches for YouTube channels per keyword, then enriches them right away. This YouTube leads email finder approach is built for building targeted pipelines instead of one-off lookups.

#### Email-first mode for B2B and outreach workflows

You can enable `scrapeLeadsWithEmail` to focus on channels that have emails present in their publicly available descriptions. That makes it especially useful for YouTube to email outreach, targeted email prospecting tool workflows, and B2B YouTube prospecting.

#### Complete channel + contact enrichment in one dataset

Each lead record includes channel metadata (name, handle, URL, subscriber/video counts, joined date, description) plus `emails` and `social_links` when available. The result is a YouTube scraper for lead generation that’s structured for exporting and importing into CRMs.

#### Resilient processing with retries and fallbacks

The actor includes retry logic and handles errors during fetching and enrichment, so you keep good coverage even when individual requests fail. This reliability helps when you’re collecting YouTube leads database-style datasets at scale.

***

### Configuring Your Run

Drop this into your `input.json` to get started:

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

| Parameter | Required | What It Does |
|---|---|---|
| `keywords` | ✅ | A list of keywords to search for YouTube channels. Each keyword is searched separately. |
| `country` | ⬜ | Filters results by country. Leave empty for worldwide results. |
| `maxLeadsPerKeyword` | ⬜ | Caps how many leads to collect for each keyword (1–500). |
| `scrapeLeadsWithEmail` | ⬜ | When enabled, the actor focuses on channels that have emails in their description; when disabled, it collects all channels matching your keywords. |

***

### Core Capabilities

#### Keyword-based lead discovery

YouTube Leads Generator - B2B & B2C Email Finder lets you generate leads by feeding in a set of `keywords`. It processes each keyword and aggregates leads into a single dataset so you can compare results across themes like “YouTube lead generation tool niches” (fitness, tech, gaming, and more).

#### B2B and B2C email extraction from channel text

When `scrapeLeadsWithEmail` is enabled, the actor extracts email addresses that appear in publicly available channel descriptions and related text it can access. This supports both B2C email extraction from YouTube and B2B contact email lookup use cases with clean, structured email arrays.

#### Structured output built for exporting

Every completed lead is written to the dataset with consistent fields such as `channel_name`, `channel_url`, `emails`, `subscriber_count`, `video_count`, `joined_date`, `channel_description`, `social_links`, `custom_url`, and `avatar_url`. That makes it easy to build a YouTube leads database and move it into spreadsheets or CRMs.

#### Resilience for real-world scraping runs

The actor includes retries and uses fallbacks so individual request failures don’t automatically ruin your entire run. This helps when you’re generating targeted email prospecting tool lists and want dependable coverage.

#### Scale via bulk processing per keyword

You control volume with `maxLeadsPerKeyword`, then run multiple keywords in one job. This is a practical way to go from keyword list → outreach-ready dataset without manual channel review.

**Overall:** YouTube Leads Generator - B2B & B2C Email Finder turns YouTube channel discovery into export-ready contact data for outreach at scale.

***

### Who Gets the Most Out of This

Here’s how different teams put YouTube Leads Generator - B2B & B2C Email Finder to work:

**Sales Development Representatives** — They use scrapeLeadsWithEmail to build a list of prospects with real contact emails, then prioritize by `subscriber_count` and `video_count` so outreach is faster and more targeted. The outcome is an email-ready prospect list built for multi-touch sequences rather than manual channel scraping.

**Marketing and Growth Teams** — They combine multiple `keywords` to cover different audience segments and capture channel context from `channel_description` and `social_links`. This supports lead generation via YouTube with better personalization because you’re not starting from scratch.

**Recruiters and Talent Sourcers** — They generate B2C and B2B leads where relevant—collecting emails and channel identity fields to streamline outreach. Instead of searching one channel at a time, they build a structured dataset for faster sourcing.

**Data Analysts and Researchers** — They export the dataset and run analysis on channel attributes like `joined_date`, subscriber size, and email availability. This makes it easy to quantify where email presence is most common for specific niches, supporting “find emails from YouTube channels” research workflows.

**Developers and Automation Specialists** — They trigger the YouTube scraper for lead generation as an automated job, then push dataset outputs to downstream systems. The consistent JSON structure makes it straightforward to integrate YouTube prospecting with email verification-style outreach pipelines.

***

### Step-by-Step: How to Use It

No coding needed. Here's how to run YouTube Leads Generator - B2B & B2C Email Finder from start to finish:

1. **Open the actor on Apify** — visit [console.apify.com](https://console.apify.com) and open **YouTube Leads Generator - B2B & B2C Email Finder**.
2. **Enter your inputs** — set `keywords`, optionally choose `country`, set `maxLeadsPerKeyword`, and enable/disable `scrapeLeadsWithEmail` based on whether you want emails-only leads.
3. **Configure proxy settings** — use the run’s proxy options for better reliability during bulk scraping.
4. **Hit Run and watch the live log** — monitor progress per keyword and watch for any logged failures.
5. **View results in the dataset tab** — each lead is saved with channel fields plus extracted `emails` (when available).
6. **Export as JSON, CSV, or Excel** — download your dataset in the format that fits your workflow.

The whole process takes under 5 minutes to set up.

***

### Integrations & Export Options

Once your data is collected, YouTube Leads Generator - B2B & B2C Email Finder plugs directly into your existing workflow.

You can download results from the Apify dataset tab in common formats like JSON, CSV, and Excel. This is ideal when you’re using a YouTube leads email finder for outreach list building and need quick import into spreadsheets or your CRM.

For automation and orchestration, you can use Apify’s API access and webhooks to trigger downstream steps programmatically, and connect to no-code tools like Zapier or Make for automated routing, enrichment, and notifications. For deeper setup options, refer to Apify’s API and automation documentation at https://apify.com/docs/api.

***

### Pricing & Free Trial

YouTube Leads Generator - B2B & B2C Email Finder runs on the Apify platform, which offers a **free tier** — no credit card required to get started. Free tier usage is limited by platform credits, which is enough for several test runs and validation of your email extraction results. For larger lists, you’ll pay as you go based on Apify’s compute usage, and you can scale using Apify’s plans when you’re running heavy workloads. Start for free at [apify.com](https://apify.com) and scale when you’re ready.

***

### Reliability & Performance

| What We Handle | How |
|---|---|
| Rate limiting | Retries with backoff when responses indicate temporary issues |
| Fetch failures | Retries up to the configured maximum during enrichment steps |
| Partial results | Captured records are written as they’re processed |
| Data completeness | Produces structured channel metadata and contact fields when available |
| Error visibility | Includes `success` and `error_message` in records when failures occur |
| Scale by volume control | You cap work with `maxLeadsPerKeyword` and run multiple `keywords` |

**Limitations:** The actor only processes leads from publicly accessible sources; it can’t access login-gated or protected pages. Some channels may not contain email addresses in their publicly available descriptions, so email arrays can be empty depending on your targets.

For enterprise-scale runs, contact us to discuss custom configurations.

***

### Frequently Asked Questions

#### Is there a free plan or trial?

Yes, Apify provides a **free tier** for trying actors without a credit card. You can use it to validate how many emails you get per keyword before scaling up.

#### Do I need to log in to YouTube to use this?

No. This actor works with publicly available YouTube channel information and does not require an account or login to run.

#### How accurate is the data?

The extracted fields reflect what is publicly available and present in the channel information the actor reads. Email accuracy depends on what the channel owner publishes, so results can vary by niche and channel completeness.

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

You control the cap with `maxLeadsPerKeyword` (1–500). The actor processes each keyword separately until it reaches the limit for that keyword.

#### How often is the data updated / how fresh is it?

The dataset reflects the state at the time the actor runs. If you need fresher leads, schedule recurring runs and rebuild your dataset regularly.

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

You should evaluate legal compliance for your use case. The actor processes **publicly available data**, and it’s your responsibility to comply with GDPR/CCPA and applicable platform terms when storing and using contact data.

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

Yes. You can export the Apify dataset from the dashboard as JSON, CSV, or Excel, then import into Google Sheets or your preferred spreadsheet/CRM workflow.

#### Can I run this on a schedule automatically?

Yes. You can schedule actor runs using Apify’s built-in scheduling capabilities and automation tools, then refresh your YouTube leads database on a cadence.

#### Can I access this via API?

Yes. Apify supports programmatic access to actor runs and datasets via the Apify API. This is useful for automation pipelines that ingest the results automatically.

#### What happens if the actor hits an error?

If scraping or enrichment fails for a specific channel, the output includes failure-state details using fields like `success` and `error_message`. The run is designed to continue processing other leads rather than stopping entirely.

***

### Need Help or Have a Request?

Got a question about YouTube Leads Generator - B2B & B2C Email Finder or want a new feature added? Reach out at <dataforleads@gmail.com>. We’re happy to help with setup questions and we actively maintain this actor based on user feedback. Feature ideas we can consider include batch CSV upload and webhook notifications on completion.

***

### Disclaimer & Responsible Use

*YouTube Leads Generator - B2B & B2C Email Finder is the fastest, most reliable way to build outreach-ready YouTube lead datasets — start your free run today.*

This actor collects **publicly available data** from YouTube channels and does not access private accounts, login-gated content, or password-protected pages. You are responsible for complying with GDPR, CCPA, applicable privacy regulations, and platform Terms of Service for your specific use. 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'). Each keyword will be searched separately.

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

Filter results by country. Leave empty for worldwide results.

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

Maximum number of leads to collect for each keyword (1-500).

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

If enabled, will search for channels that have emails in their description (using common email providers like Gmail, Hotmail, Outlook, Yahoo). If disabled, will find all channels matching keywords.

## 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("scraperoka/mass-youtube-channel-email-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": ["fitness"],
    "country": "United States",
    "maxLeadsPerKeyword": 20,
}

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Mass Youtube Channel Email Scraper",
        "description": "📧 Mass YouTube Channel Email Scraper extracts verified contact emails from YouTube channels at scale. 🚀 Perfect for B2B lead gen, outreach, and market research. Save time, boost response rates, and streamline your workflow.",
        "version": "1.0",
        "x-build-id": "HJO53Apjd8Ky9BxcC"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scraperoka~mass-youtube-channel-email-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scraperoka-mass-youtube-channel-email-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/scraperoka~mass-youtube-channel-email-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scraperoka-mass-youtube-channel-email-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/scraperoka~mass-youtube-channel-email-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scraperoka-mass-youtube-channel-email-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": "Search Keywords",
                        "minItems": 1,
                        "uniqueItems": true,
                        "type": "array",
                        "description": "List of keywords to search for YouTube channels (e.g., 'tech reviewer', 'fitness', 'gaming'). Each keyword will be searched separately.",
                        "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": "Filter results by country. Leave empty for worldwide results.",
                        "default": "United States"
                    },
                    "maxLeadsPerKeyword": {
                        "title": "Maximum Leads Per Keyword",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Maximum number of leads to collect for each keyword (1-500).",
                        "default": 20
                    },
                    "scrapeLeadsWithEmail": {
                        "title": "Find Leads with Email Only",
                        "type": "boolean",
                        "description": "If enabled, will search for channels that have emails in their description (using common email providers like Gmail, Hotmail, Outlook, Yahoo). If disabled, will find all channels matching keywords.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
