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

📧 Discover the best Amazon email scraper! Effortlessly extract verified seller/customer emails for outreach, lead gen, and marketing. ⚡ Save time, boost conversions—ideal for agencies, sales teams, and researchers.

- **URL**: https://apify.com/solid-scraper/best-amazon-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 $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 📬

**Best Amazon Email Scraper** is an Apify actor that extracts business and consumer email addresses from Amazon by using your provided **keywords**, a **country** focus, and an **email type** selector (B2B or B2C). It helps you automate the process of building prospect lists for outreach, research, and lead generation.

Whether you’re looking for the best amazon email scraper tool, an amazon seller email scraper for B2B leads, or a way to scrape amazon customer emails for consumer campaigns—this actor is designed to save you hours of manual work.

---

### Why choose Best Amazon Email Scraper?

| Feature | Benefit |
|---|---|
| ✅ **All-in-one Amazon email harvesting** | Extract emails from amazon listings using keywords, country, and B2B/B2C filtering in one run |
| ✅ **Reliability-first engine choice** | Choose `cost-effective` or `legacy` engine to balance speed and reliability for email harvesting |
| ✅ **Scale with `maxEmails` control** | Keep scraping time and cost predictable by setting `maxEmails` |
| ✅ **Structured dataset output** | Produces a clean dataset with fields like `email`, `email_domain`, and `email_type` for easy analysis |
| ✅ **Automation-ready workflow** | Suitable for bulk email scraper amazon use cases where you repeatedly run keyword batches |
| ✅ **Proxy support for consistent scraping** | Includes built-in proxy support for more reliable scraping across regions |

---

### Key features

- 🔍 **Keyword-driven email finding**: Uses your provided keywords to drive which publicly available Amazon-related pages are scraped for contact emails.
- 🌍 **Country targeting**: Lets you focus results by selecting a country to match your target market for amazon contact email finder workflows.
- 💼 **B2B vs B2C email types**: Choose `emailType` as `B2B` or `B2C` to tailor your lead generation email scraper results.
- 🛡️ **Engine options for resilience**: Pick `cost-effective` for faster/cheaper scraping or `legacy` for a more reliable approach (still with built-in resilience).
- 📊 **Comprehensive structured results**: Each scraped email is stored with context fields such as `keyword`, `title`, `url`, `description`, and `email_domain`.
- 💾 **Dataset saved as you go**: Results are pushed into the Apify dataset for easy export after the run completes.
- ⏱️ **Cost/time control with maxEmails**: A clear limit for how many emails the actor aims to collect (useful for amazon email list scraper operations).
- 🔄 **Designed for bulk runs**: Works well when you need an amazon outreach email scraper approach across multiple keyword ideas and markets.

---

### Input

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

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

#### Input Fields

| Field | Required | Description |
|---|---:|---|
| `keywords` | ✅ | One or more keywords to search for on Amazon (e.g., `fitness`, `marketing`). |
| `country` | ✅ | The country focus for the actor’s search targeting (selected from the provided country list). |
| `scrapeFrom` | ✅ | Choose which regional Amazon site to scrape (e.g., `Amazon US`, `Amazon Germany`, `Amazon UK`). |
| `emailType` | ✅ | Select the email type: `B2C` for consumer emails or `B2B` for business emails. |
| `engine` | ❌ | Choose the scraping engine: `cost-effective` (Cost Effective (New)) or `legacy` (Legacy). Default is `legacy`. |
| `maxEmails` | ✅ | Maximum number of emails to collect. Must be between `1` and `10000`. Default is `20`. |

***

### Output

The actor saves scraped results in a dataset as JSON rows, using the following fields:

```json
[
  {
    "keyword": "fitness",
    "title": "Example listing/contact title",
    "url": "https://example.com/profile",
    "description": "Example snippet/description from the public source",
    "email": "info@example.com",
    "email_domain": "example.com",
    "email_type": "B2C",
    "scrape_from": "Amazon US",
    "country": "United States"
  }
]
```

#### Output Fields

| Field | Type | Description |
|---|---|---|
| `keyword` | string | The keyword that was used for this part of the scrape. |
| `title` | string | The extracted title associated with the scraped public contact source. |
| `url` | string | The URL for the scraped source (shown as a link in the dataset view). |
| `description` | string | The extracted description/snippet text from the public source. |
| `email` | string | The email address found for this record. |
| `email_domain` | string | The domain part of the email address (everything after `@`). |
| `email_type` | string | The email type label for the record (B2B or B2C). |
| `scrape_from` | string | Which regional Amazon site selection was used (from your `scrapeFrom` input). |
| `country` | string | The selected country used for targeting (from your `country` input). |

After the run, you can export the dataset in JSON/CSV from the Apify Console (recommended for amazon email list scraper and crm import workflows).

***

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

1. **Open Apify Console**\
   Log in at https://console.apify.com and go to the **Actors** tab.

2. **Find Best Amazon Email Scraper**\
   Search for the actor and open its details page.

3. **Go to the INPUT section**\
   Use the built-in input form (or paste a valid `input.json` payload).

4. **Set your keywords and targeting**\
   Add `keywords`, choose `country`, and select `scrapeFrom` (e.g., `Amazon US`).

5. **Choose your email type and limit**\
   Pick `emailType` (`B2B` or `B2C`) and set `maxEmails` to control how many emails you want for this run.

6. **Pick the engine (optional)**\
   If you need maximum reliability, keep `engine` as `legacy`. If you want a more cost-effective run profile, choose `cost-effective`.

7. **Run the actor**\
   Click **Run**. Monitor the logs during execution (including progress and any fallbacks).

8. **Open the dataset output**\
   When finished, open the **OUTPUT** tab and view the dataset titled **Scraped Emails**. Export results as JSON or CSV.

