# Facebook B2b Email Scraper (`scraperoka/facebook-b2b-email-scraper`) Actor

🚀 Facebook B2B Email Scraper extracts business emails from Facebook pages/groups fast and accurately. 🏢 Perfect for lead generation, sales outreach & targeted B2B marketing. 📩 Save time, grow pipelines—reach the right decision-makers.

- **URL**: https://apify.com/scraperoka/facebook-b2b-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 $2.99 / 1,000 results

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

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.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

### Facebook B2b Email Scraper 🎯

Manually collecting business emails from Facebook profiles, pages, and groups wastes hours you don’t have. **Facebook B2b Email Scraper** pulls business contact emails at scale using keyword and location targeting—so you can build outreach lists fast. This **Facebook B2b Email Scraper** (facebook b2b email scraper) is ideal for marketers, recruiters, and growth teams looking to find b2b emails on Facebook and extract them into a clean dataset, often returning thousands of leads in minutes.

---

### What You Get: Sample Output

Here's a sample record from a single run:

```json
{
  "keyword": "fitness",
  "title": "Gym & Workout Community",
  "url": "https://www.facebook.com/groups/1234567890/",
  "description": "Weekly training tips, schedules, and member support. 📩 Email for inquiries in the page details.",
  "email": "hello@fitworkouts.com",
  "email_domain": "fitworkouts.com",
  "scrape_from": "Groups",
  "country": "United States",
  "error_message": null
}
````

| Field | Type | What It Tells You |
|---|---|---|
| `keyword` | string | Which keyword you used to discover this contact |
| `title` | string | The title associated with the Facebook item where the email was found |
| `url` | string | A direct link back to the Facebook page/item for quick verification |
| `description` | string | Context text captured alongside the email (useful for manual review) |
| `email` | string | The extracted business email address you can add to outreach lists |
| `email_domain` | string | Domain to help you deduplicate and segment by company |
| `scrape_from` | string | What content type the email came from (for example, Profiles or Groups) |
| `country` | string | The target country used for the run so you can localize outreach |
| `error_message` | string or null | Populated only when something goes wrong for a record |

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

***

### Why Facebook B2b Email Scraper?

There are a lot of ways to pull contact data from Facebook — here’s what sets **Facebook B2b Email Scraper** apart when you need a Facebook lead email scraper workflow that’s fast and practical.

#### Keyword, Country, and Content-Type Targeting

With Facebook B2b Email Scraper, you control what you search for by using `keywords`, choosing a `country`, and selecting `scrapeFrom` (All, Profiles, Reels, Posts, Groups, Videos, Photos, Events, or Marketplace). That means your output stays focused—ideal for facebook outreach email list building and b2b email scraping tool use cases.

#### Bulk-Ready Output for Outreach Lists

The actor writes structured records to your dataset with fields like `email`, `email_domain`, `scrape_from`, `url`, and the matching `keyword`. If you’re searching for a facebook company email extractor or facebook email harvesting software experience, you’ll get results formatted for analysis and list building right away.

#### Resilience for Real-World Scraping Runs

The run includes practical retry and fallback behavior for better resilience under imperfect conditions, so you can complete larger facebook b2b email scraper jobs without constantly babysitting the process.

#### Flexible “Max Emails” for Cost Control

Use `maxEmails` to cap how many emails you want to collect in a run (from 1 up to 10000). This helps keep your facebook b2b email scraping tool runs predictable while you test different keyword batches and regions.

***

### Configuring Your Run

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

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

| Parameter | Required | What It Does |
|---|---|---|
| `keywords` | ✅ | One or more search keywords to look for on Facebook |
| `country` | ✅ | The country to target for the run (used for location-focused results) |
| `scrapeFrom` | ✅ | What kind of Facebook content to scrape from: All, Profiles, Reels, Posts, Groups, Videos, Photos, Events, or Marketplace |
| `engine` | ⬜ | Choose the scraping engine: `cost-effective` or `legacy` (a newer cost-effective option is available) |
| `maxEmails` | ✅ | Cap the maximum number of emails to collect in the run (1–10000) |

***

### Core Capabilities

#### Fast Lead Discovery with Search Controls

You can steer Facebook B2b Email Scraper toward your ideal leads using `keywords`, `country`, and `scrapeFrom`. This helps you scrape business emails from Facebook in a more controlled way—rather than collecting unrelated contacts.

#### Built for B2B Outreach Workflows

Each dataset record includes outreach-ready fields like `email`, `email_domain`, and a clickable `url` back to the source item. That makes it easy to build a facebook outreach email list you can analyze, deduplicate, and pass into CRM or outreach tools.

#### Resilient Collection with Fallbacks

For real-world reliability, the actor is designed to continue effectively even when requests fail or return empty results. It’s built to handle the practical messiness of data collection so your runs finish with more usable output.

#### Structured Data Completeness

The output includes consistent metadata along with the email, such as `keyword`, `title`, `description`, `scrape_from`, and `country`. This is exactly what you want from a facebook company email extractor or facebook company email extractor-style tool when you need context—not just raw addresses.

#### Scale Up with a Clear Output Cap

The `maxEmails` setting helps you scale runs up for testing and production without losing control. If you’re using a facebook lead email scraper to find b2b emails on Facebook across multiple niches, you’ll appreciate this built-in limiter.

Overall, Facebook B2b Email Scraper helps you go from discovery to structured email data with less manual work.

***

### Who Gets the Most Out of This

**Sales Development Reps** — Use Facebook B2b Email Scraper to collect b2b emails from Facebook for specific niches by setting `keywords`, selecting a target `country`, and choosing `scrapeFrom` to focus on the content types your ICP is most active in. You end up with an outreach-ready list containing `email`, `email_domain`, and the source `url`, so you can validate quickly and start conversations sooner.

**Marketing Teams (Campaign & Segmentation)** — Marketing teams can run multiple keyword batches and compare the resulting `email_domain` distributions and `scrape_from` breakdowns. That makes it easier to build and refine a facebook outreach email list for experiments like “different niches” or “different regions,” using clean, structured records from a facebook b2b email scraper.

**Recruiters and Talent Sourcing Leads** — If your outreach targets organizations with public contact emails, this actor provides a practical way to collect business contact emails tied to relevant Facebook items. The combination of `keyword`, `title`, `description`, and `url` helps recruiters understand why a lead was found and reduces time spent on manual lookups.

**Data Analysts & Researchers** — Analysts benefit from the dataset’s structured fields like `email`, `email_domain`, `scrape_from`, and `country`. You can filter results, deduplicate by domain, and study how different keyword strategies perform—turning facebook b2b email scraping tool outputs into analyzable data rather than messy notes.

**Automation & Integration Specialists** — If you’re building repeatable workflows, Facebook B2b Email Scraper fits well into automation pipelines because results are written to a dataset with stable field names. You can programmatically trigger runs, pull outputs via the Apify API, and feed results into your downstream systems for scheduled prospecting or reporting—useful for a facebook email harvesting software workflow.

***

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

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

1. **Open** the actor on Apify — start from the actor page on [console.apify.com](https://console.apify.com).
2. **Enter** your inputs — add `keywords`, choose a `country`, set `scrapeFrom`, and decide your `maxEmails` cap (plus `engine` if you want to switch engines).
3. **Configure** proxy settings if prompted by your run environment — use the default or adjust based on your preferences for reliability.
4. **Hit Run** and watch the live logs — keep an eye on progress as the actor collects emails and writes records to the dataset.
5. **View** results in the dataset tab — each record includes `email`, `email_domain`, `scrape_from`, and a source `url`.
6. **Export** as JSON, CSV, or Excel — download directly from the Apify dashboard for CRM import or analysis.

The whole process takes under 5 minutes to set up.

***

### Integrations & Export Options

Once your data is collected, Facebook B2b Email Scraper plugs directly into your existing workflow. You can export results from the Apify dataset tab as JSON, CSV, or Excel for analysis, enrichment, or importing into outreach tools.

For automation, you can also connect your Apify runs to tools via Apify’s native capabilities and through no-code automation platforms like Zapier/Make. If you’re building a custom pipeline, you can access results programmatically via the Apify API, and if your workflow supports it, you can trigger downstream actions with webhooks when runs complete.

If you need recurring lead discovery, schedule repeated runs so your facebook lead email scraper output stays up to date without manual effort.

***

### Pricing & Free Trial

Facebook B2b Email Scraper runs on the Apify platform, which offers a **free tier** — no credit card required to get started. In Apify, usage typically works on a pay-as-you-go model based on platform compute units, and you can scale up when your keyword lists and countries grow.

To see the latest pricing and what’s included in the free tier, check the Apify pricing page on [apify.com](https://apify.com). Start for free at [apify.com](https://apify.com) and scale when you're ready.

***

### Reliability & Performance

| What We Handle | How |
|---|---|
| Rate-limit-like conditions | Built-in handling to keep runs moving and return usable results |
| Scraping variability | Retries and fallbacks for resilience |
| Large lead lists | Controlled collection using `maxEmails` so you can manage output size |
| Structured results | Consistent dataset fields for emails plus context (like `url` and `scrape_from`) |
| Run interruptions | Results are written to the dataset as the actor progresses |

**Limitations:** The actor is designed to work with **publicly available data** on Facebook. If a target item doesn’t have a business email available in the accessible content, you may receive empty or limited contact fields. For enterprise-scale runs, contact us to discuss custom configurations.

***

### Frequently Asked Questions

#### Is there a free plan or trial for Facebook B2b Email Scraper?

Yes—Apify provides a **free tier** so you can test Facebook B2b Email Scraper before scaling up. The exact amount of free usage depends on current Apify offerings.

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

No. Facebook B2b Email Scraper is designed to work from publicly available data, so you typically don’t need a Facebook login for the run.

#### How accurate is the data extracted by this facebook b2b email scraper?

Accuracy depends on what is publicly available in the content the actor can access for each match. The actor returns extracted email fields along with context fields such as `url`, `title`, and `description` to help you verify results.

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

You control that using `maxEmails`, which caps the maximum number of emails to collect. Set it from 1 to 10000 based on your testing or production needs.

#### How fresh is the data?

Data freshness depends on what’s currently visible in publicly available Facebook content at the time you run the actor. Since you control when you start runs, you can re-run with new keywords or countries to refresh results.

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

The actor uses **publicly available data** and does not require login-gated access. It’s still your responsibility to ensure your use, storage, and outreach practices comply with GDPR, CCPA, and applicable regulations.

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

Yes. You can export your dataset as JSON, CSV, or Excel directly from the Apify dashboard. From there, you can import into Google Sheets or any CRM that accepts CSV/Excel.

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

Yes. On Apify, you can configure runs to execute automatically on a schedule, which is helpful for continuously growing a facebook outreach email list over time.

#### Can I access this via API?

Yes. You can access results programmatically via the Apify API. This is useful if you want to integrate the facebook company email extractor output into your own data pipeline.

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

The actor is built to be resilient with retries and fallbacks. If a record fails or an email cannot be captured, the dataset still provides structured output fields, and error-related details may appear in `error_message` when applicable.

***

### Need Help or Have a Request?

Got a question about Facebook B2b Email Scraper or want a new feature added? Reach out at <dataforleads@gmail.com>. We welcome requests like batch CSV upload workflows and webhook notifications on completion, and we keep the actor maintained based on user feedback.

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

## `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",
  "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/facebook-b2b-email-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = { "keywords": [
        "fitness",
        "gym",
        "workout",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("scraperoka/facebook-b2b-email-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "keywords": [
    "fitness",
    "gym",
    "workout"
  ]
}' |
apify call scraperoka/facebook-b2b-email-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Facebook B2b Email Scraper",
        "description": "🚀 Facebook B2B Email Scraper extracts business emails from Facebook pages/groups fast and accurately. 🏢 Perfect for lead generation, sales outreach & targeted B2B marketing. 📩 Save time, grow pipelines—reach the right decision-makers.",
        "version": "1.0",
        "x-build-id": "8mJifaLg3h0SLcuyy"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scraperoka~facebook-b2b-email-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scraperoka-facebook-b2b-email-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/scraperoka~facebook-b2b-email-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scraperoka-facebook-b2b-email-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/scraperoka~facebook-b2b-email-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scraperoka-facebook-b2b-email-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "keywords",
                    "country",
                    "scrapeFrom",
                    "maxEmails"
                ],
                "properties": {
                    "keywords": {
                        "title": "Keywords",
                        "type": "array",
                        "description": "Enter one or more keywords to search for on 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"
                    },
                    "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
