# Best Linkedin Email Scraper (`solid-scraper/best-linkedin-email-scraper`) Actor

🚀 Find verified LinkedIn emails fast with Best LinkedIn Email Scraper! 🎯 Target leads by role, company & location for smarter outreach. 📩 Save time, boost deliverability, and grow pipeline—ideal for sales & marketing teams.

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

## Pricing

from $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

### Best Linkedin Email Scraper 📬

**Best Linkedin Email Scraper** is an Apify actor that helps you *extract business and consumer email addresses from LinkedIn* using keyword-driven crawling. Whether you’re looking for a **best LinkedIn email scraper**, a **LinkedIn email extractor tool**, or an **automated LinkedIn email scraping** workflow, this actor helps you discover leads by keyword, country, and content type—then saves results in a structured dataset so you can move faster at scale.

It’s built for marketers, recruiters, lead researchers, and analysts who want **a compliant LinkedIn email scraper** workflow without manually hunting for contact details one profile at a time.

---

### Why choose Best Linkedin Email Scraper?

| Feature | Benefit |
| --- | --- |
| ✅ **All-in-one LinkedIn email extraction** | Extract emails along with profile metadata in one run, filtered by your keywords, country, and email type |
| ✅ **Reliable engine options** | Choose between **Cost Effective (New)** and **Legacy** engines based on your speed vs. reliability needs |
| ✅ **Early stop with Max Emails** | Control cost and runtime with `maxEmails`, collecting up to the amount you request |
| ✅ **Structured dataset output** | Export-ready fields like `email`, `email_domain`, `email_type`, `scrape_from`, and `country` |
| ✅ **Scale-friendly batch runs** | Process large keyword/country searches while you manage limits for predictable scraping time |
| ✅ **Result persistence to dataset** | Emails are saved to the actor dataset in a tabular view for quick review and filtering |

---

### Key features

- 🔍 **Keyword-based email discovery**: Searches LinkedIn using your provided `keywords` to target the right audiences for lead generation.  
- 🌍 **Country targeting**: Focus results on a selected `country` to support region-specific prospecting and outreach.  
- 🧩 **Flexible “Scrape From” modes**: Choose `All`, `Profile`, `Company`, `Posts`, or `Pulse` to match your sourcing strategy (great for a **LinkedIn prospecting email scraper** workflow).  
- 📨 **B2B or B2C email type filtering**: Select `emailType` as `B2B` or `B2C` to align with your campaign and segmentation.  
- 🛡️ **Engine reliability options**: Pick `engine` = `cost-effective` or `legacy` depending on whether you prioritize faster/cheaper runs or higher reliability.  
- ⏱️ **Cost control with `maxEmails`**: Stop after collecting the maximum number of emails you request (ideal for a **LinkedIn outreach email list scraper**).  
- 💾 **Clean, structured output**: Each dataset row includes key fields for analysis, deduping, and CRM/import steps.  
- 📊 **Dataset-friendly viewing**: Results are stored so you can review them in the Apify Dataset UI and export to your stack.  

---

### Input

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

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

#### Input Fields

| Field | Required | Description |
| --- | --- | --- |
| `keywords` | ✅ | Enter one or more keywords to search for on LinkedIn (for example: “fitness”, “marketing”). |
| `country` | ✅ | Specify the country to target for the actor’s searching. Helps localize your lead list. |
| `scrapeFrom` | ✅ | Choose one option: `All`, `Profile`, `Company`, `Posts`, or `Pulse`. Selecting `All` searches across every type. |
| `emailType` | ✅ | Choose one: `B2B` or `B2C`. Use this to align extracted emails with your outreach model. |
| `engine` | ❌ | Choose scraping engine: `cost-effective` (Cost Effective (New)) or `legacy` (Legacy). Default is `legacy`. |
| `maxEmails` | ✅ | Enter the maximum number of emails to collect. Minimum `1`, maximum `10000`. Default is `20`. |

***

### Output

The actor saves the scraped results to the **Linkedin Email Data** dataset, with fields designed for email list building and research workflows.

Example output item:

```json
{
  "keyword": "marketing",
  "title": "Example LinkedIn Profile/Company/Pulse/Post Title",
  "url": "https://www.linkedin.com/in/example",
  "description": "Example description text from the source",
  "email": "name@example.com",
  "email_domain": "example.com",
  "email_type": "B2C",
  "scrape_from": "Profile",
  "country": "United States"
}
```

#### Output Fields

