# YouTube Email Scraper — Channels, Keywords & Niches (`brilliant_gum/youtube-email-scraper`) Actor

Find verified creator emails from any YouTube channel — by keyword search, niche, or direct URL. Extracts emails from descriptions, Linktree, external websites & contact pages. Includes contactability scoring, social links, channel metadata, and analytics report. No API key needed.

- **URL**: https://apify.com/brilliant\_gum/youtube-email-scraper.md
- **Developed by:** [Yuliia Kulakova](https://apify.com/brilliant_gum) (community)
- **Categories:** Social media, Lead generation
- **Stats:** 2 total users, 1 monthly users, 70.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $35.00 / 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 Email Scraper — Find Creator Contact Emails at Scale

![YouTube Email Scraper](https://i.imgur.com/11msXY0.png)

> **Find the right creators. Get their real emails. Start the conversation.**
> The fastest way to build targeted outreach lists from YouTube — no API key, no browser, no manual work.

---

### The Problem

You need to reach YouTube creators for brand deals, sponsorships, or partnerships. But finding their actual contact emails is painful — buried in descriptions, scattered across Linktree pages, hidden on personal websites, or obfuscated with `[at]` and `(dot)` tricks. Doing it manually takes hours. Hiring a VA takes days. Other tools miss half the emails or give you garbage addresses.

### The Solution

This scraper does what a team of researchers would do — but in minutes, not days. Give it keywords, niches, or channel URLs, and it digs through every possible source to find verified creator emails. It checks channel descriptions, follows Linktree and Beacons links, visits personal websites, scans /contact pages — and filters out the junk so you only get emails that actually reach someone.

---

### How It Works

**Step 1 — Tell it who you're looking for**

Three ways to find channels:
- **Keywords** — search YouTube like a user would (`"vegan cooking"`, `"tech review"`, `"fitness motivation"`)
- **Niches** — pick from 20 built-in categories (gaming, beauty, finance, education, travel, and more)
- **Direct URLs** — paste specific channel URLs you already have

**Step 2 — The scraper goes to work**

For every channel it finds, the scraper:
- Reads the full channel description for emails and social links
- Follows Linktree, Beacons, Bio.link, and 15+ other link aggregators
- Visits external websites linked from the channel page
- Checks /contact, /about, and /reach pages on those sites
- Decodes obfuscated emails (`business [at] creator [dot] com` → `business@creator.com`)
- Scores every email for contactability (0–100)
- Removes garbage: noreply@, info@, support@, and disposable domains

**Step 3 — You get a clean, ready-to-use list**

Every result includes the email, where it was found, how likely it is to reach a real person, plus full channel metadata — subscribers, video count, social links, website links, and more.

---

### What Makes This Different

| | Other scrapers | This scraper |
|---|---|---|
| Email from channel description | ✅ | ✅ |
| Linktree / Beacons / link aggregators | ❌ | ✅ |
| External website crawling | ❌ | ✅ |
| /contact page scanning | ❌ | ✅ |
| Email deobfuscation | ❌ | ✅ |
| Contactability scoring | ❌ | ✅ |
| Role email filtering | ❌ | ✅ |
| Social links extraction | ❌ | ✅ |
| Analytics & insights report | ❌ | ✅ |
| Works without API key | Sometimes | ✅ Always |

Most scrapers only grab emails from the channel description. That misses 30–40% of available contacts. This scraper follows every link trail — descriptions, link aggregators, personal sites, contact pages — so you get the most complete list possible.

---

### Who Is This For

- **Influencer marketing agencies** — build targeted outreach lists of creators in any niche, filtered by subscriber count, country, and contactability score
- **Brand partnership managers** — find the right micro and mid-tier creators for sponsorship campaigns without spending hours on manual research
- **PR & communications teams** — identify YouTubers covering your industry for product launches, press coverage, and reviews
- **Podcast booking agents** — discover YouTube creators who also host podcasts, with verified contact info ready for outreach
- **Talent agencies & MCNs** — scout unsigned creators with real contact details, not just DMs that get buried
- **SaaS & app companies** — find creators who review tools in your category for authentic product integrations
- **E-commerce brands** — build influencer affiliate programs by finding creators in your product niche who are open to partnerships

---

### Smart Filters — Get Exactly Who You Need

**Target by audience size:**
- Set subscriber minimums and maximums to focus on micro-influencers (10K–100K), mid-tier (100K–1M), or major channels (1M+)

**Filter by quality:**
- Contactability score threshold — only get emails that are likely to reach a real person
- Exclude role emails — skip generic addresses like info@, contact@, noreply@
- Email domain filter — target only gmail.com, custom domains, or specific providers

**Focus by geography:**
- Country filter — build region-specific lists for local campaigns

---

### Example: Find Fitness Creators for a Brand Deal

```json
{
    "searchKeywords": ["fitness motivation", "home workout"],
    "niches": ["fitness"],
    "maxChannelsPerSource": 50,
    "minSubscribers": 10000,
    "maxSubscribers": 500000,
    "excludeRoleEmails": true,
    "minContactabilityScore": 40,
    "followExternalLinks": true,
    "followLinktree": true,
    "includeAnalytics": true
}
````

### What You Get Back

```json
{
    "channelTitle": "Marques Brownlee",
    "channelHandle": "@mkbhd",
    "channelUrl": "https://www.youtube.com/@mkbhd",
    "emails": ["business@mkbhd.com"],
    "primaryEmail": "business@mkbhd.com",
    "emailSources": {
        "business@mkbhd.com": "description"
    },
    "contactabilityScore": 85,
    "hasEmail": true,
    "subscriberCount": 21000000,
    "subscriberText": "21M subscribers",
    "videoCount": 1800,
    "socialLinks": {},
    "websiteLinks": []
}
```

Every channel comes with:

- **Verified emails** sorted by contactability score, with the best one marked as `primaryEmail`
- **Email source tracking** — know exactly where each email was found (description, Linktree, website, /contact page)
- **Contactability score** (0–100) — prioritize your outreach by who's most likely to respond
- **Full channel metadata** — subscribers, video count, country, keywords, social links, website links
- **Niche/keyword matching** — see which search term or niche category found each channel

***

### Built-In Analytics Report

Every run generates a comprehensive insights report saved to the Key-Value store:

- **Email hit rate** — what percentage of channels had a reachable email
- **Source breakdown** — which extraction method found the most emails (description vs Linktree vs website)
- **Top email domains** — gmail.com, yahoo.com, custom domains distribution
- **Subscriber distribution** — email availability across micro, mid-tier, and macro channels
- **Contactability distribution** — how many high, medium, and low-quality contacts you found
- **Keyword performance** — which search terms delivered the best results

Use these insights to optimize your next run and focus on the keywords and niches that deliver the highest email hit rate.

***

### Tips for Best Results

**Targeting micro-influencers?** Set `minSubscribers: 10000` and `maxSubscribers: 500000`. Micro and mid-tier creators respond to outreach 3–5x more than major channels. Enable `excludeRoleEmails: true` and `minContactabilityScore: 50` for a clean, actionable list.

**Want maximum email coverage?** Keep both `followExternalLinks` and `followLinktree` enabled. Multi-source extraction typically boosts your email hit rate by 15–25% compared to description-only approaches.

**Running a large campaign?** For 500+ channels, set `requestDelayMs: 2000` and split into multiple runs of 100–200 channels each. This keeps results reliable and avoids rate limiting.

**Combining niches + keywords?** Use both for laser-targeted results. For example, niche `gaming` + keyword `"Minecraft tutorial"` finds gaming channels specifically about Minecraft, not general gaming commentary.

**Understanding contactability scores:**

- **70–100** — Strong. Personal or business email found in description or Linktree. High response probability.
- **40–70** — Good. Found on external website, may be a team inbox. Still worth reaching out.
- **0–40** — Low. Generic role email or found deep on a site. Consider as a backup.

***

### Pricing

| Event | Price |
|---|---|
| Channel scraped (with email extraction & enrichment) | **$0.035** |
| Actor start | **$0.01** |

*Residential proxies are included in the run cost via Apify platform. No additional proxy setup needed.*

***

### Lightweight & Cost-Efficient

Unlike competitors that spin up heavyweight Chromium browsers (1–4 GB RAM per run), this scraper runs on pure HTTP requests with just **512 MB of memory**. That means faster runs, lower compute costs, and more channels scraped per dollar.

No YouTube API key required. No browser. No OAuth. Just results.

***

*This Actor accesses only publicly available YouTube data — the same information visible to anyone browsing YouTube without an account. No authentication or private data is accessed. Please use responsibly and in compliance with applicable laws and platform policies.*

# Actor input Schema

## `startUrls` (type: `array`):

Direct YouTube channel URLs (e.g. https://www.youtube.com/@mkbhd) or YouTube search result URLs. Each URL is scraped individually.

## `searchKeywords` (type: `array`):

Keywords to search YouTube for channels (e.g. \["gaming tutorial", "vegan cooking"]). Finds channels matching these terms and extracts their contact emails.

## `niches` (type: `array`):

Predefined niche categories to search for channels. Available values: gaming, cooking, technology, beauty, fitness, travel, music, finance, education, comedy, fashion, sports, pets, diy, health, business, art, photography, automotive, food. Combines with searchKeywords if both are provided.

## `maxChannelsPerSource` (type: `integer`):

Maximum number of channels to process per keyword or niche. Higher values = more emails but longer runtime.

## `minSubscribers` (type: `integer`):

Skip channels with fewer subscribers than this value. 0 = no minimum.

## `maxSubscribers` (type: `integer`):

Skip channels with more subscribers than this value. 0 = no maximum. Useful for targeting micro-influencers.

## `countryFilter` (type: `array`):

Only include channels from these countries (e.g. \["United States", "United Kingdom"]). Leave empty to include all countries.

## `emailDomainFilter` (type: `array`):

Only include emails from these domains (e.g. \["gmail.com", "yahoo.com"]). Leave empty to include all domains.

## `excludeRoleEmails` (type: `boolean`):

Skip generic addresses like info@, contact@, noreply@, support@. These rarely lead to the creator directly.

## `minContactabilityScore` (type: `integer`):

Only include emails with a contactability score at or above this threshold (0-100). Higher = more likely to reach a real person.

## `followExternalLinks` (type: `boolean`):

Visit linked websites listed on channel pages to find additional contact emails. Increases hit rate by ~20%. Adds time per channel.

## `followLinktree` (type: `boolean`):

Follow link aggregator pages (Linktree, Beacons, Bio.link, etc.) to extract emails. These often contain business contact info.

## `includeAnalytics` (type: `boolean`):

Generate a comprehensive insights report (email hit rate, source breakdown, top domains, subscriber distribution) and save to Key-Value store as ANALYTICS.

## `proxyConfiguration` (type: `object`):

YouTube blocks datacenter IPs. Apify Residential proxy is strongly recommended for reliable results.

## `requestDelayMs` (type: `integer`):

Milliseconds to wait between requests to YouTube. Increase to 2000+ for large runs to avoid rate limiting.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.youtube.com/@MrBeast"
    }
  ],
  "searchKeywords": [],
  "niches": [],
  "maxChannelsPerSource": 50,
  "minSubscribers": 0,
  "maxSubscribers": 0,
  "countryFilter": [],
  "emailDomainFilter": [],
  "excludeRoleEmails": false,
  "minContactabilityScore": 0,
  "followExternalLinks": true,
  "followLinktree": true,
  "includeAnalytics": true,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  },
  "requestDelayMs": 1500
}
```

# Actor output Schema

## `results` (type: `string`):

No description

# 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 = {
    "startUrls": [
        {
            "url": "https://www.youtube.com/@MrBeast"
        }
    ],
    "searchKeywords": [],
    "niches": [],
    "countryFilter": [],
    "emailDomainFilter": [],
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("brilliant_gum/youtube-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 = {
    "startUrls": [{ "url": "https://www.youtube.com/@MrBeast" }],
    "searchKeywords": [],
    "niches": [],
    "countryFilter": [],
    "emailDomainFilter": [],
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("brilliant_gum/youtube-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 '{
  "startUrls": [
    {
      "url": "https://www.youtube.com/@MrBeast"
    }
  ],
  "searchKeywords": [],
  "niches": [],
  "countryFilter": [],
  "emailDomainFilter": [],
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call brilliant_gum/youtube-email-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "YouTube Email Scraper — Channels, Keywords & Niches",
        "description": "Find verified creator emails from any YouTube channel — by keyword search, niche, or direct URL. Extracts emails from descriptions, Linktree, external websites & contact pages. Includes contactability scoring, social links, channel metadata, and analytics report. No API key needed.",
        "version": "1.0",
        "x-build-id": "4bSn9EKYEvyUfpcqg"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/brilliant_gum~youtube-email-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-brilliant_gum-youtube-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/brilliant_gum~youtube-email-scraper/runs": {
            "post": {
                "operationId": "runs-sync-brilliant_gum-youtube-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/brilliant_gum~youtube-email-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-brilliant_gum-youtube-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",
                "properties": {
                    "startUrls": {
                        "title": "Channel / Search URLs",
                        "type": "array",
                        "description": "Direct YouTube channel URLs (e.g. https://www.youtube.com/@mkbhd) or YouTube search result URLs. Each URL is scraped individually.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "searchKeywords": {
                        "title": "Search Keywords",
                        "type": "array",
                        "description": "Keywords to search YouTube for channels (e.g. [\"gaming tutorial\", \"vegan cooking\"]). Finds channels matching these terms and extracts their contact emails.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "niches": {
                        "title": "Niche Categories",
                        "type": "array",
                        "description": "Predefined niche categories to search for channels. Available values: gaming, cooking, technology, beauty, fitness, travel, music, finance, education, comedy, fashion, sports, pets, diy, health, business, art, photography, automotive, food. Combines with searchKeywords if both are provided.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxChannelsPerSource": {
                        "title": "Max channels per source",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Maximum number of channels to process per keyword or niche. Higher values = more emails but longer runtime.",
                        "default": 50
                    },
                    "minSubscribers": {
                        "title": "Min subscribers",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Skip channels with fewer subscribers than this value. 0 = no minimum.",
                        "default": 0
                    },
                    "maxSubscribers": {
                        "title": "Max subscribers",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Skip channels with more subscribers than this value. 0 = no maximum. Useful for targeting micro-influencers.",
                        "default": 0
                    },
                    "countryFilter": {
                        "title": "Country filter",
                        "type": "array",
                        "description": "Only include channels from these countries (e.g. [\"United States\", \"United Kingdom\"]). Leave empty to include all countries.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "emailDomainFilter": {
                        "title": "Email domain filter",
                        "type": "array",
                        "description": "Only include emails from these domains (e.g. [\"gmail.com\", \"yahoo.com\"]). Leave empty to include all domains.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "excludeRoleEmails": {
                        "title": "Exclude role/generic emails",
                        "type": "boolean",
                        "description": "Skip generic addresses like info@, contact@, noreply@, support@. These rarely lead to the creator directly.",
                        "default": false
                    },
                    "minContactabilityScore": {
                        "title": "Min contactability score",
                        "minimum": 0,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Only include emails with a contactability score at or above this threshold (0-100). Higher = more likely to reach a real person.",
                        "default": 0
                    },
                    "followExternalLinks": {
                        "title": "Follow external website links",
                        "type": "boolean",
                        "description": "Visit linked websites listed on channel pages to find additional contact emails. Increases hit rate by ~20%. Adds time per channel.",
                        "default": true
                    },
                    "followLinktree": {
                        "title": "Follow Linktree / link aggregators",
                        "type": "boolean",
                        "description": "Follow link aggregator pages (Linktree, Beacons, Bio.link, etc.) to extract emails. These often contain business contact info.",
                        "default": true
                    },
                    "includeAnalytics": {
                        "title": "Include analytics report",
                        "type": "boolean",
                        "description": "Generate a comprehensive insights report (email hit rate, source breakdown, top domains, subscriber distribution) and save to Key-Value store as ANALYTICS.",
                        "default": true
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "YouTube blocks datacenter IPs. Apify Residential proxy is strongly recommended for reliable results."
                    },
                    "requestDelayMs": {
                        "title": "Request delay (ms)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Milliseconds to wait between requests to YouTube. Increase to 2000+ for large runs to avoid rate limiting.",
                        "default": 1500
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
