# Best Twitter Email Scraper (`scraperoka/best-twitter-email-scraper`) Actor

🚀 Best Twitter Email Scraper helps you extract verified email leads from Twitter/X profiles fast and accurately. 📩 Perfect for B2B sales, outreach, and lead generation. 🔎 Save time, boost targeting, and grow your pipeline effortlessly.

- **URL**: https://apify.com/scraperoka/best-twitter-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

### Best Twitter Email Scraper 📬

**Best Twitter Email Scraper** automatically extracts email addresses from publicly available X (Twitter) pages, using your selected **keywords**, **country**, and **email type** to help you build targeted lead lists faster. If you’re searching for the best Twitter email scraper, a Twitter to email scraper, or a Twitter email finder tool, this actor streamlines the process of finding relevant contacts for outreach—whether you’re a marketer, recruiter, or data enthusiast—saving you hours of manual work at scale.

---

### Why choose Best Twitter Email Scraper?

| Feature | Benefit |
| --- | --- |
| ✅ **All-in-one Twitter email harvesting** | Extract emails from X (Twitter) using your keywords, country, and email-type filters in one run |
| ✅ **Built-in reliability options** | Includes resilience-focused scraping engines and fallbacks to help keep runs productive |
| ✅ **Structured dataset output** | Saves results with clear fields like `email`, `email_domain`, `email_type`, and profile `url` |
| ✅ **Scale controls for time & cost** | Use `maxEmails` to cap how many emails are collected per run |
| ✅ **Real-world lead-building workflow** | Great for building a Twitter email list builder and email outreach campaigns |
| ✅ **Designed for bulk extraction** | Use it as a bulk Twitter email scraper to quickly grow your Twitter leads email scraper lists |

---

### Key features

- 🔎 **Accurate email collection from X (Twitter)**: Extracts `email` and `email_domain` tied to the scraped X (Twitter) content  
- 🧩 **Flexible search targeting**: Combine one or more **keywords**, a **country**, and a chosen **Email Type** (B2B or B2C)  
- 🗂️ **Scrape scope control (All / Status / Profile)**: Choose where to scrape from using `scrapeFrom` for broader or narrower targeting  
- 🛡️ **Resilience-focused scraping options**: Offers an `engine` setting for cost-effective vs legacy behavior, helping runs succeed under different conditions  
- 🔄 **Limit-based run control**: Use `maxEmails` (min 1, max 10000) to manage scraping time and budget  
- 💾 **Immediately usable structured results**: Outputs a dataset table-ready with keyword, profile info, and extracted email fields  
- 🌍 **Country-focused targeting**: Uses the `country` input to focus results for more relevant email leads  

---

### Input

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

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

#### Input Fields

| Field | Required | Description |
| --- | --- | --- |
| `keywords` | ✅ | Enter one or more keywords to search for on X (Twitter). Use this to match your niche so the Best Twitter Email Scraper finds relevant accounts and contact signals. |
| `country` | ✅ | Specify the country to target. This helps focus results geographically for more usable Twitter email finder tool output. |
| `scrapeFrom` | ✅ | Choose one option—`All`, `Status`, or `Profile`. Use `All` to search across every type. |
| `emailType` | ✅ | Choose `B2B` or `B2C` depending on whether you want business or consumer-oriented emails. |
| `engine` | ❌ | Choose `cost-effective` (Cost Effective (New)) or `legacy` (Legacy). `legacy` is the default. |
| `maxEmails` | ✅ | Enter the maximum number of emails to collect. Set a practical cap to manage scraping time and cost. (Allowed: 1–10000; default: 20.) |

***

### Output

The actor saves results into the default dataset view **“Scraped Emails”** as table-ready records.

#### Output JSON example

```json
[
  {
    "keyword": "fitness",
    "title": "Example Profile Title",
    "url": "https://x.com/exampleprofile",
    "description": "Example description text",
    "email": "contact@example.com",
    "email_domain": "example.com",
    "email_type": "B2C",
    "scrape_from": "All",
    "country": "United States"
  }
]
```

#### Output Fields

