# Amazon Email Scraper - Multi-Engine, Type Targeted (`scrapido/amazon-contact-extractor`) Actor

🛒 Amazon Email Scraper runs multi-engine search with address-type filtering. 🌍 Country and region targeting keeps Amazon leads relevant, while alias merging and decoding keep your list clean. 💼 Built for ecommerce B2B prospecting.

- **URL**: https://apify.com/scrapido/amazon-contact-extractor.md
- **Developed by:** [Scrapido](https://apify.com/scrapido) (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 $2.50 / 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** is a practical Amazon email extraction tool built for marketers, data analysts, and researchers who need public contact data without the manual grind. Use it as an Amazon email finder, Amazon contact scraper, or Amazon lead generator to collect structured leads faster and at scale. It’s a smart way to support Amazon seller leads, Amazon vendor email finder workflows, and broader ecommerce email scraper campaigns. 🚀

### What is Amazon Email Scraper? 🔍

Amazon Email Scraper is an Apify actor that helps you collect public emails and related profile details from Amazon-related pages based on your search terms, country, and source region settings. It’s designed for Amazon data extraction at scale, helping you turn repetitive manual research into a fast, repeatable workflow.

This Amazon contact scraper is useful for marketers building outreach lists, analysts tracking niche marketplace contacts, and researchers mapping Amazon business activity. By using the provided search terms and filters, the actor helps identify relevant public web data and organize it into a clean dataset. If you need an Amazon email extractor or Amazon business email extraction workflow, this actor is built to save time and improve lead generation efficiency. 📬

### What Data Does Amazon Email Scraper Collect? 📊

This Amazon marketplace email extraction tool saves structured records with contact details, page metadata, and lookup context. Each result includes the search term that surfaced it, the page title, the profile URL, and the extracted email information.

| Data Category | Fields Extracted | Description |
|---|---|---|
| Contact | `email` | Public email address found in the result |
| Identity | `title` | Name or title associated with the result |
| Context | `description` | Summary or descriptive text from the page |
| Discovery | `keyword` | Search term that surfaced the result |
| Navigation | `url` | Direct link to the page |
| Domain | `email_domain` | Email domain extracted from the address |
| Type | `email_type` | Email category selected in the input |
| Source | `scrape_from` | Source label saved with the result |
| Geography | `country` | Target country used for the run |

### What Do Results from Amazon Email Scraper Look Like? 👀

Each result is stored as a structured JSON record in your Apify dataset. Here’s a realistic example of what Amazon email harvesting output can look like in practice:

```json
{
  "keyword": "fitness",
  "title": "Sarah Mitchell",
  "url": "https://www.amazon.com/sp?ie=UTF8&seller=A3H8K9L2M1N0P",
  "description": "Independent wellness brand owner and Amazon marketplace seller",
  "email": "sarah.mitchell@wellnessstudio.com",
  "email_domain": "wellnessstudio.com",
  "email_type": "B2B",
  "scrape_from": "Amazon US",
  "country": "United States"
}
```

Export formats: JSON in the Apify dataset and CSV via the Apify Console. ✅

#### Core Features: Amazon Email Scraper ⚡

| Feature | Benefit |
|---|---|
| ✅ **Search-Term Targeting** | Find relevant Amazon seller leads and Amazon store contact scraper results using your own keywords |
| ✅ **Country Selection** | Focus extraction on a specific country for better regional relevance |
| ✅ **Source Region Filter** | Choose the Amazon regional index that matches your target market |
| ✅ **B2B or B2C Mode** | Adapt the run to either business contacts or consumer-style contact discovery |
| ✅ **Result Cap Control** | Set `maxEmails` to keep runs focused and cost-efficient |
| ✅ **Structured Dataset Output** | Get clean, labeled records that are easy to export and analyze |
| ✅ **Built-In Resilience** | Includes retries and fallbacks for more reliable public web scraping |
| ✅ **Proxy Support** | Built-in proxy support for reliable scraping at scale |

### Getting Started with Amazon Email Scraper 🚀

1. **Open Apify Store** — Go to the Apify Store and search for Amazon Email Scraper.
2. **Open the Input Tab** — Configure your extraction settings in the built-in form.
3. **Add Search Terms** — Enter the keywords you want to use for Amazon leads scraping.
4. **Choose a Country** — Select the country you want to target.
5. **Select a Source Region** — Pick the Amazon regional index that fits your audience.
6. **Choose Email Type** — Select either B2C or B2B.
7. **Set Your Limit** — Use `maxEmails` to cap the number of emails collected.
8. **Run the Actor** — Start the job and monitor progress in real time.
9. **Export Your Data** — Download the dataset as JSON or CSV when the run finishes.

No coding required. It’s a fast way to build Amazon seller email finder and Amazon marketplace email extraction workflows. ⚙️

### Ways to Use Amazon Email Scraper 💡

- 🎯 **Amazon Seller Outreach** — Build targeted contact lists for outreach campaigns and partnerships
- 📣 **Email Marketing** — Collect public emails for newsletters, launches, and follow-ups
- 🔍 **Market Research** — Study Amazon business contact patterns across niches and regions
- 🤝 **Lead Generation** — Turn Amazon product listing email lookup tasks into structured lead lists
- 📊 **CRM Enrichment** — Add public contact data to your existing customer or prospect database
- ⚙️ **Research Automation** — Scale Amazon contact extraction tool workflows without manual copy-paste

#### Input Parameters — Amazon Email Scraper

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

| Parameter | Type | Required | Default | Description |
|---|---|---|---|---|
| `country` | String | Yes | `United States` | Choose the country used for targeting results. |
| `emailType` | String | Yes | `B2C` | Select whether you want B2C or B2B email targeting. |
| `engine` | String | No | `legacy` | Choose the scraping engine. |
| `maxEmails` | Integer | Yes | `20` | Set the maximum number of emails to collect. |
| `searchTerms` | Array | Yes | `["fitness","gym","workout"]` | Add the keywords used to find relevant Amazon profiles. |
| `sourceRegion` | String | Yes | `Amazon US` | Select the Amazon regional index to target. |

#### Output Parameters — Amazon Email Scraper

| Field | Label | Format | Description |
|---|---|---|---|
| `keyword` | Keyword | text | The search term that surfaced the result. |
| `title` | Title | text | The title or name associated with the result. |
| `url` | URL | link | Direct link to the page. |
| `description` | Description | text | Summary or supporting text from the page. |
| `email` | Email | text | Public email address found in the result. |
| `email_domain` | Email Domain | text | Domain portion of the extracted email address. |
| `email_type` | Email Type | text | The selected email category for the run. |
| `scrape_from` | Scrape From | text | Source label saved with the result. |
| `country` | Country | text | Target country used for the search. |

### Why Choose This Amazon Email Scraper? 🏆

If you need reliable Amazon email harvesting without wasting hours on manual copy-paste, this actor gives you a structured workflow, clear filters, and export-ready results. It’s built for speed, scale, and practical lead generation, making it a strong fit for ecommerce email scraper use cases.

You also get a cleaner workflow than ad hoc research because the output is standardized and easy to move into a CRM, spreadsheet, or outreach tool. For support or feedback, contact <scrapido.support@gmail.com>. ✉️

### How Many Results Can You Scrape? 📈

You can set `maxEmails` anywhere from 1 to 10,000. The number of results you actually receive depends on how many public contacts are available for your search terms, country, and source region. For larger Amazon lead extraction runs, the built-in proxy support and retry logic help improve reliability while keeping the process manageable.

### Legal Guidelines for Scraping Amazon ⚖️

Amazon Email Scraper collects only publicly available data. It does not require private access or authenticated pages. You are responsible for using the data in line with applicable laws, platform rules, and your own compliance requirements, including privacy and spam regulations. Use extracted contacts for legitimate business purposes only. For data removal requests, please contact <scrapido.support@gmail.com>.

### FAQ — Amazon Email Scraper ❓

#### How does Amazon Email Scraper work?

You provide search terms, country, source region, and email type, and the actor processes publicly available data to return structured contact records. It’s designed to support Amazon contact extraction tool workflows without manual research.

#### What Amazon profile types can I scrape?

You can scrape public Amazon-related pages that surface relevant contact details and profile information. Results depend on what is publicly available for your keywords and filters.

#### Why use Amazon Email Scraper for lead generation?

It helps you turn scattered public contact data into organized Amazon seller leads and Amazon vendor email finder lists that are easier to sort, export, and action.

#### How much does Amazon Email Scraper cost?

Your costs depend on how many results you collect and how you configure the run. Use `maxEmails` to keep the run focused and predictable.

#### How does Amazon Email Scraper help my business?

It saves time by converting manual Amazon marketplace email extraction into structured data you can use for outreach, research, or CRM enrichment.

#### What challenges should I expect when using Amazon Email Scraper?

Not every result will contain a public email. Yield depends on your search terms, region choice, and how visible the contact details are on publicly accessible pages.

#### How do I choose a high-performing Amazon Email Scraper?

Look for clear filters, structured output, result caps, and reliable scraping behavior. This Amazon email scraper includes all of those essentials in one workflow.

### Conclusion 🏁

Amazon Email Scraper is a fast, practical way to extract public contact data from Amazon-related pages at scale. Whether you’re building Amazon seller email finder lists, enriching your CRM, or running Amazon business email extraction campaigns, it helps you move from manual research to actionable results. 🚀

### 🆘 Support & Feedback

Have a question or feature request for the Amazon Email Scraper?

- 🐞 **Bug Reports:** Share any issues you encounter during a run
- ✨ **Feature Requests:** Suggest improvements for Amazon email extraction or lead workflows
- 📧 **Email:** <scrapido.support@gmail.com>

### Multiple Email Types

**Email Types** replaces the old single Audience Type choice: select as many
kinds of mailbox as you want and the run chases all of them together.

| Type | What it matches |
| --- | --- |
| Personal / free webmail | Gmail, Outlook, Yahoo, iCloud, AOL, Proton, ... |
| Business / corporate | Company domains - free webmail and institutions excluded |
| Education (.edu / .ac) | `.edu`, `.ac.uk`, `.edu.au`, `.ac.in` and other academic suffixes |
| Government (.gov / .mil) | `.gov`, `.mil`, `.gov.uk`, `.gc.ca`, ... |
| Non-profit (.org) | `.org`, `.ngo`, `.org.uk`, ... |

Each selected type contributes its own Google dork patterns *and* its own domain
test, so a result is only kept if it genuinely belongs to the type that found
it. Every row carries an `emailType` field recording which one that was.

Suffixes are matched as real domain suffixes, so `cs.mit.edu` counts as
Education while `notedu.com` does not.

Setting **Custom Email Domains** still overrides everything: an explicit domain
list is a manual override and replaces the type-driven patterns. The legacy
`audienceType` value is still accepted, so saved inputs keep working.

# Actor input Schema

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

Specify the country to target for Google search results.

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

## `searchTerms` (type: `array`):

List of queries to find Amazon profiles.

## `sourceRegion` (type: `string`):

Select the regional index to target.

## `emailTypes` (type: `array`):

Which kinds of mailbox to hunt for. Pick as many as you like - each type contributes its own set of Google search patterns and its own domain filter, and every result records the type it was found as. Personal = free webmail (Gmail, Outlook, Yahoo, iCloud). Business = company domains, excluding free webmail and institutions. Education = .edu / .ac.uk and friends. Government = .gov / .mil. Non-profit = .org.

## Actor input object example

```json
{
  "country": "United States",
  "emailType": "B2C",
  "engine": "legacy",
  "maxEmails": 20,
  "searchTerms": [
    "fitness",
    "gym",
    "workout"
  ],
  "sourceRegion": "Amazon US",
  "emailTypes": [
    "Personal",
    "Business"
  ]
}
```

# Actor output Schema

## `dataset` (type: `string`):

No description

# 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 = {
    "searchTerms": [
        "fitness",
        "gym",
        "workout"
    ],
    "emailTypes": [
        "Personal",
        "Business"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapido/amazon-contact-extractor").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 = {
    "searchTerms": [
        "fitness",
        "gym",
        "workout",
    ],
    "emailTypes": [
        "Personal",
        "Business",
    ],
}

# Run the Actor and wait for it to finish
run = client.actor("scrapido/amazon-contact-extractor").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "searchTerms": [
    "fitness",
    "gym",
    "workout"
  ],
  "emailTypes": [
    "Personal",
    "Business"
  ]
}' |
apify call scrapido/amazon-contact-extractor --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,scrapido/amazon-contact-extractor"
        }
    }
}

```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

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