# YouTube Lead Scraper (`simpleapi/youtube-lead-scraper`) Actor

The YouTube Lead Scraper automates lead generation from YouTube channels and videos. Collect creator emails, channel metrics, links, and audience data fast. Ideal for outreach campaigns, partnership discovery, and building targeted prospect lists from YouTube.

- **URL**: https://apify.com/simpleapi/youtube-lead-scraper.md
- **Developed by:** [SimpleAPI](https://apify.com/simpleapi) (community)
- **Categories:** Lead generation, Automation, Social media
- **Stats:** 2 total users, 0 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$19.99/month + usage

To use this Actor, you pay a monthly rental fee to the developer. The rent is subtracted from your prepaid usage every month after the free trial period.You also pay for the Apify platform usage, which gets cheaper the higher Apify subscription plan you have.

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

## 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** Lead Scraper 📱

The Youtube Lead Scraper allows users to **extract** a variety of **data** from **YouTube** profiles. This includes publicly available lead addresses, channel names, and other relevant details.

By using this tool, users can gather structured information for outreach or research purposes. The scraper is designed to identify and collect **data** that is publicly accessible on **YouTube**.

It ensures that users can **extract** information efficiently without manual effort. The tool is ideal for those looking to automate the process of gathering **contact** details from **YouTube** channels and profiles.

With its advanced capabilities, it provides accurate and organized **data** for various use cases.

Youtube Lead Scraper is a powerful tool designed to extract contact leads from YouTube channels and profiles efficiently. It helps users gather valuable contact information for outreach and marketing purposes.

With the increasing demand for direct communication, this Youtube lead extraction tool simplifies the process of finding publicly available leads on YouTube. It is an automated solution that saves time and effort.

Whether you are a marketer, researcher, or business owner, scraping YouTube contact leads can provide you with a competitive edge. The tool ensures accuracy and speed in extracting relevant data.

### Support and feedback

- **Bug reports**: Open a ticket in the repository Issues section
- **Custom features**: Contact our enterprise support team
  *Lead: dev.scraperengine@gmail.com *
### Extractable Data Table 📊
| Data Type | Description |
| --- | --- |
| Lead Address | Extract publicly available lead addresses from YouTube profiles. |
| Channel Name | Retrieve the names of the YouTube channels associated with the leads. |
| Channel URL | Collect the URLs of the YouTube channels for easy access. |
| Subscriber Count | Extract the number of subscribers for each YouTube channel. |
| Channel Description | Scrape the description provided on the YouTube channel. |
| Video Count | Retrieve the total number of videos uploaded by the channel. |
| Category or Niche | Identify the category or niche of the YouTube channel. |
| Social Links | Extract additional social media links shared on the channel. |

### Key Features of **YouTube** Lead Scraper

Here are the **standout features** that make the **YouTube** Lead Scraper a **top-tier tool** for **marketers**, **agencies**, and **researchers**:

- ⭐ **Automated** extraction of publicly available leads from **YouTube** profiles
- ⭐ User-friendly interface requiring no technical expertise
- ⭐ **Accurate** and reliable data collection for outreach and marketing purposes
- ⭐ Capability to scrape additional channel details such as subscriber count and video count
- ⭐ Option to filter results based on specific niches or categories
- ⭐ **Fast** processing to handle large-scale data extraction efficiently
- ⭐ **Secure** and compliant with ethical guidelines for data scraping
- ⭐ **Customizable** settings to meet specific user requirements
- ⭐ Detailed reports with structured and organized data output
- ⭐ Cloud-based solution accessible from anywhere with an internet connection
- ⭐ **Regular** updates to ensure compatibility with **YouTube**s platform changes
- ⭐ Free trial option to test the tool before committing to a subscription

### How to use **YouTube** Lead Scraper 🚀

Follow this **simple, step-by-step guide** to start extracting **YouTube** leads today:

1. ✅ **Sign up** for an account on our platform to access the Youtube Lead Scraper
2. ✅ Log in and navigate to the Youtube Lead Scraper tool in the dashboard
3. ✅ Enter the keywords or URLs of the **YouTube** channels you want to scrape
4. ✅ Customize the settings such as filters for niches or subscriber count ranges
5. ✅ **Start** the scraping process by clicking the Run button
6. ✅ Wait for the tool to process the data and extract the required information
7. ✅ Download the results in your preferred format such as CSV or Excel
8. ✅ **Review** the extracted data and use it for your outreach or marketing purposes
9. ✅ If needed refine your search criteria and rerun the scraper for better results
10. ✅ Contact support for assistance if you encounter any issues during the process
11. ✅ Access the tutorial section for detailed guidance on using the tool effectively
12. ✅ Upgrade your plan if you require additional features or higher scraping limits

### Use Cases 🎯

Marketing and Outreach
🎯 **Find** contact leads for influencer collaborations
🎯 Build lead lists for targeted marketing campaigns
🎯 **Identify** potential partners in specific niches

Research and Analysis
🎯 Gather data for market research on **YouTube** content creators
🎯 **Analyze** trends in specific categories or niches
🎯 **Study** the growth patterns of popular **YouTube** channels

Business Development
🎯 Discover new leads for business partnerships
🎯 Expand your network by connecting with **YouTube** creators
🎯 **Identify** potential clients or collaborators

Content Creation
🎯 **Find** inspiration by analyzing top-performing channels
🎯 Connect with creators for guest appearances or collaborations
🎯 **Study** competitor channels for content strategies

### Why choose us? 💎

Our Youtube Lead Scraper stands out as a **reliable** and efficient tool for extracting leads from **YouTube**. It is designed to meet the needs of marketers, researchers, and businesses looking to streamline their outreach efforts.

The tool offers a **user-friendly** interface that requires no technical expertise, making it accessible to everyone. With **advanced** features like filtering options and fast processing, it ensures that users can extract data accurately and efficiently.

We prioritize compliance with ethical guidelines, ensuring that our tool only collects publicly available information. Additionally, our software is **regular**ly updated to adapt to changes in **YouTube**'s platform, providing a seamless experience for users.

Our support team is always available to assist with any queries or issues, ensuring a smooth and hassle-free experience. By choosing our tool, you gain access to a powerful solution that saves time and delivers **reliable** results.

Whether you are a small business or a large enterprise, our scraper is designed to scale with your needs. Experience the convenience and efficiency of our Youtube Lead Scraper today.

### **YouTube** Lead Scraper Scalability 📈

The Youtube Lead Scraper is built to handle projects of all sizes, from small-scale data extraction to **large-scale** operations. It is designed with scalability in mind, ensuring that users can extract data **efficient**ly regardless of the volume.

Our tool can process thousands of **YouTube** profiles and channels without compromising on speed or accuracy. For businesses with high-volume requirements, we offer **customizable** plans that cater to specific needs.

The cloud-based infrastructure ensures that the scraper remains fast and reliable even under heavy workloads. Whether you are a solo entrepreneur or a large organization, our tool adapts to your requirements **seamless**ly.

With its robust architecture, the scraper can handle complex data extraction tasks with ease. Experience the flexibility and scalability of our Youtube Lead Scraper for all your data needs.

### **YouTube** Lead Scraper Legal Guidelines ⚖️

**Yes**—scraping **YouTube** is **legal** as long as you follow **ethical** and **compliant** practices. The **YouTube** Lead Scraper extracts only **publicly available** information from **public** **YouTube** profiles, making it **safe** and **compliant** for **research**, **marketing**, and **analysis**.

#### Legal & Ethical Guidelines
⚖️ **Ensure** that you only scrape publicly available information from **YouTube** profiles
⚖️ **Do not** use the tool for unauthorized or unethical purposes
⚖️ Comply with **YouTube**s terms of service when using the scraper
⚖️ **Avoid** using the extracted data for spamming or unsolicited communication
⚖️ Respect the privacy of individuals and do not attempt to extract private information
⚖️ **Use** the tool responsibly and within the boundaries of applicable laws
⚖️ Seek permission from channel owners if required for specific use cases
⚖️ Regularly review and adhere to updates in **YouTube**s policies and guidelines

### Input Parameters 🧩
📦 Example Input (JSON)
```json
{
  "keywords": ["Youtube Lead Scraper"],
  "country": "Global",
  "maxLeadNumbers": 20,
  "platform": "YouTube",
  "engine": "legacy"
}
````

### Input Table

| Data Type | Description |
| --- | --- |
| keywords | Keywords to find relevant profiles |
| country | Country setting (Global) |
| maxLeadNumbers | Maximum leads to collect (default 20) |
| platform | Platform to scrape (YouTube) |
| engine | Engine type (legacy) |
| proxyConfiguration | Optional proxy settings |

### Output Format 📤

📝 Example Output (JSON)

```json
[
  {
    "network": "YouTube",
    "keyword": "Youtube Lead Scraper",
    "title": "Google's Single-Benefit Marketing Strategy for Chrome ...",
    "description": "✓For years, once we created a Gmail account, we couldn't change the username (the part before @ gmail.com ). ... Grand Rapids Marketing Co. Read more",
    "url": "https://www.linkedin.com/posts/phill-agnew_heres-how-google-marketed-chrome-browser-activity-7404878510214914048-dLxI",
    "lead": "before@gmail.com"
  }
]
```

### Output Table

| Data Type | Description |
| --- | --- |
| network | Identifies YouTube as the source |
| keyword | Keyword that triggered the result (Youtube Lead Scraper) |
| title | Profile title or username |
| description | Public bio snippet with contact info |
| url | Direct YouTube profile link |
| lead | Extracted lead address |

### FAQ ❓

#### What is the Youtube **Lead Scraper**?

The Youtube Lead Scraper is a tool designed to extract **publicly available** **leads** and other data from YouTube profiles and channels.

#### Can I use this tool to scrape **private** information?

**No**, the tool only extracts **publicly available** information in **compliance** with ethical guidelines.

#### Is the Youtube **Lead Scraper** easy to use?

**Yes**, the tool features a **user-friendly** interface that requires no technical expertise.

#### What data can I **extract** using this tool?

You can extract lead addresses, channel names, URLs, subscriber counts, and other **publicly available** details.

#### Is the tool compliant with YouTube's terms of service?

**Yes**, the scraper is designed to comply with YouTube's terms by only collecting publicly accessible information.

#### Can I filter results based on **specific** criteria?

**Yes**, the tool allows you to apply filters such as niches or subscriber count ranges.

#### How do I download the **extract**ed data?

You can download the results in formats like **CSV** or Excel directly from the tool.

#### Is there a free trial available?

**Yes**, we offer a free trial so you can test the tool before making a purchase.

#### Does the tool support **large-scale** data **extract**ion?

**Yes**, the scraper is designed to handle large-scale projects efficiently.

#### What support options are available if I face issues?

Our support team is available to assist you with any queries or technical issues.

#### Can I use the tool for marketing purposes?

**Yes**, the tool is ideal for building lead lists and conducting targeted marketing campaigns.

#### Is the data **extract**ion process automated?

**Yes**, the scraper automates the process of extracting data from YouTube profiles.

#### How often is the software updated?

We regularly update the software to ensure compatibility with YouTube's platform changes.

#### Can I customize the scraping settings?

**Yes**, the tool offers customizable settings to meet your specific requirements.

#### Is the Youtube **Lead Scraper** **secure** to use?

**Yes**, the tool is designed with security in mind and adheres to ethical guidelines for data scraping.

### What are other Youtube scraping tools?

If you want to scrape specific Youtube data, you can use any of the dedicated scrapers below for faster and more targeted results.

| Scraper Name | Scraper Name |
|---|---|
| [Youtube B2b Email Scraper](https://apify.com/simpleapi/youtube-b2b-email-scraper) | [Youtube Phone Number Scraper](https://apify.com/simpleapi/youtube-phone-number-scraper) |
| [Youtube B2b Lead Scraper](https://apify.com/simpleapi/youtube-b2b-lead-scraper) | [Youtube Playlist Scraper](https://apify.com/simpleapi/youtube-playlist-scraper) |
| [Youtube B2b Phone Number Scraper](https://apify.com/simpleapi/youtube-b2b-phone-number-scraper) | [Youtube Scraper](https://apify.com/simpleapi/youtube-scraper) |
| [Youtube Channel Email Scraper](https://apify.com/simpleapi/youtube-channel-email-scraper) | [Youtube Search And Channel Scraper](https://apify.com/simpleapi/youtube-search-and-channel-scraper) |
| [Youtube Channel Finder](https://apify.com/simpleapi/youtube-channel-finder) | [Youtube Search Scraper](https://apify.com/simpleapi/youtube-search-scraper) |
| [YouTube Channel Lead Scraper](https://apify.com/simpleapi/youtube-channel-lead-scraper) | [YouTube Shorts Scraper](https://apify.com/simpleapi/youtube-shorts-scraper) |
| [Youtube Channel Phone Number Scraper](https://apify.com/simpleapi/youtube-channel-phone-number-scraper) | [Youtube Transcript Scraper](https://apify.com/simpleapi/youtube-transcript-scraper) |
| [Youtube Channel Scraper](https://apify.com/simpleapi/youtube-channel-scraper) | [YouTube Trending Scraper](https://apify.com/simpleapi/youtube-trending-scraper) |
| [Youtube Comments Scraper](https://apify.com/simpleapi/youtube-comments-scraper) | [YouTube Video Details Scraper](https://apify.com/simpleapi/youtube-video-details-scraper) |
| [Youtube Community Posts Scraper](https://apify.com/simpleapi/youtube-community-posts-scraper) | [YouTube Video Scraper By Hashtag](https://apify.com/simpleapi/youtube-video-scraper-by-hashtag) |
| [Youtube Email Scraper](https://apify.com/simpleapi/youtube-email-scraper) | [Youtube Video Subtitles Scraper](https://apify.com/simpleapi/youtube-video-subtitles-scraper) |
| [Youtube Metadata Scraper](https://apify.com/simpleapi/youtube-metadata-scraper) | [YouTube Video Summarizer](https://apify.com/simpleapi/youtube-video-summarizer) |
| [YouTube Most Replayed Scraper](https://apify.com/simpleapi/youtube-most-replayed-actor) |  |

# Actor input Schema

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

List of keywords to search for on Youtube (e.g., \['marketing', 'founder', 'business']). The actor will search Google for Youtube profiles/posts containing these keywords and extract email addresses.

## `platform` (type: `string`):

Select platform.

## `location` (type: `string`):

Optional: Add location to search query (e.g., 'London', 'New York'). Leave empty to search globally.

## `emailDomains` (type: `array`):

Optional: Filter results to only include emails from specific domains (e.g., \['@gmail.com', '@outlook.com']). Leave empty to collect all email domains.

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

Maximum number of emails to collect per keyword (default: 20).

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

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

Choose which proxies to use. By default, no proxy is used. If Google rejects or blocks the request, the actor will automatically fallback to datacenter proxy, then residential proxy with 3 retries.

## Actor input object example

```json
{
  "keywords": [
    "marketing"
  ],
  "platform": "Youtube",
  "location": "",
  "emailDomains": [
    "@gmail.com"
  ],
  "maxEmails": 20,
  "engine": "legacy",
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "keywords": [
        "marketing"
    ],
    "emailDomains": [
        "@gmail.com"
    ],
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("simpleapi/youtube-lead-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": ["marketing"],
    "emailDomains": ["@gmail.com"],
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("simpleapi/youtube-lead-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": [
    "marketing"
  ],
  "emailDomains": [
    "@gmail.com"
  ],
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call simpleapi/youtube-lead-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "YouTube Lead Scraper",
        "description": "The YouTube Lead Scraper automates lead generation from YouTube channels and videos. Collect creator emails, channel metrics, links, and audience data fast. Ideal for outreach campaigns, partnership discovery, and building targeted prospect lists from YouTube.",
        "version": "0.1",
        "x-build-id": "LhS03pKaraW5vyO9U"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/simpleapi~youtube-lead-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-simpleapi-youtube-lead-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/simpleapi~youtube-lead-scraper/runs": {
            "post": {
                "operationId": "runs-sync-simpleapi-youtube-lead-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/simpleapi~youtube-lead-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-simpleapi-youtube-lead-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "keywords"
                ],
                "properties": {
                    "keywords": {
                        "title": "Keywords",
                        "type": "array",
                        "description": "List of keywords to search for on Youtube (e.g., ['marketing', 'founder', 'business']). The actor will search Google for Youtube profiles/posts containing these keywords and extract email addresses.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "platform": {
                        "title": "Platform",
                        "enum": [
                            "Youtube"
                        ],
                        "type": "string",
                        "description": "Select platform.",
                        "default": "Youtube"
                    },
                    "location": {
                        "title": "Location Filter",
                        "type": "string",
                        "description": "Optional: Add location to search query (e.g., 'London', 'New York'). Leave empty to search globally.",
                        "default": ""
                    },
                    "emailDomains": {
                        "title": "Email Domains Filter",
                        "type": "array",
                        "description": "Optional: Filter results to only include emails from specific domains (e.g., ['@gmail.com', '@outlook.com']). Leave empty to collect all email domains.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxEmails": {
                        "title": "Maximum Emails per Keyword",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Maximum number of emails to collect per keyword (default: 20).",
                        "default": 20
                    },
                    "engine": {
                        "title": "Engine",
                        "enum": [
                            "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"
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Choose which proxies to use. By default, no proxy is used. If Google rejects or blocks the request, the actor will automatically fallback to datacenter proxy, then residential proxy with 3 retries."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
