# Best Amazon Email Scraper (`scraperoka/best-amazon-email-scraper`) Actor

📧 Best Amazon Email Scraper extracts verified email addresses from Amazon listings with advanced filters & fast scraping. 🔎 Perfect for outreach, lead generation & B2B marketing. ✅ Save time, boost conversions, and stay compliant. 🚀

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

## Pricing

from $1.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/docs.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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 Amazon Email Scraper ⚡
Manually hunting for contact emails tied to Amazon sellers and profiles wastes hours you don’t have. **Best Amazon Email Scraper** automatically extracts email addresses from publicly available web sources using your keywords, country, and email-type filters. This best Amazon email scraper helps marketers, recruiters, and growth teams find Amazon leads email scraper targets faster—scale to thousands of records in a single run.

### What You Get: Sample Output
Here's a sample record from a single run:

```json
{
  "keyword": "fitness",
  "title": "Fitness Brand Contact Page",
  "url": "https://example.com/contact",
  "description": "Contact us for business inquiries and email support.",
  "email": "contact@fitnessbrand.com",
  "email_domain": "fitnessbrand.com",
  "email_type": "B2B",
  "scrape_from": "Amazon US",
  "country": "United States",
  "error_message": null,
  "status": "success"
}
````

**Output fields table (what the dataset contains):**

| Field | Type | What It Tells You |
|---|---|---|
| `keyword` | string | The keyword that drove the lookup so you can segment leads by theme (e.g., “workout” or “marketing”). |
| `title` | string | A human-readable title for the page where the email was found—useful for quick quality checks. |
| `url` | string | The source link behind the email so you can verify it and understand context. |
| `description` | string | The extracted page snippet/description that supports why this contact is relevant. |
| `email` | string | The contact email address you can import into outreach and CRM tools. |
| `email_domain` | string | The email domain extracted alongside the email to help with deduping and company-level analysis. |
| `email_type` | string | Whether the email was categorized as B2B or B2C for better targeting. |
| `scrape_from` | string | Which regional Amazon site selection was used for the run (for reporting and lead routing). |
| `country` | string | The country value you targeted to focus results for your lead list. |
| `status` | string | A run state indicator so you can quickly spot success vs failure in downstream processing. |
| `error_message` | string | Error details when something goes wrong, so you can troubleshoot without guessing. |

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

### Why Best Amazon Email Scraper?

There are a lot of ways to pull email data from Amazon-related lead sources—here's what sets Best Amazon Email Scraper apart.

#### Keyword-first lead discovery

You provide `keywords`, plus a `country`, and the actor uses that to drive which contacts it tries to find. This makes the best Amazon email scraper especially handy for Amazon outreach email scraper workflows where relevance matters.

#### Flexible targeting with email-type filters

Pick `emailType` as **B2B** or **B2C** to tailor your Amazon customer email extractor output to the type of contacts you actually want. That keeps your Amazon email list scraper cleaner and easier to segment.

#### Controlled volume with `maxEmails`

You can cap results with `maxEmails` to manage scraping time and cost. This gives you a practical “lead volume dial” for bulk email scraper for Amazon campaigns without running indefinitely.

#### Resilient scraping engine options

Choose an `engine` mode for different trade-offs in speed and reliability. That makes this Amazon contact email finder a better fit for both quick tests and larger lead-gathering runs.

### Configuring Your Run

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

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

**Input fields table:**

| Parameter | Required | What It Does |
|---|---|---|
| `keywords` | ✅ | Enter one or more keywords to search for on Amazon. |
| `country` | ✅ | Specify the country to target for results. |
| `scrapeFrom` | ✅ | Choose which regional Amazon site to scrape (for example, “Amazon US”). |
| `emailType` | ✅ | Choose one — **B2C** or **B2B**. |
| `engine` | ⬜ | Select the scraping engine mode (Cost Effective (New) vs Legacy). |
| `maxEmails` | ✅ | Enter the maximum number of emails to collect (from 1 to 10000). |

### Core Capabilities

#### Bulk lead extraction from Amazon-relevant sources

Best Amazon Email Scraper extracts email addresses using your `keywords`, `country`, and `scrapeFrom` selections. It’s designed to help you scrape Amazon emails at scale without manual page-by-page hunting.

#### Structured dataset output for analysis and outreach

Each result is written with consistent fields like `email`, `email_domain`, `email_type`, `url`, and the originating `keyword`. That means your Amazon email harvesting tool output is ready for segmentation, deduping, and CRM import.

#### Deduplication and cleaner results

The actor avoids duplicates based on the final extracted entries so your Amazon outreach email scraper workflow starts with less cleanup. This makes it a strong option for building an Amazon prospecting email scraper list.

#### Resilience for large searches

The actor is built for longer runs and includes retry and fallback behavior for resilience. Large searches or high email limits may take longer, and you can increase timeouts in Run Options (default is 3600 s / 1 hr).

#### Pagination and early stop behavior

It processes multiple pages and can stop early when it detects consecutive pages returning no new results. This helps keep runs cost-controlled for Amazon leads email scraper use cases.

### Who Gets the Most Out of This

Here’s how different teams put Best Amazon Email Scraper to work:

**Marketing teams** use it to quickly expand prospect lists by keyword, then route B2B vs B2C contacts into the right campaigns. The outcome is more outreach coverage with far less manual research time.

**Sales and lead generation reps** run Amazon email harvesting tool jobs for specific niches (like “fitness” or “marketing”) and export the results into their CRM or outreach stack. They get usable emails plus the supporting `url` and `description` context for faster verification.

**Recruiters and HR teams** use B2B mode to find business-focused contacts relevant to partnerships, supplier networks, or service providers. This turns a vague search into an actionable contact database.

**Data analysts and researchers** pull structured datasets for analysis by `email_domain`, `email_type`, `scrape_from`, and `country`. The output supports deduping, enrichment workflows, and reporting without reformatting.

**Automation specialists and developers** integrate runs via the Apify platform to refresh lead lists on demand. They benefit from predictable dataset fields when building end-to-end automation pipelines with the Apify API.

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

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

1. **Open the actor on Apify** — go to [console.apify.com](https://console.apify.com) and find Best Amazon Email Scraper.
2. **Enter your inputs** — set `keywords`, `country`, `scrapeFrom`, `emailType`, and `maxEmails` (see the Configuring Your Run section).
3. **Choose your engine** — pick the `engine` option that matches your speed vs reliability needs.
4. **Configure proxy settings** — use your run’s proxy configuration for reliability (set via Apify Run Options).
5. **Hit Run and watch the live log** — monitor progress as emails are collected.
6. **View results in the dataset tab** — inspect the table with fields like `email`, `email_domain`, and `url`.
7. **Export as JSON, CSV, or Excel** — download directly from the Apify dashboard for immediate use.

The whole process takes under 5 minutes to set up.

### Integrations & Export Options

Once your data is collected, Best Amazon Email Scraper plugs directly into your existing workflow.

You can download results from the Apify dataset tab as **JSON, CSV, or Excel**, making it simple to move into spreadsheets, BI tools, or outreach systems. For “Amazon compliance email data” workflows, exporting also helps you document sources using the included `url`.

If you use automation, you can connect this actor to **Zapier or Make** (via Apify integrations), trigger downstream actions with **webhooks**, and run the actor automatically on a schedule. For programmatic access, use **API access** through the Apify API: https://apify.com/docs/api

### Pricing & Free Trial

Best Amazon Email Scraper runs on the Apify platform, which offers a **free tier** — no credit card required to get started. Free tier credits are typically enough for several test runs, so you can validate output quality before scaling.

For production runs, Apify uses pay-as-you-go pricing based on Actor compute units (CU). Start for free at [apify.com](https://apify.com) and scale when you're ready.

### Reliability & Performance

| What We Handle | How |
|---|---|
| Large searches and time-bound runs | Uses a default timeout of 3600 s / 1 hr (you can increase it in Run Options for large jobs). |
| Scraping resilience | Includes retries and fallbacks to reduce the chance of empty outputs. |
| Reliability across runs | Supports choosing different `engine` modes to match your needs. |
| Data freshness for lead building | Produces a structured dataset per run that you can refresh on demand. |
| Error visibility | Errors are surfaced via dataset fields so you can identify issues downstream. |

**Limitations:** This actor targets publicly available sources. It can only extract the emails that are available from those sources, and result count is influenced by your `maxEmails` setting and the availability of matching contact information.

For enterprise-scale runs, contact us to discuss custom configurations.

### Frequently Asked Questions

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

Yes. Apify offers a free tier, which is designed to help you run a few test jobs before scaling.

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

No. This Best Amazon Email Scraper is designed to extract emails from publicly available sources without requiring Amazon login.

#### How accurate is the data?

Accuracy depends on what’s publicly available on the source pages and how well your `keywords`, `country`, and `emailType` match the right audience. The dataset includes both `email` and the source `url` so you can verify quickly.

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

You control the upper limit using `maxEmails` (minimum 1, maximum 10000). If matching sources are limited, you may receive fewer results than your cap.

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

The dataset reflects what the actor extracts during that specific run. If you need fresher data, schedule runs and re-export the updated dataset.

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

Use responsibly. The actor accesses **publicly available data**, and it’s your responsibility to ensure your use of the extracted emails complies with GDPR/CCPA and applicable local regulations and platform terms.

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

Yes. You can export the dataset as JSON, CSV, or Excel from the Apify dashboard. For Google Sheets workflows, you can also connect via Apify automations or no-code tools like Zapier/Make.

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

Yes. You can set up scheduled runs on the Apify platform so your Amazon email list stays refreshed without manual reruns.

#### Can I access this via API?

Yes. You can retrieve results programmatically using the Apify API. See: https://apify.com/docs/api

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

The run will log errors, and the dataset can include failure-state details through fields like `error_message`/`status`. That way, you can identify issues and re-run with adjusted inputs if needed.

### Need Help or Have a Request?

Got a question about Best Amazon Email Scraper or want a new feature added? Reach out at <dataforleads@gmail.com>. We actively maintain this actor and respond to requests—ideas like webhook notifications on completion and batch upload workflows are always welcome.

### Disclaimer & Responsible Use

*Best Amazon Email Scraper is the fastest, most reliable way to build an Amazon outreach email scraper list — start your free run today.*

This actor collects **publicly available data**. It does not access private accounts, login-gated content, or password-protected pages. You are responsible for complying with GDPR, CCPA, applicable spam laws, and platform terms when using the extracted contacts. For data removal requests, contact <dataforleads@gmail.com>. Use responsibly, ethically, and only for lawful purposes.

# Actor input Schema

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

Enter one or more keywords to search for on Amazon.

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

Specify the country to target for Google search results.

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

Choose which regional Amazon site to scrape.

## `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": "Amazon US",
  "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-amazon-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-amazon-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-amazon-email-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Best Amazon Email Scraper",
        "description": "📧 Best Amazon Email Scraper extracts verified email addresses from Amazon listings with advanced filters & fast scraping. 🔎 Perfect for outreach, lead generation & B2B marketing. ✅ Save time, boost conversions, and stay compliant. 🚀",
        "version": "1.0",
        "x-build-id": "NR42WDWjlL8PTnSbZ"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scraperoka~best-amazon-email-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scraperoka-best-amazon-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-amazon-email-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scraperoka-best-amazon-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-amazon-email-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scraperoka-best-amazon-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 Amazon.",
                        "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": [
                            "Amazon US",
                            "Amazon India",
                            "Amazon Germany",
                            "Amazon UK",
                            "Amazon Japan",
                            "Amazon Canada",
                            "Amazon France",
                            "Amazon Italy",
                            "Amazon Spain",
                            "Amazon Brazil",
                            "Amazon Australia",
                            "Amazon Mexico",
                            "Amazon UAE",
                            "Amazon Saudi Arabia",
                            "Amazon Netherlands"
                        ],
                        "type": "string",
                        "description": "Choose which regional Amazon site to scrape.",
                        "default": "Amazon US"
                    },
                    "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