No coding required—get accurate results in minutes with this best amazon email scraper tool.

***

### Advanced features & SEO optimization

- ⚙️ **B2B outreach and B2C lead targeting**: Use `emailType` to make your amazon email harvesting software outputs more relevant for your outreach audience.
- 🧭 **Country + regional Amazon control**: Combine `country` and `scrapeFrom` to tailor the results for scrape emails from amazon marketplace lead generation email scraper campaigns.
- 🏎️ **Engine choice for faster or more reliable harvesting**: Select `cost-effective` or `legacy` based on whether speed or reliability matters more for your amazon contact email finder workflow.
- 🧰 **Structured dataset for analysis**: Every record includes `email`, `email_domain`, and source context fields like `title`, `url`, and `description`—great for amazon outreach email scraper pipelines.
- 💡 **Max emails for predictable scale**: Set `maxEmails` to manage performance for bulk email scraper amazon operations (large searches may take longer).

***

### Best use cases

- 📈 **B2B marketers building an email list**: Generate a curated amazon seller email scraper dataset with `email_type`, domains, and source context for better segmentation.
- 🎯 **Sales teams doing targeted outreach**: Extract emails from amazon listings for focused campaigns by keyword and country.
- 🤝 **Agency lead generation**: Produce prospect lists quickly using a repeatable amazon lead generation email scraper workflow across multiple keyword themes.
- 🔎 **Researchers analyzing contact patterns**: Study email domains and listing themes using structured fields like `keyword`, `email_domain`, and `description`.
- 🛒 **Brand partnership sourcing**: Find contact emails tied to listing-related pages using an email extraction tool for amazon use cases.
- 🧾 **CRM enrichment & import**: Feed results into your CRM after exporting the dataset (email + domain + source URL).
- 💬 **Consumer campaign prep (B2C)**: Use `emailType: "B2C"` to scrape amazon customer emails when you’re running consumer-focused promotions.

***

### Technical specifications

✅ **Supported Input Formats**

- Provide inputs as an `input.json` file with `keywords`, `country`, `scrapeFrom`, `emailType`, and `maxEmails`.

✅ **Proxy Support**

- Includes built-in proxy support designed to improve scraping reliability.

✅ **Retry Mechanism**

- Designed with resilience in mind (includes retries and fallbacks for robustness).

✅ **Dataset Structure**

- JSON dataset with fields: `keyword`, `title`, `url`, `description`, `email`, `email_domain`, `email_type`, `scrape_from`, `country`.

✅ **Rate Limits & Performance**

- Uses a `maxEmails` limit to help manage run time and cost.
- Larger searches or higher limits may take longer.

❌ **Limitations**

- No guarantee of email availability for every scraped source.
- Some runs may yield fewer emails than requested depending on the publicly available data found for the chosen keywords, country, and email type.

***

### FAQ

#### Is Best Amazon Email Scraper the best tool to find Amazon seller emails?

✅ Yes—**Best Amazon Email Scraper** is specifically built to help you gather email contacts from publicly available sources related to Amazon listings, using your keywords, selected country, and B2B/B2C filtering. It’s well-suited when you want an amazon email list scraper workflow without manual digging.

#### What’s the difference between B2B and B2C in this actor?

✅ `emailType` controls whether you want `B2B` or `B2C` email results. This helps the actor target business-oriented vs consumer-oriented contacts for use cases like amazon seller email scraper (B2B) or scrape amazon customer emails (B2C).

#### Which countries can I target?

✅ You can select from the provided list in the `country` input field (for example: `United States`, `United Kingdom`, `Germany`, `India`, `Japan`, and many others).

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

✅ Yes. Use `maxEmails` to set the maximum number of emails to collect for the run. This is the key control for predictable amazon email harvesting software usage.

#### Do I need to code to use this?

✅ No coding required. You can run it directly in Apify Console by configuring the inputs and then exporting the resulting dataset.

#### What does the output contain?

✅ The dataset includes structured fields such as `email`, `email_domain`, `email_type`, plus context fields like `keyword`, `title`, `url`, and `description`. This makes it easier to analyze and import into other tools.

#### Is it legal to use this for email harvesting?

✅ The actor is designed to extract emails from publicly available sources. However, you’re responsible for complying with applicable laws and platform policies (including GDPR/CCPA and spam regulations) for your specific use case.

#### Can I request data removal?

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

***

### Support & feature requests

Have questions about **Best Amazon Email Scraper**, or want to improve the results for your amazon outreach email scraper workflow? We’d love to hear from you.

- 💡 **Feature Requests**: For example, improvements like CSV export options, additional filtering, or enhancements to email extraction coverage for specific amazon email list scraper use cases.
- 📧 **Contact**: Reach out at <dataforleads@gmail.com>.

Your feedback helps shape the roadmap for this best amazon email scraper tool.

***

### Best Amazon Email Scraper

*Get started with the most comprehensive and SEO-optimized Best Amazon Email Scraper for structured email discovery at scale.*

# 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("solid-scraper/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("solid-scraper/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 solid-scraper/best-amazon-email-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Best Amazon Email Scraper",
        "description": "📧 Discover the best Amazon email scraper! Effortlessly extract verified seller/customer emails for outreach, lead gen, and marketing. ⚡ Save time, boost conversions—ideal for agencies, sales teams, and researchers.",
        "version": "1.0",
        "x-build-id": "5TljYIJuBwKFsjynl"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/solid-scraper~best-amazon-email-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-solid-scraper-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/solid-scraper~best-amazon-email-scraper/runs": {
            "post": {
                "operationId": "runs-sync-solid-scraper-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/solid-scraper~best-amazon-email-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-solid-scraper-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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
