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

Automate lead generation from YouTube channels using the YouTube Channel Lead Scraper. Extract channel profiles, contact emails, social links, subscriber metrics, and video data. Export structured lead lists for CRM systems, outreach tools, or market research.

- **URL**: https://apify.com/simpleapi/youtube-channel-lead-scraper.md
- **Developed by:** [SimpleAPI](https://apify.com/simpleapi) (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

$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 Channel Lead Scraper allows you to **extract** a variety of **data** points from **YouTube** channels. It focuses on retrieving publicly available lead addresses provided by content creators for business inquiries.

Additionally, the tool can gather supplementary information such as channel names, descriptions, and subscriber counts. This ensures that you have a comprehensive view of the channel's profile before initiating **contact**.

The scraper is designed to respect **YouTube**'s terms of service by only **extract**ing information that is publicly accessible. It is ideal for marketers, researchers, and businesses looking to connect with creators in an ethical and efficient manner.

With its advanced algorithms, the **YouTube** lead scraping tool ensures high accuracy and reliability in the **data** it collects. By using this tool, you can save time and resources while maximizing the effectiveness of your outreach campaigns.

Youtube Channel Lead Scraper is a powerful tool designed to help users extract publicly available lead addresses from YouTube channels efficiently. It simplifies the process of finding contact information for creators and businesses on the platform.

With the rise of influencer marketing and collaborations, having access to accurate contact details is essential. This YouTube lead scraping tool ensures that you can connect with content creators for partnerships, promotions, or business opportunities.

The automated YouTube lead scraper eliminates the need for manual searches, saving you time and effort. It is designed to provide accurate and reliable results while adhering to ethical and legal guidelines.

### 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 | Publicly available lead addresses provided by YouTube channel owners for business inquiries. |
| Channel Name | The name of the YouTube channel to identify the creator or brand. |
| Channel Description | A brief overview of the channel's content and focus. |
| Subscriber Count | The number of subscribers to gauge the channel's audience size. |
| Video Count | The total number of videos uploaded by the channel. |
| Channel URL | The direct link to the YouTube channel for easy access. |
| Category | The niche or category the channel belongs to, such as gaming, education, or lifestyle. |
| Social Media Links | Links to other social media platforms shared by the channel owner. |

### 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**:

- ⭐ Extracts publicly available lead addresses from **YouTube** channels quickly and efficiently
- ⭐ Provides additional channel data such as names descriptions and subscriber counts
- ⭐ User-friendly interface for seamless operation even for beginners
- ⭐ Supports bulk scraping to handle multiple channels simultaneously
- ⭐ **Advanced** filtering options to target specific niches or categories
- ⭐ Ensures compliance with **YouTube**s terms of service by only extracting public data
- ⭐ Offers high accuracy and reliability in the extracted information
- ⭐ **Customizable** settings to tailor the scraping process to your specific needs
- ⭐ **Automated** processes to save time and reduce manual effort
- ⭐ **Secure** and private data handling to protect user information

### How to use **YouTube** Lead Scraper 🚀

Follow this **simple, step-by-step guide** to start extracting **YouTube** leads today:

1. ✅ **Sign up** or **log in** to the **YouTube** lead scraping tool platform
2. ✅ Navigate to the dashboard and select the **YouTube** Lead Scraper option
3. ✅ Enter the URLs of the **YouTube** channels you want to scrape or upload a list of URLs
4. ✅ Set your preferences such as filtering by category or subscriber count
5. ✅ **Start** the scraping process by clicking the Run button
6. ✅ Monitor the progress of the scraper in real-time on the dashboard
7. ✅ Once the process is complete download the extracted data in your preferred format
8. ✅ **Review** the results and use the information for your outreach campaigns

### Use Cases 🎯

Influencer Marketing
🎯 **Find** lead addresses of **YouTube** influencers for collaboration opportunities
🎯 Target creators in specific niches for product promotions or sponsorships

Business Outreach
🎯 Connect with content creators to promote your brand or services
🎯 **Identify** potential partners for joint ventures or marketing campaigns

Market Research
🎯 **Analyze** **YouTube** channels to understand trends and audience preferences
🎯 Gather data for competitor analysis or industry insights

Content Collaboration
🎯 Reach out to creators for guest appearances or content partnerships
🎯 Expand your network by connecting with like-minded individuals on **YouTube**

### Why choose us? 💎

Our Youtube Channel Lead Scraper stands out as the **best** **YouTube** lead scraper due to its reliability and efficiency. It is designed to cater to the needs of marketers, researchers, and businesses looking to connect with content creators.

The tool is easy to use, even for beginners, and offers **advanced** features for experienced users. With our **YouTube** lead scraping tool, you can extract data in bulk, saving time and effort.

We prioritize accuracy and ensure that all extracted data is publicly available and compliant with **YouTube**'s terms of service. Our platform also provides robust filtering options, allowing you to target specific niches or categories.

Whether you need an lead extractor for **YouTube** or a comprehensive **YouTube** lead harvesting software, our tool has you covered. We are committed to providing secure and private data handling to protect our users' information.

Choose us for a seamless, efficient, and ethical **YouTube** lead scraping experience.

### **YouTube** Lead Scraper Scalability 📈

The Youtube Channel Lead Scraper is built to handle projects of any size, making it suitable for both small businesses and large enterprises. It supports bulk scraping, allowing you to extract data from multiple **YouTube** channels simultaneously.

Our tool is designed to scale with your needs, whether you're targeting a handful of creators or thousands. The automated **YouTube** lead scraper ensures that the process remains fast and **efficient**, even as the volume of data increases.

With its robust infrastructure, the tool can handle high-demand tasks without compromising on performance or accuracy. This scalability makes it an ideal choice for businesses looking to grow their outreach efforts over time.

Whether you're extracting leads from **YouTube** channels for a small campaign or a **large-scale** project, our scraper is equipped to deliver reliable results.

### **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
⚖️ **Only** extract publicly available lead addresses shared by **YouTube** channel owners
⚖️ **Do not** use the tool to scrape private or sensitive information from **YouTube**
⚖️ **Ensure** compliance with **YouTube**s terms of service and privacy policies
⚖️ **Use** the extracted data ethically and avoid spamming or unsolicited communication
⚖️ **Obtain** proper consent before using the contact information for marketing purposes
⚖️ **Do not** resell or distribute the extracted data without permission
⚖️ Regularly review and adhere to local data protection laws and regulations
⚖️ **Use** the tool responsibly to maintain the integrity of the **YouTube** platform

### Input Parameters 🧩
📦 Example Input (JSON)
```json
{
  "keywords": ["Youtube Channel 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 Channel 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 Channel 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 Channel **Lead Scraper**?

The Youtube Channel Lead Scraper is a tool designed to extract **publicly available** lead addresses from YouTube channels efficiently.

#### Can I **extract** data from multiple channels at once?

**Yes**, the tool supports bulk scraping, allowing you to extract data from multiple channels simultaneously.

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

**Yes**, the scraper only extracts **publicly available** information to ensure **compliance** with YouTube's terms of service.

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

You can extract lead addresses, channel names, descriptions, subscriber counts, video counts, and more.

#### Is the tool user-friendly?

**Yes**, the YouTube lead scraping tool features a simple and intuitive interface suitable for all users.

#### Can I filter channels by category or subscriber count?

**Yes**, the tool offers advanced **filtering** options to target specific niches or categories.

#### Is the **extract**ed data accurate?

The tool is designed to provide high accuracy and reliability in the data it collects.

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

Once the scraping process is complete, you can download the data in your preferred format from the dashboard.

#### Is my data **secure** while using the tool?

**Yes**, we prioritize **secure** and private data handling to protect user information.

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

**Yes**, the tool is ideal for finding lead addresses of YouTube influencers for collaborations and promotions.

#### What are the **legal** guidelines for using this tool?

You should only extract **publicly available** data, comply with YouTube's terms of service, and use the information ethically.

#### Can I use the tool for market research?

**Yes**, the tool is suitable for analyzing YouTube channels and gathering industry insights.

#### Does the tool support automated processes?

**Yes**, the scraper automates the data extraction process to save time and effort.

#### What makes this tool the best YouTube lead scraper?

It offers reliability, efficiency, advanced features, and **compliance** with ethical guidelines, making it the best YouTube lead scraper.

#### Is there **customer support** available?

**Yes**, our team is available to assist you with any questions or issues you may have.

### 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 Phone Number Scraper](https://apify.com/simpleapi/youtube-channel-phone-number-scraper) | [YouTube Shorts Scraper](https://apify.com/simpleapi/youtube-shorts-scraper) |
| [Youtube Channel Scraper](https://apify.com/simpleapi/youtube-channel-scraper) | [Youtube Transcript Scraper](https://apify.com/simpleapi/youtube-transcript-scraper) |
| [Youtube Comments Scraper](https://apify.com/simpleapi/youtube-comments-scraper) | [YouTube Trending Scraper](https://apify.com/simpleapi/youtube-trending-scraper) |
| [Youtube Community Posts Scraper](https://apify.com/simpleapi/youtube-community-posts-scraper) | [YouTube Video Details Scraper](https://apify.com/simpleapi/youtube-video-details-scraper) |
| [Youtube Email Scraper](https://apify.com/simpleapi/youtube-email-scraper) | [YouTube Video Scraper By Hashtag](https://apify.com/simpleapi/youtube-video-scraper-by-hashtag) |
| [YouTube Lead Scraper](https://apify.com/simpleapi/youtube-lead-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-channel-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-channel-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-channel-lead-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "YouTube Channel Lead Scraper",
        "description": "Automate lead generation from YouTube channels using the YouTube Channel Lead Scraper. Extract channel profiles, contact emails, social links, subscriber metrics, and video data. Export structured lead lists for CRM systems, outreach tools, or market research.",
        "version": "0.1",
        "x-build-id": "hzDDht4FyIkwlsITt"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/simpleapi~youtube-channel-lead-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-simpleapi-youtube-channel-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-channel-lead-scraper/runs": {
            "post": {
                "operationId": "runs-sync-simpleapi-youtube-channel-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-channel-lead-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-simpleapi-youtube-channel-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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