| Field | Type | Description |
| --- | --- | --- |
| `keyword` | string | The keyword that drove the discovery for this email result. |
| `title` | string | The title associated with the scraped source entry. |
| `url` | string | The source URL where the email was found (shown as a “View Profile” link in the dataset UI). |
| `description` | string | The description/snippet text associated with the scraped entry. |
| `email` | string | The extracted email address. |
| `email_domain` | string | The domain portion of the extracted email (e.g., `example.com`). |
| `email_type` | string | The selected email type classification (`B2B` or `B2C`). |
| `scrape_from` | string | Where the actor scraped from (matches your `scrapeFrom` mode). |
| `country` | string | The country targeted for this run’s results. |

You can then export the dataset from Apify to **JSON or CSV** (depending on your downstream tooling needs).

***

### How to use Best Linkedin Email Scraper (via Apify Console)

1. **Open Apify Console**\
   Log in at https://console.apify.com and open the actor page for **Best Linkedin Email Scraper**.

2. **Go to the INPUT panel**\
   Paste or configure the input values in the built-in form (or upload an `input.json`).

3. **Add your LinkedIn keywords**\
   Fill `keywords` with one or more topics you want to target (e.g., “fitness”, “marketing”).

4. **Select your country focus**\
   Choose `country` to localize results for region-specific lead generation (useful for a **LinkedIn lead list email scraper** strategy).

5. **Choose where to scrape from**\
   Set `scrapeFrom` to `All`, `Profile`, `Company`, `Posts`, or `Pulse` based on how you want to build your outreach list.

6. **Pick your email type**\
   Choose `emailType` as `B2B` or `B2C` so the results match your campaign segmentation.

7. **Set the engine and Max Emails**\
   Optionally change `engine` (`cost-effective` or `legacy`). Set `maxEmails` to control runtime and cost—large values may take longer.

8. **Run and monitor results**\
   Start the run, then check the logs for progress. After completion, open the **OUTPUT** tab to view your **Linkedin Email Data** dataset table and export it.

No coding required—get accurate results in minutes with this **best LinkedIn email scraper** for email-led prospecting.

***

### Advanced features & SEO optimization

- 🚀 **Engine selection for your workflow**: Use `engine` = `cost-effective` for a Cost Effective (New) approach or `legacy` for the Legacy engine—handy when you need a **best LinkedIn scraper for emails** with different performance tradeoffs.
- 🧠 **Smart keyword and country targeting**: Designed to help you run **LinkedIn email finder software** style campaigns by focusing your search inputs up front.
- 🔁 **Resilience through controlled runs**: Includes retries and fallbacks for resilience, especially helpful for large or demanding keyword/country runs.
- 🧾 **Email domain included**: With `email_domain` available per result, it’s easier to segment lists and validate deliverability assumptions.

***

### Best use cases

- 📈 **B2B sales teams building outreach lists**: Collect targeted `B2B` emails for specific niches using `keywords` and `country`, then import into your CRM.
- 🎯 **Recruiters sourcing talent leads**: Use `scrapeFrom = Profile` and `emailType = B2C` or `B2B` depending on your candidate pipeline to speed up outreach research.
- 🧠 **Market researchers analyzing contact surfaces**: Compare email domains and sourcing modes (`Profile`, `Company`, `Posts`, `Pulse`) for a keyword set to understand where contact info tends to appear.
- 🧾 **Demand generation teams**: Build a **LinkedIn outreach email list scraper** dataset with consistent fields like `url`, `description`, and `scrape_from` for easier reporting.
- 🧰 **Data analysts assembling lead enrichment datasets**: Combine `email` + `email_domain` + `country` + `keyword` for downstream scoring and deduping.
- 💻 **Marketing automation developers**: Use the actor’s structured dataset output to automate steps in your pipeline—ideal for **automated LinkedIn email scraping** jobs.

***

### Technical specifications

- **Supported Input Formats**
  - ✅ `input.json` with the actor fields: `keywords`, `country`, `scrapeFrom`, `emailType`, `engine`, `maxEmails`

- **Proxy Support**
  - ✅ Engine-based scraping with built-in support for reliable scraping runs using your selected `engine` option

- **Retry Mechanism**
  - ✅ Includes retries and fallbacks for resilience during scraping

- **Dataset Structure**
  - ✅ Writes results to dataset **“Linkedin Email Data”** with fields: `keyword`, `title`, `url`, `description`, `email`, `email_domain`, `email_type`, `scrape_from`, `country`

- **Rate Limits & Performance**
  - ✅ Uses `maxEmails` (min `1`, max `10000`) to help manage scraping time and cost
  - ⏳ Large searches or high limits may take longer

