# Youtube B2b Email Scraper (`solid-scraper/youtube-b2b-email-scraper`) Actor

📩 Unlock targeted B2B email leads with this powerful YouTube B2B Email Scraper! 🚀 Scrape verified contacts fast for sales, marketing, and outreach—filter by niche and location to boost ROI instantly. Ideal for agencies & growth teams. 🏢

- **URL**: https://apify.com/solid-scraper/youtube-b2b-email-scraper.md
- **Developed by:** [SolidScraper](https://apify.com/solid-scraper) (community)
- **Categories:** Lead generation, Automation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.99 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js/docs.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

### Youtube B2b Email Scraper 🔍

**Youtube B2b Email Scraper** helps you **extract business email addresses from YouTube content** so you can build targeted lead lists without manual searching. Whether you’re using a **youtube b2b email scraper** for outreach, a **youtube email scraper tool** for prospecting, or a **b2b email scraper from youtube** for research, this actor automates the workflow of finding relevant contacts by **keywords**, **country**, and **content type**—saving you hours of manual work at scale.

---

### Why choose Youtube B2b Email Scraper?

| Feature | Benefit |
| --- | --- |
| ✅ **All-in-one email collection** | Collects business emails for your chosen keywords and YouTube content types in one run |
| ✅ **Engine choice with resilience** | Lets you pick a scraping engine and improves reliability using built-in resilience and fallbacks |
| ✅ **Controlled extraction volume** | Uses `maxEmails` to cap the maximum number of emails collected |
| ✅ **Structured dataset output** | Saves results in a consistent table-ready format (keyword, URL, email, domain, country, etc.) |
| ✅ **Designed for lead generation at scale** | Supports multiple keywords and extracts across different YouTube sources based on your selection |
| ✅ **Works smoothly in Apify workflows** | Output goes directly to an Apify dataset for downstream CRM, reporting, or automation |

---

### Key features

- 🔎 **B2B-focused email harvesting**: Designed for extracting business emails (not consumer-only results) from relevant YouTube content.
- 🧩 **Keyword-driven prospecting**: Use one or more keywords to discover leads aligned with your niche—great for **youtube lead generation email scraper** workflows.
- 🌍 **Country targeting**: Select a target `country` to focus your prospecting region.
- 🎯 **Flexible content selection**: Choose **All, Channel, Video, Shorts, or Posts** with `scrapeFrom` for precise **youtube channel contact email scraper** use cases.
- 🛡️ **Reliability with engine options**: Pick `engine` to balance speed and reliability based on your needs (Cost Effective vs Legacy).
- 💾 **Immediate structured saving**: Results are pushed into the dataset in a consistent schema so you can export to JSON/CSV easily.
- 📊 **Email + domain extraction**: Each record includes both `email` and `email_domain` to help you deduplicate and segment leads.
- 🔄 **Deduplication support**: The scraper tracks and filters out globally seen emails to reduce duplicates in your results.

---

### Input

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

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

#### Input Fields

| Key | Required | Description |
| --- | --- | --- |
| `keywords` | ✅ | Enter one or more keywords to search for on YouTube. |
| `country` | ✅ | Specify the country to target for results (helps you focus lead discovery geographically). |
| `scrapeFrom` | ✅ | Choose one option — **All, Channel, Video, Shorts, or Posts**. |
| `engine` | ❌ | Choose scraping engine. **cost-effective** uses residential proxies with async requests for faster, cheaper scraping. **legacy** uses a different approach described as more reliable but slower and more expensive. |
| `maxEmails` | ✅ | Enter the maximum number of emails to collect (between 1 and 10000). |

***

### Output

The actor saves scraped records in an Apify dataset in **JSON format**, with a table-ready structure.

Example output record:

```json
[
  {
    "keyword": "fitness",
    "title": "Channel title or content title",
    "url": "https://www.youtube.com/channel/XXXX",
    "description": "Short description text related to the found contact info",
    "email": "contact@example.com",
    "email_domain": "example.com",
    "scrape_from": "Channel",
    "country": "United States"
  }
]
```

#### Output Fields

| Field | Type | Description |
| --- | --- | --- |
| `keyword` | string | The keyword that triggered this lead record. |
| `title` | string | The YouTube title associated with the record. |
| `url` | string | The YouTube URL for the profile/content that was used to extract the email. |
| `description` | string | A description snippet associated with the record. |
| `email` | string | The extracted email address. |
| `email_domain` | string | The email’s domain portion (e.g., `example.com`). |
| `scrape_from` | string | Where the record came from: **All, Channel, Video, Shorts, or Posts**. |
| `country` | string | The selected country used during scraping. |

Closing note: You can export the Apify dataset to common formats like **JSON** (and typically **CSV** via Apify exports) for CRM lead list building and analytics.

***

### How to use Youtube B2b Email Scraper (via Apify Console)

1. **Open Apify Console**\
   Log in at https://console.apify.com and go to the **Actors** section.

2. **Find the actor**\
   Search for **Youtube B2b Email Scraper** and open the actor page.

3. **Go to the INPUT tab**\
   Paste your `input.json` into the input editor. The actor accepts `keywords`, `country`, `scrapeFrom`, and `maxEmails` (and optionally `engine`).

4. **Set your prospecting scope**\
   Enter your `keywords` (one or more). Pick a `country` and choose `scrapeFrom` as **All**, **Channel**, **Video**, **Shorts**, or **Posts**.

5. **Choose an engine (optional)**\
   If you care about cost/speed tradeoffs, select `engine` as:
   - **cost-effective** for faster, cheaper scraping with residential proxies (async)
   - **legacy** for the more reliable approach described in the input schema

6. **Set the email cap**\
   Adjust `maxEmails` to control how many emails you want the run to collect.

7. **Run the actor**\
   Click **Run**. Monitor the logs for progress and any extraction issues. The actor is designed with resilience and extraction logic suitable for repeated runs (for **youtube email list builder** and **youtube outreach email finder** workflows).

8. **Open your dataset results and export**\
   After the run completes, open the dataset (e.g., **Scraped Emails** / “Youtube Email Data”) and export the results for downstream use in spreadsheets, analytics, or CRM tools. No coding required—get accurate results in minutes.

***

### Advanced features & SEO optimization

- 🚀 **Engine tuning for different needs**: Use `engine` to choose between **Cost Effective (New)** and **Legacy**, enabling use cases like **youtube b2b email scraper** vs more reliability-focused runs.
- 🧠 **Targeted lead discovery**: Built to “engineered for purpose” extraction by using your `keywords` plus `country` targeting and the selected `scrapeFrom` type—ideal when you need **extract emails from youtube channels**.
- 💾 **Dataset-first workflow**: Because results are saved in a consistent schema (`keyword`, `title`, `url`, `email`, `email_domain`, `scrape_from`, `country`), it’s easy to build a **crm lead list from youtube emails**.
- 🛡️ **Rate-limit resilience & fallbacks**: Includes retries and fallback behavior to keep extraction moving even when requests fail.
- 🌐 **Designed for B2B outreach**: The actor focuses on collecting business emails—supporting **youtube data scraper for emails** and **youtube email list builder** pipelines.

***

### Best use cases

- 📈 **Marketing teams building segmented lead lists**: Quickly generate **youtube b2b prospecting tool** email lists by niche keyword, country, and content type.
- ✉️ **Outbound sales teams finding decision-maker contacts**: Use this **youtube outreach email finder** to enrich prospecting lists with `email` and `email_domain`.
- 🔎 **Recruiters and hiring researchers**: Identify business contacts associated with YouTube-related organizations and channels using **find business emails from youtube** patterns.
- 🧪 **Market researchers running competitor contact audits**: Combine `url`, `title`, and `email_domain` to understand who publishes and how they present contact channels.
- 🗂️ **Analysts creating email-domain cohorts**: Analyze `email_domain` frequency by `keyword` and `country` for measurable outreach strategy decisions.
- 🧰 **Developers integrating into automation pipelines**: Consume dataset output to populate CRM fields and dashboards—useful for a **youtube email scraper tool** in ETL jobs.
- 🌍 **International lead generation**: Use the `country` selector to tailor lists for different regions, aligning with your target market.

***

### Technical specifications

- **Supported Input Formats**
  - ✅ `keywords` (array of strings)
  - ✅ `country` (string; selected from the provided enum)
  - ✅ `scrapeFrom` (string; **All, Channel, Video, Shorts, Posts**)
  - ✅ `engine` (string; **cost-effective** or **legacy**)
  - ✅ `maxEmails` (integer; min 1, max 10000)

- **Proxy Support**
  - ✅ Built-in proxy support is available via the chosen `engine` option (includes residential proxy behavior for **cost-effective**)

- **Retry Mechanism**
  - ✅ Includes retries and fallback logic for resilience when requests fail

- **Dataset Structure**
  - ✅ Saves records with these dataset fields: `keyword`, `title`, `url`, `description`, `email`, `email_domain`, `scrape_from`, `country`

- **Rate Limits & Performance**
  - ⚙️ Uses an extraction approach that aims to remain stable across runs with delays, concurrency control, and fallbacks (performance depends on conditions)

- **Limitations**
  - ❌ Results depend on publicly available contact information being present and discoverable for the selected YouTube sources
  - ❌ Not every record will necessarily contain an email address

***

### FAQ

#### What does Youtube B2b Email Scraper extract?

✅ It extracts **business email addresses from YouTube-related sources** based on your provided `keywords`, `country`, and `scrapeFrom` selection. Each output record includes the `email` plus `email_domain` along with the related `url` and `title`.

#### Can I scrape only channels or only videos?

✅ Yes. Use `scrapeFrom` to choose **Channel**, **Video**, **Shorts**, or **Posts**. If you want everything in one run, select **All**.

#### How do I control how many emails I get?

✅ Use `maxEmails` to set the maximum number of emails to collect for the run (minimum 1, maximum 10000). This is ideal for **youtube lead generation email scraper** runs where you want predictable volume.

#### Which engine should I use: cost-effective or legacy?

✅ Choose `engine` based on your priorities. **cost-effective** is described as using residential proxies with async requests for faster, cheaper scraping, while **legacy** is described as more reliable but slower and more expensive.

#### Where can I find the results after the run?

✅ The actor saves results into an Apify dataset (configured as **Youtube Email Data** / **Scraped Emails**). You can open the dataset in the **OUTPUT** area and export for analysis.

#### Is this meant for CRM lead list building?

✅ Yes. The dataset includes fields like `email`, `email_domain`, `url`, `keyword`, and `country`, making it easy to transform into a **crm lead list from youtube emails** or feed into outreach workflows.

#### Does this scrape private or restricted content?

❌ No. The actor is intended to collect information from **publicly accessible sources** only.

#### Can I remove data later?

✅ If you need data removal, contact <dataforleads@gmail.com>.

***

### Support & feature requests

Want to improve **Youtube B2b Email Scraper** (including **youtube b2b email scraper** performance or output usability)? Share your ideas and feedback.

- 💡 **Feature Requests**: For example, ask for enhancements like better exports for CRM, additional dataset fields, or custom filtering options for outreach segmentation.
- 📧 **Contact**: Reach us at <dataforleads@gmail.com>.

Your feedback helps shape future versions of this **youtube email scraper tool**.

***

### *Youtube B2b Email Scraper* — final thoughts

*If you’re looking for a practical, dataset-first way to build a b2b email list from YouTube, this is one of the most comprehensive and SEO-optimized options for your workflow.*

# 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.

## `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",
  "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("solid-scraper/youtube-b2b-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("solid-scraper/youtube-b2b-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 solid-scraper/youtube-b2b-email-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Youtube B2b Email Scraper",
        "description": "📩 Unlock targeted B2B email leads with this powerful YouTube B2B Email Scraper! 🚀 Scrape verified contacts fast for sales, marketing, and outreach—filter by niche and location to boost ROI instantly. Ideal for agencies & growth teams. 🏢",
        "version": "1.0",
        "x-build-id": "Y1JT44wJRWCSTbi6Y"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/solid-scraper~youtube-b2b-email-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-solid-scraper-youtube-b2b-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/solid-scraper~youtube-b2b-email-scraper/runs": {
            "post": {
                "operationId": "runs-sync-solid-scraper-youtube-b2b-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/solid-scraper~youtube-b2b-email-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-solid-scraper-youtube-b2b-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",
                    "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"
                    },
                    "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
