# Best Facebook Email Scraper (`scraperoka/best-facebook-email-scraper`) Actor

📧 Best Facebook Email Scraper extracts emails from public Facebook profiles & pages quickly and accurately. 🚀 Perfect for B2B lead generation, sales, and outreach—save time, grow your pipeline, and target the right prospects with ease.

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

## Pricing

from $0.01 / 1,000 results

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

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

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

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

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

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

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

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

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

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

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

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


# README

### Best Facebook Email Scraper ⚡

Manually visiting hundreds of Facebook profiles to collect emails wastes hours you don’t have. **Best Facebook Email Scraper** extracts business and consumer email addresses from Facebook at scale using keyword, country, and content-type targeting. This Best Facebook Email Scraper (and similar facebook email extractor tool workflows) is ideal for marketers, recruiters, and growth teams who need leads quickly. In a single run, you can generate thousands of structured email records—fast.

---

### What You Get: Sample Output

Here's a sample record from a single run:

```json
{
  "keyword": "fitness",
  "title": "Fitness Gym — Contact",
  "url": "https://www.facebook.com/examplegym/contact",
  "description": "For bookings and inquiries, email our team.",
  "email": "contact@examplegym.com",
  "email_domain": "examplegym.com",
  "email_type": "B2B",
  "scrape_from": "Profiles",
  "country": "United States",
  "error_message": null
}
````

| Field | Type | What It Tells You |
|---|---|---|
| `keyword` | string | Which keyword helped surface the contact (useful for campaign mapping). |
| `title` | string | The title text associated with the scraped listing/profile for context. |
| `url` | string | The Facebook link where the email was found so you can verify quickly. |
| `description` | string | The surrounding text that provides extra evidence about the email’s relevance. |
| `email` | string | The extracted email address you can use for outreach. |
| `email_domain` | string | Domain name for filtering, deduping, and company-level analysis. |
| `email_type` | string | Whether the email is targeted as B2B or B2C for better list quality. |
| `scrape_from` | string | Where the actor scraped from (for example, Profiles, Groups, Marketplace). |
| `country` | string | The country focus used during the run to help regional targeting. |
| `error_message` | string | null | Shows what went wrong when a record can’t be extracted. |

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

***

### Why Best Facebook Email Scraper?

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

#### Keyword, country, and content-type targeting

You control the inputs using `keywords`, `country`, and `scrapeFrom` so you’re not stuck with generic lead lists. This makes it a strong facebook lead scraper for targeted outreach, including facebook group email scraper and facebook page email scraper style workflows.

#### B2B vs B2C email targeting

With `emailType`, you choose whether you want B2B or B2C emails. That single setting helps align the output with how your messaging and lead qualification are structured—useful for a facebook contact email scraper pipeline.

#### Structured output designed for fast cleanup

The dataset includes consistent fields like `email`, `email_domain`, `email_type`, `scrape_from`, and `country`. That structure helps analysts quickly filter, deduplicate, and segment results without heavy reformatting—ideal for an facebook email list scraper use case.

#### Resilient scraping engine options

You can select an `engine` option to match your cost and reliability needs. If you’re running automated facebook email scraping at scale, having engine flexibility helps reduce friction when search traffic varies.

***

### Configuring Your Run

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

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

| Parameter | Required | What It Does |
|---|---|---|
| `keywords` | ✅ | One or more keywords to search for on Facebook. |
| `country` | ✅ | The country focus used to target results for email discovery. |
| `scrapeFrom` | ✅ | Choose where to scrape from: `All`, `Profiles`, `Reels`, `Posts`, `Groups`, `Videos`, `Photos`, `Events`, or `Marketplace`. |
| `emailType` | ✅ | Choose which email audience to target: `B2C` or `B2B`. |
| `engine` | ⬜ | Select the scraping engine mode (`cost-effective` or `legacy`) to balance speed vs reliability needs. |
| `maxEmails` | ✅ | Sets the maximum number of emails to collect for this run (up to 10,000). |

***

### Core Capabilities

#### Flexible Facebook coverage with `scrapeFrom`

Best Facebook Email Scraper lets you aim at specific Facebook content types using `scrapeFrom`, including Profiles, Groups, Posts, Reels, Videos, Events, Marketplace, and more. Selecting `All` searches across every type, which is great for automated facebook email scraping when you don’t yet know where the best emails will appear.

#### Clean, analysis-ready fields for email outreach

Results are written into a dataset with fields like `email`, `email_domain`, `email_type`, and `url`. This makes it easier to build a facebook email extractor tool workflow that feeds directly into segmentation, outreach tools, and reporting.

#### Output capped with `maxEmails` for predictable runs

The actor uses `maxEmails` to control how many emails it collects in a run. This is important when you’re building an facebook email list scraper for a particular campaign and need predictable processing time and cost management.

#### Engine selection for different run goals

By choosing the `engine`, you can steer the run toward either a cost-effective mode or a legacy mode. This is helpful when you’re trying to find the best balance for your facebook business page email finder project or an ongoing lead scraping schedule.

#### Country and keyword control for better lead relevance

You decide the direction using `keywords` and `country`, so your output is more relevant than a one-size-fits-all scrape. This works well for facebook marketing email scraper use cases where you need leads clustered by topic and region.

***

### Who Gets the Most Out of This

**Marketers building targeted lead lists** — Best Facebook Email Scraper helps turn keyword research into outreach-ready contact data, so you can assemble a segmented list of emails faster and focus your campaigns on the right niches.

**Recruiters and HR teams** — When you need a practical facebook contact email scraper workflow for staffing, the `emailType` option (B2B vs B2C) helps align contacts to how you plan to communicate and qualify candidates.

**Growth teams running outreach experiments** — You can run multiple variations of `keywords`, `country`, and `scrapeFrom` to quickly compare lead quality and response rates, while keeping results in a consistent dataset format.

**Data analysts and researchers** — The structured dataset fields like `email_domain`, `email_type`, `scrape_from`, `country`, and the associated `url` make it easier to analyze patterns, deduplicate, and evaluate which discovery settings produce higher-quality contacts.

**Automation specialists (API-driven workflows)** — Best Facebook Email Scraper fits into automated pipelines where you pull results programmatically and push them into your CRM or marketing stack, turning facebook email list scraper tasks into scheduled data refreshes.

***

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

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

1. **Open the actor on Apify** — visit the Apify console and open Best Facebook Email Scraper: https://console.apify.com
2. **Enter your inputs** — set `keywords`, `country`, `scrapeFrom`, `emailType`, and `maxEmails` in the Input section.
3. **Configure proxy settings (optional)** — if you use proxy settings in Apify, enable them according to your reliability and cost preferences.
4. **Hit Run and watch the live log** — monitor progress and any warnings while the actor collects emails.
5. **View results in the dataset tab** — your output is saved in the dataset as it’s scraped.
6. **Export as JSON, CSV, or Excel** — download your dataset in the format that fits your workflow.

The whole process takes under 5 minutes to set up.

***

### Integrations & Export Options

Once your data is collected, Best Facebook Email Scraper plugs directly into your existing workflow. You can export results from the Apify dataset tab in JSON, CSV, or Excel for use in spreadsheets, internal tools, or downstream processing.

You can also connect the actor to automation tools using Apify’s API and integrations. With API access, you can pull results programmatically via the Apify API, and with Zapier/Make you can push updates into your tools without manual exports. Webhooks and scheduled runs make it possible to refresh your facebook lead scraper datasets automatically.

For deeper details, see Apify documentation at https://apify.com/docs/api.

***

### Pricing & Free Trial

Best Facebook Email Scraper runs on the Apify platform, which offers a **free tier** — no credit card required to get started. You typically begin with platform credits for testing, then scale using Apify’s pay-as-you-go approach as needed.

Exact pricing depends on your run and settings, and heavy usage should be planned using Apify’s pricing resources. Start for free at [apify.com](https://apify.com) and scale when you're ready.

***

### Reliability & Performance

| What We Handle | How |
|---|---|
| Rate limiting and variability | Built for resilience with engine and run controls you can configure. |
| Scraping workload changes | Use `maxEmails` to cap results and keep runs predictable. |
| Output consistency | Dataset records follow a stable schema with email context fields like `url`, `email_domain`, and `email_type`. |
| Large search jobs | Larger runs may take longer; plan accordingly when increasing email limits. |

**Limitations:** This actor focuses on emails found in publicly available Facebook content. If emails aren’t present in the visible information for targeted entities, results may be sparse. For enterprise-scale runs, contact us to discuss custom configurations.

***

### Frequently Asked Questions

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

Yes. Apify offers a free tier so you can try Best Facebook Email Scraper before scaling up. You can start with platform credits and run smaller tests first.

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

No. The actor is designed to collect data from publicly available sources on Facebook—no Facebook login is required.

#### How accurate is the data?

Accuracy depends on what contact information is publicly available. Best Facebook Email Scraper extracts emails from the visible information it encounters, and the dataset includes fields like `url` and `description` so you can validate quickly.

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

You control the maximum output using `maxEmails`, with a minimum of 1 and a maximum of 10,000. For large jobs, you may see longer run times.

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

Freshness depends on when you run the actor and what’s currently visible on the target Facebook content. If you need updated results, schedule repeated runs.

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

Use of email-harvesting outputs must follow applicable laws and platform rules. Best Facebook Email Scraper only works with **publicly available data**, but it’s still your responsibility to comply with GDPR, CCPA, and any relevant regulations and consent requirements.

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

Yes. Export from the Apify dataset tab is available as JSON, CSV, or Excel. From there, you can import into tools like spreadsheets and CRMs as needed.

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

Yes. With Apify automation features, you can set scheduled runs so your Best Facebook Email Scraper output stays current for outreach cycles.

#### Can I access this via API?

Yes. You can pull results programmatically using the Apify API. This is useful for building an automated facebook email scraping pipeline connected to your CRM.

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

If errors occur, you may see failure indicators such as `error_message` in the dataset output. Your run may still produce partial results depending on where the issue happens.

***

### Need Help or Have a Request?

Got a question about Best Facebook Email Scraper or want a new feature added? Reach out at <dataforleads@gmail.com>. We’re happy to help with setup questions and consider feedback like webhook notifications on completion and more automation-friendly exports.

***

### Disclaimer & Responsible Use

*Best Facebook Email Scraper is the fastest, most reliable way to build your outreach-ready Facebook email lists — start your free run today.*

This actor collects **publicly available data** from Facebook. It does not access private accounts, login-gated content, or password-protected pages. You’re responsible for compliance with GDPR, CCPA, platform Terms of Service, and any applicable local regulations. For data-removal requests, contact <dataforleads@gmail.com>. Use responsibly, ethically, and only for lawful purposes.

# Actor input Schema

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

Enter one or more keywords to search for on Facebook.

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

Specify the country to target for Google search results.

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

Choose one option — All, Profiles, Reels, Posts, Groups, Videos, Photos, Events, or Marketplace.

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

Choose one — B2C or B2B.

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

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

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

Enter the maximum number of emails to collect.

## Actor input object example

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

# API

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

## JavaScript example

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

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

// Prepare Actor input
const input = {
    "keywords": [
        "fitness",
        "gym",
        "workout"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("scraperoka/best-facebook-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",
        "gym",
        "workout",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("scraperoka/best-facebook-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",
    "gym",
    "workout"
  ]
}' |
apify call scraperoka/best-facebook-email-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Best Facebook Email Scraper",
        "description": "📧 Best Facebook Email Scraper extracts emails from public Facebook profiles & pages quickly and accurately. 🚀 Perfect for B2B lead generation, sales, and outreach—save time, grow your pipeline, and target the right prospects with ease.",
        "version": "1.0",
        "x-build-id": "PqGfKhaiBLjYo9JXR"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scraperoka~best-facebook-email-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scraperoka-best-facebook-email-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/scraperoka~best-facebook-email-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scraperoka-best-facebook-email-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/scraperoka~best-facebook-email-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scraperoka-best-facebook-email-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "keywords",
                    "country",
                    "scrapeFrom",
                    "emailType",
                    "maxEmails"
                ],
                "properties": {
                    "keywords": {
                        "title": "Keywords",
                        "type": "array",
                        "description": "Enter one or more keywords to search for on Facebook.",
                        "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",
                            "Profiles",
                            "Reels",
                            "Posts",
                            "Groups",
                            "Videos",
                            "Photos",
                            "Events",
                            "Marketplace"
                        ],
                        "type": "string",
                        "description": "Choose one option — All, Profiles, Reels, Posts, Groups, Videos, Photos, Events, or Marketplace.",
                        "default": "All"
                    },
                    "emailType": {
                        "title": "Email Type",
                        "enum": [
                            "B2C",
                            "B2B"
                        ],
                        "type": "string",
                        "description": "Choose one — B2C or B2B.",
                        "default": "B2C"
                    },
                    "engine": {
                        "title": "Engine",
                        "enum": [
                            "cost-effective",
                            "legacy"
                        ],
                        "type": "string",
                        "description": "Choose scraping engine. 🚀 Cost Effective (New): Uses residential proxies with async requests for faster, cheaper scraping. 🔧 Legacy: Uses GOOGLE_SERP proxy with traditional selectors - more reliable but slower and more expensive.",
                        "default": "legacy"
                    },
                    "maxEmails": {
                        "title": "Max Emails",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Enter the maximum number of emails to collect.",
                        "default": 20
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