- **Limitations**
  - ❌ Emails are only extracted when they are available from publicly accessible sources
  - ❌ No guarantee of finding emails for every keyword/country combination

***

### FAQ

#### Is Best Linkedin Email Scraper able to extract both business and consumer emails?

✅ Yes. You can choose `emailType` as `B2B` or `B2C`, and the actor extracts emails accordingly. This makes it useful as a **LinkedIn contact email scraper** for different outreach styles.

#### What does “Scrape From” mean in the input?

In the input, `scrapeFrom` controls where the actor looks for relevant LinkedIn content. Options include `All`, `Profile`, `Company`, `Posts`, and `Pulse`. Selecting `All` searches across every type.

#### How do I control scraping cost and runtime?

Use `maxEmails`. It sets the maximum number of emails to collect (minimum `1`, maximum `10000`, default `20`). Higher values can collect more, but may take longer.

#### Do I need any special login or API keys?

No special login is exposed in the actor interface itself. You configure the actor via the Apify Console input fields, then run the actor to generate dataset output.

#### Can I integrate the results into my CRM or workflow?

Yes. The actor saves results to a dataset with structured fields like `email`, `email_domain`, `email_type`, and `url`. From Apify, you can export the dataset in formats commonly used in analysis pipelines (e.g., JSON/CSV depending on your workflow).

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

Use `engine` based on your priorities. `cost-effective` is labeled as Cost Effective (New), while `legacy` is labeled Legacy. If you need a **best LinkedIn email extractor** approach that balances speed vs. reliability, try `legacy` first and switch based on your results.

#### Where do the emails come from?

The actor extracts emails from publicly available data sources. It does not target private or password-protected information.

#### Is this suitable for automated lead generation at scale?

💻 Yes—this **LinkedIn lead generation email scraper** is designed for keyword- and country-driven runs with an email limit (`maxEmails`) so you can manage scale in a predictable way.

***

### Support & feature requests

Want to improve your Best Linkedin Email Scraper workflow? 💡 Share feedback or feature requests—your input helps shape the roadmap.

- 💡 **Feature Requests**: Examples include CSV export enhancements, custom filtering improvements, or additional dataset fields for outreach workflows.
- 📧 **Contact**: Reach out at <dataforleads@gmail.com>

Thanks for helping make Best Linkedin Email Scraper better for **LinkedIn email extraction** and lead research use cases!

***

### Best Linkedin Email Scraper — Final thoughts 🚀

*If you’re after the most comprehensive Best Linkedin Email Scraper for email-led LinkedIn prospecting, this actor gives you structured results you can review, export, and use immediately.*

*Run it with the right `keywords`, `country`, and `emailType`—and scale your outreach faster than manual research.*

***

### Disclaimer

**This tool only accesses publicly accessible sources.** It does not access private profiles, authenticated data, or password-protected pages.

You are responsible for complying with applicable laws and regulations (including GDPR, CCPA), as well as respecting platform terms and spam/email marketing rules. For data removal requests, contact <dataforleads@gmail.com>.

Use **Best Linkedin Email Scraper** responsibly, ethically, and for legitimate purposes only.

# Actor input Schema

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

Enter one or more keywords to search for on Linkedin.

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

Specify the country to target for Google search results.

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

Choose one option — All, Profile, Company, Posts, or Pulse.

## `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": [
    "developer",
    "founder"
  ],
  "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": [
        "developer",
        "founder"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("solid-scraper/best-linkedin-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": [
        "developer",
        "founder",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("solid-scraper/best-linkedin-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": [
    "developer",
    "founder"
  ]
}' |
apify call solid-scraper/best-linkedin-email-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Best Linkedin Email Scraper",
        "description": "🚀 Find verified LinkedIn emails fast with Best LinkedIn Email Scraper! 🎯 Target leads by role, company & location for smarter outreach. 📩 Save time, boost deliverability, and grow pipeline—ideal for sales & marketing teams.",
        "version": "1.0",
        "x-build-id": "lCc0nLehA1mZFiq6H"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/solid-scraper~best-linkedin-email-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-solid-scraper-best-linkedin-email-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/solid-scraper~best-linkedin-email-scraper/runs": {
            "post": {
                "operationId": "runs-sync-solid-scraper-best-linkedin-email-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/solid-scraper~best-linkedin-email-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-solid-scraper-best-linkedin-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 Linkedin.",
                        "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",
                            "Profile",
                            "Company",
                            "Posts",
                            "Pulse"
                        ],
                        "type": "string",
                        "description": "Choose one option — All, Profile, Company, Posts, or Pulse.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
