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

📧 Amazon Email Scraper finds verified seller & brand emails using keywords, categories, and regions. Speed up outreach for sales, agencies & lead-gen teams—export results instantly. 🚀 Save time, reach the right contacts.

- **URL**: https://apify.com/solid-scraper/amazon-email-scraper.md
- **Developed by:** [SolidScraper](https://apify.com/solid-scraper) (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 web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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

### Amazon Email Scraper 📬

**Amazon Email Scraper** helps you **scrape emails from Amazon bios and posts related to your keywords**, so you can quickly build outreach-ready leads without manual searching. Whether you’re a marketer, recruiter, or data enthusiast looking for an *Amazon email scraper*, this tool automates extracting an **Amazon contact email scraper** style dataset at scale—ideal for **Amazon leads email scraper** workflows. Use it to find relevant emails using your keywords and email-domain filters, saving you hours of manual work.

***

### Why choose Amazon Email Scraper?

| Feature | Benefit |
| --- | --- |
| ✅ Keyword-driven extraction | Pulls emails that match the topics you care about, instead of generic searching |
| ✅ Domain filtering via custom email domains | Targets specific recipient types (for example, `@gmail.com`) to improve relevance |
| ✅ Built-in resilience with retries and fallbacks | Helps maintain output quality even when pages don’t load cleanly |
| ✅ Reliability-focused proxy support | Uses your proxy configuration to improve scraping stability |
| ✅ Structured JSON output | Produces consistent rows with `keyword`, page context, email, and source URL fields |
| ✅ Easy to scale with limits | Use `maxEmails` to control runtime and cost while collecting up to your target volume |

***

### Key features

- 🔍 **Accurate Amazon contact email extraction**: Finds email addresses from **public Amazon bios and posts related to your keywords**
- 🧠 **Smart keyword targeting**: Search by topic to make your **Amazon email harvesting tool** results more relevant to your campaign
- 🌐 **Custom email-domain filtering**: Narrow results by providing `customDomains` like `@gmail.com` for tighter **Amazon outreach email scraper** targeting
- 🛡️ **Resilient scraping engine options**: Choose between `cost-effective` and `legacy` engines depending on your reliability vs. speed needs
- 🔄 **Retry and stop conditions for efficiency**: Includes stopping logic like `maxEmails`, and halts when additional pages aren’t producing new results
- 💾 **Progress persistence**: Saves progress during the run so long jobs are less likely to lose work
- 📊 **Dataset-friendly structure**: Each discovered email is pushed with clear context (keyword, title/description context, and result URL) for downstream analysis

***

### Input

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

```json
{
  "keywords": ["founder", "marketing"],
  "location": "New York",
  "platform": "Amazon",
  "customDomains": ["@gmail.com"],
  "maxEmails": 50,
  "engine": "cost-effective",
  "proxyConfiguration": {}
}
```

#### Input Fields

| Key | Required | Description |
| --- | --- | --- |
| `keywords` | ✅ Yes | A list of keywords to search for. These keywords drive what kind of Amazon bios and posts the actor focuses on when extracting emails. |
| `location` | ❌ No | Location to filter search results. Leave empty to use no location filtering. |
| `platform` | ❌ No | Select platform. For this actor, the only available option is `Amazon`. |
| `customDomains` | ❌ No | List of custom email domains used to filter emails (for example, `@gmail.com`). This helps you build a more targeted **Amazon email list scraper**. |
| `maxEmails` | ❌ No | Maximum number of emails to collect. The scraper will stop once this limit is reached. Higher limits can take longer and don’t guarantee the exact number. |
| `engine` | ❌ No | Choose scraping engine. Use `cost-effective` for a more cost-effective approach, or `legacy` for a legacy scraping approach that may be more reliable but can be slower. |
| `proxyConfiguration` | ❌ No | Proxy configuration for this Actor. This lets you control how the actor routes requests for better reliability. |

***

### Output

The actor saves results as **individual JSON rows** into the default Apify dataset by calling `Actor.push_data(row)`.

Example output row:

```json
{
  "network": "Amazon.com",
  "keyword": "founder",
  "title": "Example page title",
  "description": "Example page description/context text",
  "url": "https://www.example.com/source-url",
  "email": "contact@example.com",
  "proxyGroups": ["example-proxy-group-1"]
}
```

#### Output Fields

| Field | Type | Description |
| --- | --- | --- |
| `network` | string | The source network label. For this actor, it is set to `Amazon.com`. |
| `keyword` | string | The keyword from your input that was used for this extraction run. |
| `title` | string | Title text extracted from the result context (as provided in the parsed result). |
| `description` | string | Description/context text extracted alongside the title. |
| `url` | string | The URL associated with the extracted content where the email was found. |
| `email` | string | The extracted email address. |
| `proxyGroups` | array | Proxy groups information used by the scraper in that row (driven by the selected engine/proxy configuration). |

Note: The actor stops when `maxEmails` is reached (if provided), and it also avoids adding duplicate emails using an internal “seen emails” set.

***

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

1. **Open Apify Console**\
   Go to [console.apify.com](https://console.apify.com) and sign in, then open the **Actors** section.

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

3. **Configure your INPUT**\
   In the **INPUT** panel, add values for at least `keywords` (required).\
   Optional fields like `location`, `customDomains`, `maxEmails`, `engine`, and `proxyConfiguration` help you tailor results.

4. **Pick an engine for your run**\
   Choose `engine` as `cost-effective` or `legacy` depending on your preference for speed/cost vs. legacy reliability.

5. **Run the actor**\
   Click **Run**. During execution you’ll see logs that reflect progress and when limits (like `maxEmails`) are reached.

6. **Monitor progress**\
   The actor persists progress while it’s running, which helps reduce the risk of losing work during long runs.

7. **Open the OUTPUT dataset**\
   When the run finishes, open the dataset from the **OUTPUT** tab to review the pushed rows.

8. **Export and use the data**\
   Export the dataset to your preferred format (JSON/CSV available in Apify UI) and use it for your **Amazon outreach email scraper** pipeline.

No coding required—get accurate results in minutes.

***

### Advanced features & SEO optimization

- 🧩 **Engine choice for your workflow**: Tune between `cost-effective` and `legacy` when using an **Amazon email scraper tool** for different reliability needs
- 🎯 **Domain-aware targeting**: With `customDomains`, your **Amazon business email finder** output is filtered to the recipient types you want
- 📏 **Cost control with `maxEmails`**: Set a hard stop to balance volume vs. runtime—useful for bulk email scraping for Amazon campaigns
- 💾 **Progress persistence for long jobs**: Progress is stored during execution, which is helpful for large keyword lists or high limits
- 🔍 **Keyword expansion behavior**: You can re-run with broader or related terms if you see low output—this is commonly effective for **extract emails from Amazon** workflows

***

### Best use cases

- 📈 **Lead generation for Amazon-based businesses**: Build targeted email lists by extracting emails that appear in publicly accessible Amazon bios and posts matching your keywords
- 🎯 **B2B outreach campaigns**: Filter by `customDomains` to focus on the right inbox types for higher outreach relevance
- 🔎 **Market research and competitive profiling**: Combine keyword context (`keyword`, `title`, `description`, `url`) with extracted contacts for structured analysis
- 🧑‍💼 **Recruiter sourcing**: Identify potential founders or marketers listed publicly on Amazon profiles as part of your sourcing research
- ✉️ **Bulk email harvesting for Amazon outreach**: Use `maxEmails` to scale **Amazon email harvesting tool** runs while controlling cost and runtime
- 🧱 **Data enrichment pipelines**: Feed the structured dataset rows into CRMs, spreadsheets, or downstream analytics (email + source context per row)
- 🧪 **Research experiments**: Run controlled keyword/domain combinations to compare email coverage across niches using the same extraction output schema

***

### Technical specifications

- **Supported Input Formats**
  - ✅ `keywords` as an array (required)
  - ✅ `location` as a string (optional)
  - ✅ `platform` as `Amazon` (optional, default provided)
  - ✅ `customDomains` as an array (optional, default provided)
  - ✅ `maxEmails` as an integer between 1 and 10000 (optional)
  - ✅ `engine` as `cost-effective` or `legacy` (optional)
  - ✅ `proxyConfiguration` object (optional)

- **Proxy Support**
  - ✅ Yes — supported via `proxyConfiguration`, and the actor can use the selected engine alongside your proxy settings.

- **Retry Mechanism**
  - ✅ Yes — includes resilience logic so runs are more robust when pages don’t load cleanly.

- **Dataset Structure**
  - ✅ One dataset row per extracted email, pushed via `Actor.push_data(row)` with fields:
    - `network`, `keyword`, `title`, `description`, `url`, `email`, `proxyGroups`

- **Rate Limits & Performance**
  - ✅ Runtime depends on your `keywords` list and `maxEmails`.
  - ✅ The actor uses stop conditions to avoid running indefinitely once enough emails are collected.

- **Limitations**
  - ❌ Results depend on publicly available email addresses appearing in the target bios/posts and matching your `customDomains`.
  - ❌ A higher `maxEmails` can increase runtime; it does not guarantee reaching that exact number.

***

### FAQ

#### Do I need to write code to use Amazon Email Scraper?

✅ No. You can run **Amazon Email Scraper** directly from Apify Console by filling in the INPUT form (or providing an `input.json` file).

#### What does Amazon Email Scraper actually extract?

✅ It extracts email addresses from **publicly accessible sources** on Amazon—specifically from Amazon bios and posts related to the keywords you provide in `keywords`.

#### Can I control which emails I want (for example, only `@gmail.com`)?

✅ Yes. Use `customDomains` to filter emails by domain, such as `@gmail.com`, so your **Amazon contact email scraper** results stay targeted.

#### What happens if I set `maxEmails` high?

✅ The actor will keep collecting until it reaches your `maxEmails` limit, but it may stop earlier if it runs out of new emails. Larger limits can take longer.

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

✅ Choose `cost-effective` for a more cost-effective approach, or `legacy` for the legacy approach. If you’re getting fewer results, you can re-run with broader keywords and different domains as suggested in the actor input description.

#### Does the output include source context for each email?

✅ Yes. Each pushed row includes `title`, `description`, and the associated `url` along with `email` and the input `keyword`.

#### Can I use Amazon Email Scraper with custom proxy settings?

✅ Yes. Use the `proxyConfiguration` field to control proxy behavior for the actor run.

#### Is scraping legal and compliant?

❌ Compliance depends on how you use the collected data and the applicable laws and platform terms. Always ensure your usage is lawful and respectful of privacy and anti-spam requirements.

***

### Support & feature requests

Have feedback on **Amazon email scraper** results, or want improvements for Amazon outreach workflows? We’d love to hear from you.

- 💡 **Feature Requests**: Examples include enhancements like additional export formats, better filtering options, or workflow improvements for **Amazon email extraction software** users
- 📧 **Contact**: Reach out at <dataforleads@gmail.com>

Your input helps shape what we build next for **Amazon Email Scraper**.

***

### *Amazon Email Scraper* — build your Amazon outreach email list at scale

*If you’re searching for the most comprehensive Amazon email scraper tool for lead building, this is the quickest path from keywords to actionable contact rows.*

***

### Disclaimer

**This tool accesses publicly accessible sources only.** It does not access private profiles, authenticated data, or password-protected content. It is your responsibility to comply with all applicable laws and regulations (including GDPR/CCPA where relevant), as well as platform terms and any anti-spam rules.

If you need data removal, contact <dataforleads@gmail.com>. Use this tool responsibly, ethically, and for legitimate purposes only.

# Actor input Schema

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

A list of keywords to search for.

## `location` (type: `string`):

Location to filter search results.

## `platform` (type: `string`):

Select platform.

## `customDomains` (type: `array`):

List of custom email domains

## `maxEmails` (type: `integer`):

Maximum number of emails to collect. The scraper will stop once this limit is reached. Setting a higher limit allows for more potential results but doesn't guarantee reaching that number. This helps save costs by controlling scraping time.

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

## `proxyConfiguration` (type: `object`):

Configure proxies for this Actor.

## Actor input object example

```json
{
  "keywords": [
    "founder",
    "marketing"
  ],
  "location": "",
  "platform": "Amazon",
  "customDomains": [
    "@gmail.com"
  ],
  "maxEmails": 20,
  "engine": "cost-effective"
}
```

# 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": [
        "founder",
        "marketing"
    ],
    "location": "",
    "customDomains": [
        "@gmail.com"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("solid-scraper/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": [
        "founder",
        "marketing",
    ],
    "location": "",
    "customDomains": ["@gmail.com"],
}

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

```

## MCP server setup

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

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/sxQBz0zQhMdvw0lvj/builds/vOT9bSIC4t6vaei3g/openapi.json