| Field | Type | Description |
| --- | --- | --- |
| `keyword` | string | The keyword used to generate this lead result |
| `title` | string | The title text associated with the scraped X (Twitter) source |
| `url` | string | The X (Twitter) URL for the profile/source (shown as “View Profile” in the dataset table) |
| `description` | string | The scraped description/snippet content |
| `email` | string | The extracted email address |
| `email_domain` | string | The domain part of the extracted email (for grouping and filtering) |
| `email_type` | string | The selected email type (`B2B` or `B2C`) for this extraction |
| `scrape_from` | string | Where the scraper was instructed to scrape from (`All`, `Status`, or `Profile`) |
| `country` | string | The selected country used for targeting |

You can export your dataset from the Apify Console (for example, as JSON or CSV) and use it directly in your outreach pipeline or CRM workflow.

***

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

1. **Open Apify Console**: Log in at https://console.apify.com and open the **Actors** page.
2. **Find the actor**: Search for **Best Twitter Email Scraper** and open the actor details page.
3. **Configure the INPUT**: In the **INPUT** panel, fill in the required fields: `keywords`, `country`, `scrapeFrom`, `emailType`, and `maxEmails`.
4. **Optional: choose an engine**: If you need different performance/cost behavior, set `engine` to `cost-effective` or `legacy` (default is `legacy`).
5. **Run the actor**: Click **Run** to start. During execution, you’ll be able to monitor logs and see progress while the actor extracts email addresses from publicly available sources.
6. **Review results in OUTPUT**: After completion, open the dataset named **“Scraped Emails”** (table view: “Scraped Emails”).
7. **Export for analysis or outreach**: Export the dataset in the format you need (JSON/CSV workflows work well for email list building, including Twitter email list builder and lead generation pipelines).

No coding required—get accurate Twitter email harvesting software style results in minutes.

***

### Advanced features & SEO optimization

- ⚙️ **Keyword-driven lead discovery**: Engineered for Twitter email scraping tool workflows by combining `keywords` with `country` targeting to improve relevance for extract emails from Twitter accounts use cases.
- 🧭 **Scope control with `scrapeFrom`**: Use `scrapeFrom` = `All`, `Status`, or `Profile` to fine-tune where you want the Best Twitter Email Scraper to look for contact signals—useful for targeting specific Twitter email harvesting strategies.
- 🧱 **Email quality grouping with `email_domain`**: The dataset includes `email_domain`, making it easy to filter, deduplicate, or segment leads for your Twitter contact email extractor workflow.
- 📈 **Cost/time management with `maxEmails`**: A practical control point for bulk Twitter email scraper operations when building a Twitter email list builder or Twitter leads email scraper dataset.
- 🔌 **Designed for automation**: Works well in recurring lead-gen tasks, including Twitter DM email scraper style investigations (focused on publicly available email signals).

***

### Best use cases

- 📈 **Sales teams building outbound lists**: Quickly grow a Twitter email list builder for lead generation outreach without manually checking accounts one by one.
- 🧠 **Market researchers**: Analyze contact patterns by niche keyword and country to support a Twitter email list builder and Twitter user email lookup research workflow.
- 🎯 **Agencies scaling prospecting**: Use Best Twitter Email Scraper to assemble a Twitter email harvesting software dataset for new client campaigns.
- 🧷 **CRM enrichment pipelines**: Feed extracted `email` and `email_domain` into automation for deduping and segmentation in a Twitter email scraping tool workflow.
- 💼 **Recruiters and HR teams (B2B)**: Collect professional contact emails with `emailType` = `B2B` for hiring and partnership outreach lists.
- 🛒 **Ecommerce and consumer brands (B2C)**: Build B2C-focused contact lists for consumer support and brand inquiries using `emailType` = `B2C`.
- 🧾 **Data analysts**: Use structured outputs (`keyword`, `email_type`, `country`, `scrape_from`) to quantify lead sources across many runs.

***

### Technical specifications

- **Supported Input Formats**
  - ✅ `keywords` as an array of strings
  - ✅ `country` as a string from the provided enum list
  - ✅ `scrapeFrom` as `All`, `Status`, or `Profile`
  - ✅ `emailType` as `B2C` or `B2B`
  - ✅ `maxEmails` as an integer (min `1`, max `10000`, default `20`)
  - ✅ `engine` as `cost-effective` or `legacy` (default `legacy`)

- **Proxy Support**
  - ✅ Supports built-in engine/proxy behaviors via the `engine` option (Cost Effective (New) vs Legacy)

- **Retry Mechanism**
  - ✅ Includes resilience-focused scraping behavior (engine selection is provided to help keep runs successful)

