# Best Youtube Email Scraper (`scraperoka/best-youtube-email-scraper`) Actor

📧 Best YouTube Email Scraper extracts email contacts from YouTube channels and videos quickly and accurately. 🚀 Perfect for lead gen, outreach, and B2B sales—save hours and boost conversions with reliable results.

- **URL**: https://apify.com/scraperoka/best-youtube-email-scraper.md
- **Developed by:** [Scraperoka](https://apify.com/scraperoka) (community)
- **Categories:** Lead generation, Automation, Other
- **Stats:** 2 total users, 1 monthly users, 0.0% runs succeeded, 0 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

### Best Youtube Email Scraper 🎯

Manually hunting for contact emails across YouTube content wastes hours you don’t have. **Best Youtube Email Scraper** automatically extracts business emails at scale, helping you build a targeted list for outreach. This Best Youtube Email Scraper (also known as a best YouTube email scraper and YouTube email extractor tool) is ideal for marketers, recruiters, and growth teams who want thousands of records in minutes.

---

### What You Get: Sample Output

Here's a sample record from a single run:

```json
{
  "keyword": "fitness",
  "title": "Fitness Studio — Contact & Bookings",
  "url": "https://www.youtube.com/@fitnessstudio",
  "description": "For bookings and collaborations, email our team at bookings@fitnessstudio.com.",
  "email": "bookings@fitnessstudio.com",
  "email_domain": "fitnessstudio.com",
  "email_type": "B2B",
  "scrape_from": "Channel",
  "country": "United States",
  "status": "success",
  "error_message": null
}
````

| Field | Type | What It Tells You |
|---|---|---|
| `keyword` | string | Which keyword drove the email discovery (great for campaign attribution) |
| `title` | string | The title of the matched YouTube source for quick context |
| `url` | string | The YouTube link where the email was found, so you can verify quickly |
| `description` | string | The extracted text context (useful for auditing and relevance checks) |
| `email` | string | The actual email address you can use for outreach |
| `email_domain` | string | The organization’s domain for filtering, enrichment, and deduping |
| `email_type` | string | Whether the result is tagged as `B2B` or `B2C` so you can target correctly |
| `scrape_from` | string | Where it was scraped from (All, Channel, Video, Shorts, or Posts) |
| `country` | string | The country focus used for the run |
| `status` | string | Lets you quickly see whether a record is marked as successful or not |
| `error_message` | string | Error details when something goes wrong; `null` when successful |

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

***

### Why Best Youtube Email Scraper?

There are a lot of ways to pull contact data from YouTube — here’s what sets Best Youtube Email Scraper apart.

#### Keyword-led lead discovery

Best Youtube Email Scraper uses your `keywords`, a selected `country`, and your chosen content scope to surface relevant contacts. It’s designed for YouTube lead generation email scraper workflows, so you can go from idea to outreach list faster.

#### Flexible scraping scope (All, Channel, Video, Shorts, Posts)

You can control where to scrape from using `scrapeFrom` — including `All` for broader discovery or a specific mode like `Channel`, `Video`, `Shorts`, or `Posts`. This helps when you need a YouTube contact email scraper approach tailored to your outreach strategy.

#### Email type targeting (B2B vs B2C)

By selecting `emailType`, you can focus results for either `B2B` or `B2C` use cases. That makes it easier to produce a clean YouTube outreach email list aligned to your ICP.

#### Resilient runs with engine choice

Best Youtube Email Scraper offers an `engine` option (`cost-effective` or `legacy`) to fit your performance and reliability needs. It includes retries and fallbacks for resilience, so long jobs like scraping influencer emails from YouTube have a better chance of finishing smoothly.

***

### Configuring Your Run

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

```json
{
  "keywords": ["fitness", "marketing"],
  "country": "United States",
  "scrapeFrom": "All",
  "emailType": "B2B",
  "engine": "legacy",
  "maxEmails": 100
}
```

| Parameter | Required | What It Does |
|---|---|---|
| `keywords` | ✅ | One or more keywords to search for on YouTube |
| `country` | ✅ | The country to target for results (you can pick from a long list of countries) |
| `scrapeFrom` | ✅ | Choose what to scrape: `All`, `Channel`, `Video`, `Shorts`, or `Posts` |
| `emailType` | ✅ | Choose `B2C` or `B2B` so the results fit your outreach type |
| `engine` | ⬜ | Pick `cost-effective` (Cost Effective (New)) or `legacy` (Legacy) depending on your scraping preferences |
| `maxEmails` | ✅ | Set an upper limit on how many emails to collect (helps control scraping time and cost) |

***

### Core Capabilities

#### Built for YouTube outreach email extraction

Best Youtube Email Scraper extracts contact emails and returns structured fields like `email`, `email_domain`, and `email_type`. It’s a practical YouTube data extraction email solution when you need a list you can actually use.

#### Scope control for better relevance

You can narrow results using `scrapeFrom` (Channel, Video, Shorts, or Posts) instead of getting mixed signals. That’s especially helpful when you’re trying to scrape influencer emails from YouTube channels and want cleaner targeting.

#### Controlled volume with `maxEmails`

Use `maxEmails` to manage throughput—ideal for teams who want predictable runs. For larger research projects, you can raise the cap, but keep in mind that higher limits may take longer.

#### Engine choice to match your needs

Select `engine` to balance speed and reliability: `cost-effective` or `legacy`. This makes Best Youtube Email Scraper a solid option whether you’re running a quick test or building a larger YouTube email harvesting software workflow.

#### Clean, dataset-ready output

Results are written to a dataset with consistent fields including `keyword`, `title`, `url`, `description`, `email`, `email_domain`, `email_type`, `scrape_from`, and `country`. This is exactly what you want from a YouTube email extractor tool before you push data into your CRM or spreadsheet.

***

### Who Gets the Most Out of This

Here's how different teams put Best Youtube Email Scraper to work:

**Marketing managers** use it to build a YouTube email outreach list for campaigns tied to specific niches, then filter by `email_type` and `email_domain` before they send. The result is faster experimentation with better targeting, not guesswork.

**Sales development teams** use it to find business emails from relevant YouTube content and compile leads by keyword and country. They leave the manual searching behind and focus on messaging and follow-up.

**Recruiters and talent acquisition leads** benefit when creators and professionals list contact emails publicly, especially for B2B collaboration or booking requests. With `scrapeFrom`, they can focus on the most relevant types of YouTube pages for their search.

**Data analysts and researchers** use the structured dataset fields (`keyword`, `url`, `description`, `email`, `email_domain`, `country`) to measure lead coverage, deduplicate domains, and analyze which keywords perform best. It’s a practical YouTube channel email finder for reporting and evaluation workflows.

**Automation specialists and developers** can run it as part of a scheduled pipeline, then consume the dataset output downstream via Apify integrations or the Apify API for repeatable YouTube lead generation email scraper jobs.

***

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

No coding needed. Here's how to run Best Youtube Email Scraper from start to finish:

1. **Open the actor on Apify** — go to the actor page on Apify (console.apify.com) and find Best Youtube Email Scraper.
2. **Enter your inputs** — fill in `keywords`, `country`, `scrapeFrom`, `emailType`, and `maxEmails` using the tables above.
3. **Configure proxy settings** — set up your run preferences using Apify’s built-in proxy configuration options for reliable scraping at scale.
4. **Hit Run and watch the live log** — monitor progress and ensure the job completes as expected.
5. **View results in the dataset tab** — each dataset record includes fields like `email`, `email_domain`, `email_type`, and `url`.
6. **Export as JSON, CSV, or Excel** — download directly from the dataset tab for immediate analysis or outreach.

The whole process takes under 5 minutes to set up.

***

### Integrations & Export Options

Once your data is collected, Best Youtube Email Scraper plugs directly into your existing workflow.

You can export results from the Apify dataset tab as JSON, CSV, or Excel. That makes it easy to review outputs like `email_domain` and `scrape_from`, then import into spreadsheets or CRMs.

For automation and scaling, you can connect the actor run to downstream systems using Apify’s API capabilities, webhooks, and no-code automation tools like Zapier or Make (details and setup are available in Apify docs). You can also schedule recurring runs for ongoing YouTube email harvesting and lead list refreshes.

***

### Pricing & Free Trial

Best Youtube Email Scraper runs on the Apify platform, which offers a **free tier** — no credit card required to get started. You’ll typically get a small amount of platform credits (enough for several test runs), then scale using Apify’s pay-as-you-go model based on compute units.

For the latest and most accurate Apify plan details and credit amounts, check the pricing page on Apify. Start for free at [apify.com](https://apify.com) and scale when you're ready.

***

### Reliability & Performance

| What We Handle | How |
|---|---|
| Public web variability | Scrapes publicly available sources and returns structured results in a consistent dataset |
| Performance tuning | Supports an `engine` choice to fit different speed vs reliability preferences |
| Long research jobs | Use `maxEmails` to control volume and time per run |
| Resilience | Includes retries and fallbacks to reduce empty-result runs |

Limitations: Best Youtube Email Scraper only works with publicly available contact information. Emails are included only when they’re present in the public sources being scraped, so results can vary by channel, video, or post.

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

***

### Frequently Asked Questions

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

Yes. Apify offers a free tier that you can use to run Best Youtube Email Scraper for initial testing without committing to a paid plan.

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

No. Best Youtube Email Scraper is designed to work with publicly available data, so you don’t need to provide any login credentials.

#### How accurate is the data?

Accuracy depends on what the channel owner has published. The actor extracts emails and includes contextual fields like `description`, along with `url`, so you can review and validate results.

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

You control the maximum number of emails collected using `maxEmails`. If you set a higher value, the run may take longer, and it still isn’t guaranteed you’ll reach that cap if fewer emails are available.

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

The dataset reflects what’s available at the time of the run. If you want fresher data for an ongoing campaign, you can run the actor again on a schedule.

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

This actor is intended for use with **publicly available data**. You’re responsible for ensuring your use complies with GDPR, CCPA, platform terms, and any applicable local laws.

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

Yes. You can export as JSON, CSV, or Excel directly from the Apify dataset tab. You can also connect to tools like Google Sheets using Apify-native integrations or automation via Zapier/Make.

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

Yes. You can schedule actor runs on Apify so your YouTube email lists stay refreshed for ongoing outreach.

#### Can I access this via API?

Yes. You can programmatically access run results via the Apify API; refer to Apify’s API documentation for details.

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

The actor uses resilient behavior (including retries and fallbacks). If a record fails, error details are represented in the dataset fields such as `error_message` (and a `status` value when applicable), so you can monitor and handle partial results.

***

### Need Help or Have a Request?

Got a question about Best Youtube Email Scraper or want a new feature added? Reach out at <dataforleads@gmail.com>. We’re happy to help with setups and can also consider enhancements like webhook notifications on completion and batch CSV upload workflows.

***

### Disclaimer & Responsible Use

*Best Youtube Email Scraper is the fastest, most reliable way to build a targeted YouTube email list — start your free run today.*

This actor collects **publicly available data** from the web and does not access private accounts, login-gated content, or password-protected pages. You’re responsible for ensuring your use complies with GDPR, CCPA, platform terms, and any applicable regulations. For data-removal requests, contact <dataforleads@gmail.com>. Use responsibly, ethically, and only for lawful purposes.

# Actor input Schema

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

Enter one or more keywords to search for on Youtube.

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

Specify the country to target for Google search results.

## `scrapeFrom` (type: `string`):

Choose one option — All, Channel, Video, Shorts, or Posts.

## `emailType` (type: `string`):

Choose one — B2C or B2B.

## `engine` (type: `string`):

Choose scraping engine. 🚀 Cost Effective (New): Uses residential proxies with async requests for faster, cheaper scraping. 🔧 Legacy: Uses GOOGLE\_SERP proxy with traditional selectors - more reliable but slower and more expensive.

## `maxEmails` (type: `integer`):

Enter the maximum number of emails to collect.

## Actor input object example

```json
{
  "keywords": [
    "fitness"
  ],
  "country": "United States",
  "scrapeFrom": "All",
  "emailType": "B2C",
  "engine": "legacy",
  "maxEmails": 20
}
```

# 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"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("scraperoka/best-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 = { "keywords": ["fitness"] }

# Run the Actor and wait for it to finish
run = client.actor("scraperoka/best-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 '{
  "keywords": [
    "fitness"
  ]
}' |
apify call scraperoka/best-youtube-email-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Best Youtube Email Scraper",
        "description": "📧 Best YouTube Email Scraper extracts email contacts from YouTube channels and videos quickly and accurately. 🚀 Perfect for lead gen, outreach, and B2B sales—save hours and boost conversions with reliable results.",
        "version": "1.0",
        "x-build-id": "YztHTdtr69mq0vEvA"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scraperoka~best-youtube-email-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scraperoka-best-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/scraperoka~best-youtube-email-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scraperoka-best-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/scraperoka~best-youtube-email-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scraperoka-best-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",
                "required": [
                    "keywords",
                    "country",
                    "scrapeFrom",
                    "emailType",
                    "maxEmails"
                ],
                "properties": {
                    "keywords": {
                        "title": "Keywords",
                        "type": "array",
                        "description": "Enter one or more keywords to search for on Youtube.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "country": {
                        "title": "Country",
                        "enum": [
                            "United States",
                            "United Kingdom",
                            "Canada",
                            "Australia",
                            "Germany",
                            "France",
                            "India",
                            "Japan",
                            "Brazil",
                            "Italy",
                            "Spain",
                            "Netherlands",
                            "Sweden",
                            "Norway",
                            "Denmark",
                            "Finland",
                            "Poland",
                            "Czech Republic",
                            "Hungary",
                            "Romania",
                            "Bulgaria",
                            "Croatia",
                            "Slovenia",
                            "Slovakia",
                            "Estonia",
                            "Latvia",
                            "Lithuania",
                            "Portugal",
                            "Greece",
                            "Cyprus",
                            "Malta",
                            "Luxembourg",
                            "Ireland",
                            "Belgium",
                            "Austria",
                            "Switzerland",
                            "Liechtenstein",
                            "Iceland",
                            "South Korea",
                            "China",
                            "Mexico",
                            "Argentina",
                            "Chile",
                            "Colombia",
                            "Peru",
                            "Venezuela",
                            "Ecuador",
                            "Uruguay",
                            "Paraguay",
                            "Bolivia",
                            "Guyana",
                            "Suriname",
                            "French Guiana",
                            "Falkland Islands (Malvinas)",
                            "South Georgia and the South Sandwich Islands",
                            "Bonaire, Sint Eustatius and Saba",
                            "Curaçao",
                            "Aruba",
                            "Sint Maarten (Dutch part)",
                            "Turks and Caicos Islands",
                            "British Virgin Islands",
                            "Anguilla",
                            "Montserrat",
                            "Antigua and Barbuda",
                            "Barbados",
                            "Dominica",
                            "Grenada",
                            "Saint Kitts and Nevis",
                            "Saint Lucia",
                            "Saint Vincent and the Grenadines",
                            "Trinidad and Tobago",
                            "Jamaica",
                            "Bahamas",
                            "Belize",
                            "Costa Rica",
                            "Guatemala",
                            "Honduras",
                            "Nicaragua",
                            "Panama",
                            "El Salvador",
                            "Cuba",
                            "Dominican Republic",
                            "Haiti",
                            "Puerto Rico",
                            "U.S. Virgin Islands",
                            "American Samoa",
                            "Guam",
                            "Northern Mariana Islands",
                            "Saudi Arabia",
                            "United Arab Emirates",
                            "Bahrain",
                            "Iraq",
                            "Iran, Islamic Republic of",
                            "Israel",
                            "Jordan",
                            "Kuwait",
                            "Lebanon",
                            "Oman",
                            "Qatar",
                            "Syrian Arab Republic",
                            "Yemen",
                            "Afghanistan",
                            "Bangladesh",
                            "Bhutan",
                            "Maldives",
                            "Nepal",
                            "Pakistan",
                            "Sri Lanka",
                            "Myanmar",
                            "Cambodia",
                            "Lao People's Democratic Republic",
                            "Thailand",
                            "Viet Nam",
                            "Malaysia",
                            "Singapore",
                            "Brunei Darussalam",
                            "Philippines",
                            "Indonesia",
                            "Timor-Leste",
                            "Papua New Guinea",
                            "Fiji",
                            "New Zealand",
                            "Solomon Islands",
                            "Vanuatu",
                            "New Caledonia",
                            "French Polynesia",
                            "Wallis and Futuna",
                            "Samoa",
                            "Tonga",
                            "Tuvalu",
                            "Kiribati",
                            "Nauru",
                            "Federated States of Micronesia",
                            "Marshall Islands",
                            "Palau",
                            "Cook Islands",
                            "Niue",
                            "Tokelau"
                        ],
                        "type": "string",
                        "description": "Specify the country to target for Google search results.",
                        "default": "United States"
                    },
                    "scrapeFrom": {
                        "title": "Scrape From",
                        "enum": [
                            "All",
                            "Channel",
                            "Video",
                            "Shorts",
                            "Posts"
                        ],
                        "type": "string",
                        "description": "Choose one option — All, Channel, Video, Shorts, or Posts.",
                        "default": "All"
                    },
                    "emailType": {
                        "title": "Email Type",
                        "enum": [
                            "B2C",
                            "B2B"
                        ],
                        "type": "string",
                        "description": "Choose one — B2C or B2B.",
                        "default": "B2C"
                    },
                    "engine": {
                        "title": "Engine",
                        "enum": [
                            "cost-effective",
                            "legacy"
                        ],
                        "type": "string",
                        "description": "Choose scraping engine. 🚀 Cost Effective (New): Uses residential proxies with async requests for faster, cheaper scraping. 🔧 Legacy: Uses GOOGLE_SERP proxy with traditional selectors - more reliable but slower and more expensive.",
                        "default": "legacy"
                    },
                    "maxEmails": {
                        "title": "Max Emails",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Enter the maximum number of emails to collect.",
                        "default": 20
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