- **Dataset Structure**
  - ✅ Default dataset view: **“Scraped Emails”**
  - ✅ Dataset table fields: `keyword`, `title`, `url`, `description`, `email`, `email_domain`, `email_type`, `scrape_from`, `country`

- **Rate Limits & Performance**
  - ✅ Controlled by `maxEmails`
  - ✅ Large runs may take longer (run-time depends on your limits and selected engine)

- **Limitations**
  - ❌ No guarantee that every scraped profile/source will contain an email address
  - ❌ Higher `maxEmails` values increase runtime and cost risk compared to smaller batches

***

### FAQ

#### Does Best Twitter Email Scraper work for both B2B and B2C email finding?

✅ Yes. You can choose `emailType` as either `B2B` or `B2C`, and the output includes the `email_type` field so you can keep results consistent in your Twitter email finder tool workflows.

#### What does `scrapeFrom` mean?

✅ `scrapeFrom` lets you control where the actor focuses: `All` (broadest), `Status`, or `Profile`. The dataset includes `scrape_from` so you can track the scope used for each run.

#### Can I limit how many emails I collect?

✅ Yes. Use `maxEmails` to set the maximum number of emails the actor should collect. This is the key control for cost and time management.

#### Is there a difference between `engine: legacy` and `engine: cost-effective`?

✅ Yes. The actor exposes two options via the `engine` input: **Cost Effective (New)** (`cost-effective`) and **Legacy** (`legacy`). You can pick the one that best fits your speed vs reliability expectations for Twitter email scraping tool jobs.

#### What data is included in the output dataset?

✅ The actor saves records with fields including `keyword`, `title`, `url`, `description`, `email`, `email_domain`, `email_type`, `scrape_from`, and `country`. This makes it easy to build a clean Twitter contact email extractor dataset.

#### Do I need to write any code to use this actor?

✅ No. You can run it directly in Apify Console using the built-in input form, then export the dataset for JSON/CSV-friendly processing.

#### How should I handle legal and compliance requirements?

✅ **You are responsible for complying with applicable laws and platform policies.** The Best Twitter Email Scraper collects information from **publicly accessible sources**, but you must ensure your use (including outreach and email marketing) follows GDPR/CCPA, spam regulations, and the relevant terms of service.

#### Can I request data removal?

✅ Yes. For data removal requests, contact <dataforleads@gmail.com>.

***

### Support & feature requests

Want to improve Best Twitter Email Scraper or request enhancements for Twitter leads email scraper workflows? 💡

- 💡 **Feature Requests**: Ideas like additional export options (CSV/JSON shaping), more segmentation helpers, or deeper lead-qualification fields are welcome—share what would make your Twitter email list builder workflow faster.
- 📧 **Contact**: Email us at <dataforleads@gmail.com>.

Your feedback helps shape the roadmap for Best Twitter Email Scraper.

***

### *Best Twitter Email Scraper* — Final thoughts

*If you’re looking for the best Twitter email scraper for lead generation, this SEO-optimized actor gives you structured, export-ready results from publicly available sources.* Get started and build your Twitter email harvesting software dataset at scale.

***

### Disclaimer

**This tool accesses publicly accessible sources only.** It does not access private profiles, authenticated data, or password-protected pages. You are responsible for ensuring your use complies with applicable laws (including GDPR/CCPA where relevant), spam regulations, and platform terms of service.

For data removal requests, contact <dataforleads@gmail.com>. Always use this actor responsibly, ethically, and for legitimate purposes.

# Actor input Schema

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

Enter one or more keywords to search for on X (Twitter).

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

Specify the country to target for Google search results.

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

Choose one option — All, Status, or Profile.

## `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-twitter-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-twitter-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-twitter-email-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Best Twitter Email Scraper",
        "description": "🚀 Best Twitter Email Scraper helps you extract verified email leads from Twitter/X profiles fast and accurately. 📩 Perfect for B2B sales, outreach, and lead generation. 🔎 Save time, boost targeting, and grow your pipeline effortlessly.",
        "version": "1.0",
        "x-build-id": "3kX6qk3HyLDYQCfPY"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scraperoka~best-twitter-email-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scraperoka-best-twitter-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-twitter-email-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scraperoka-best-twitter-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-twitter-email-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scraperoka-best-twitter-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 X (Twitter).",
                        "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",
                            "Status",
                            "Profile"
                        ],
                        "type": "string",
                        "description": "Choose one option — All, Status, or Profile.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
