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

Amazon Email Scraper extracts publicly visible email addresses from Amazon.com search results using targeted keywords, email domains, location filters, and exclusion words. Get structured contact data for lead generation, research, and business intelligence.

- **URL**: https://apify.com/email\_scraper/amazon-email-scraper.md
- **Developed by:** [Email Scraper](https://apify.com/email_scraper) (community)
- **Categories:**
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.49 / 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.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#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 Overview

**Amazon Email Scraper** is an Apify Actor designed to discover publicly published email addresses associated with Amazon.com search results. It searches Google for Amazon pages using your keywords, selected email domains, and an optional location filter, then extracts matching email addresses from search-result descriptions.

The **Amazon Email Scraper** is useful for lead generation, prospect research, market research, contact discovery, and data collection where publicly visible Amazon-related contact information is relevant. You can provide multiple keywords and multiple email domains to expand search coverage.

Instead of manually searching Amazon and checking individual results, the **Amazon Email Scraper** automates Google-based discovery and returns structured records containing the keyword, result title, description, URL, and extracted email address.

The Actor searches only the publicly available information exposed through Google search results. It does not claim access to private Amazon accounts, private contact information, or restricted data.

### Amazon Email Scraper Features

The **Amazon Email Scraper** combines keyword targeting, domain filtering, optional geographic targeting, exclusion rules, pagination, duplicate prevention, and incremental dataset storage.

Key capabilities include:

- Search Amazon.com results using custom keywords or queries.
- Filter discovered email addresses by domains such as `@gmail.com`.
- Add multiple custom email domain suffixes.
- Optionally narrow searches using a country, state, or city.
- Exclude snippets containing unwanted words or phrases.
- Process every keyword and email-domain combination.
- Extract email addresses from Google result descriptions.
- Remove duplicate email addresses across the run.
- Push discovered records incrementally to the Apify Dataset.
- Use the Apify `GOOGLE_SERP` proxy group for Google search requests.
- Retry failed requests with proxy rotation.
- Persist progress so processing can resume after interruption.

The **Amazon Email Scraper** is particularly useful when a single broad search does not provide enough relevant results. Combining specific keywords, several email domains, and carefully selected locations can increase search coverage.

### Amazon Email Scraper Features for Targeted Discovery

The **Amazon Email Scraper** supports a matrix of keywords and email domains. For example, if you provide three keywords and two email domains, the Actor processes six keyword-domain combinations.

The `maxEmails` value is applied independently to each keyword and domain combination. Therefore, a setting of `20` with three keywords and two domains creates up to six separate collection targets.

Actual results depend on what Google exposes in its Amazon search results. A target is not a guarantee that the requested number of unique email addresses will be found.

### How to Use the Amazon Email Scraper

Using the **Amazon Email Scraper** is straightforward:

1. Enter one or more keywords.
2. Optionally enter a location.
3. Add the email domains you want to search for.
4. Set the maximum email target.
5. Optionally provide words or phrases to exclude.
6. Start the Actor.
7. Review the resulting records in the Apify Dataset.

For stronger discovery, use specific search terms rather than relying on one broad keyword. For example, instead of only searching for `fitness`, you can use terms such as `fitness coach`, `fitness trainer`, `fitness influencer`, or another relevant Amazon-related query.

The **Amazon Email Scraper** converts each keyword-domain combination into a Google query targeting Amazon.com. When a location is provided, the location is also added to the query.

### Amazon Email Scraper Data Extraction

The **Amazon Email Scraper** parses Google organic search results and examines the result descriptions for email addresses matching your selected domain suffixes.

For example, when `@gmail.com` is selected, the Actor searches for addresses ending in that domain. The extracted email is associated with the corresponding search-result title, description, and URL.

The primary extracted information includes:

- Search keyword used for discovery
- Amazon.com result title
- Search-result description
- Result URL
- Matching email address
- Network identifier in the raw dataset record

The dataset view is configured to display the keyword, title, description, URL, and email fields. The Actor itself also pushes a `network` field containing `Amazon.com`.

The **Amazon Email Scraper** extracts email addresses from the text available in Google result descriptions. It does not crawl private Amazon areas or retrieve information that is unavailable through the search results being processed.

### Amazon Email Scraper Use Cases

The **Amazon Email Scraper** can support several legitimate research and data workflows involving publicly exposed information.

#### Lead Generation

Businesses can use the **Amazon Email Scraper** to discover publicly listed contact addresses relevant to specific search terms. Keyword combinations can help narrow discovery toward particular products, industries, or audience segments.

#### Market Research

Researchers can use structured search-result data to study Amazon-related topics, businesses, product categories, and publicly visible contact information.

#### Competitor Research

The **Amazon Email Scraper** can help collect publicly exposed result information around selected competitive keywords. The resulting URLs and descriptions provide context for understanding what Google associates with those searches.

#### Business Intelligence

Collected records can be analyzed in spreadsheets, databases, or downstream workflows to identify patterns across keywords, domains, titles, descriptions, and URLs.

#### Contact Discovery

Where an email address is publicly displayed within an eligible Google result description, the Actor can extract it automatically rather than requiring manual copying.

#### Data Analysis

The structured Apify Dataset makes the collected records easier to review, filter, export, and analyze after the run.

### Input Configuration

The **Amazon Email Scraper** accepts the following inputs.

| Input           | Type             | Required | Default                     | Description                                                                                 |
| --------------- | ---------------- | -------- | --------------------------- | ------------------------------------------------------------------------------------------- |
| `keywords`      | Array of strings | Yes      | `["skincare", "cosmetics"]` | Keywords or search queries used to discover Amazon.com results.                             |
| `location`      | String           | No       | `""`                        | Optional country, state, or city added to the search query.                                 |
| `customDomains` | Array of strings | No       | `["@gmail.com"]`            | Email domain suffixes to search for, such as `@gmail.com`, `@yahoo.com`, or `@outlook.com`. |
| `maxEmails`     | Integer          | No       | `10`                        | Maximum target per keyword + domain combination. Allowed range is 1–10,000.                 |
| `excludeWords`  | Array of strings | No       | `[]`                        | Words or phrases that cause a search-result description to be skipped.                      |

#### Keywords

`keywords` is the only required input. It accepts a list of strings.

Use multiple related and specific terms to increase search coverage. Each keyword is processed separately against each configured email domain.

#### Location

`location` is optional. When populated, the value is added to the Google search query as a quoted phrase.

For example, entering `New York` causes the search to include `"New York"`. This can narrow search results, but it should be understood as a search-query filter rather than a strict geographic verification system.

#### Custom Email Domains

`customDomains` controls which email suffixes the Actor looks for.

Examples include:

```text
@gmail.com
@yahoo.com
@outlook.com
@hotmail.com
@icloud.com
```

Multiple domains can be supplied. Each domain is processed separately for each keyword.

#### Maximum Emails

`maxEmails` accepts values from `1` through `10000`, with a default of `10`.

The limit is applied per keyword-domain combination. For example, three keywords combined with two domains and `maxEmails: 20` create six collection combinations, each targeting up to 20 newly discovered addresses.

Duplicate emails are tracked globally within the run, so an address already discovered through another combination is not added again.

For free users, the implementation caps the configured per-combination target at 100 when a higher value is requested.

#### Exclude Words

`excludeWords` lets you remove unwanted search-result snippets before email extraction.

Single words are matched case-insensitively as whole words. Phrases are matched case-insensitively as substrings.

For example:

```json
["crypto", "onlyfans"]
```

If an exclusion term appears in a result description, that complete result is skipped and no email is extracted from it.

### Output Data

The **Amazon Email Scraper** pushes structured records to the Apify Dataset as emails are discovered.

| Field         | Type   | Description                                                                                   |
| ------------- | ------ | --------------------------------------------------------------------------------------------- |
| `network`     | String | Network/source identifier. The Actor sets this value to `Amazon.com`.                         |
| `keyword`     | String | Keyword responsible for discovering the result.                                               |
| `title`       | String | Title extracted from the Google organic result.                                               |
| `description` | String | Description/snippet extracted from the search result.                                         |
| `url`         | String | URL associated with the organic search result.                                                |
| `email`       | String | Email address extracted from the result description and matching the selected domain pattern. |

The dataset view is configured to prominently show `keyword`, `title`, `description`, `url`, and `email`. The raw pushed record additionally contains the `network` field.

The **Amazon Email Scraper** therefore produces more than a plain email list. Each address remains connected to the search keyword and the result context from which it was discovered, making the data easier to understand and evaluate.

### Example Input

The following example follows the actual Actor input schema:

```json
{
  "keywords": [
    "skincare",
    "cosmetics",
    "beauty products"
  ],
  "location": "New York",
  "customDomains": [
    "@gmail.com",
    "@outlook.com"
  ],
  "maxEmails": 10,
  "excludeWords": [
    "crypto",
    "onlyfans"
  ]
}
```

This configuration processes each keyword against each selected email domain, while adding `New York` to the search queries and excluding result descriptions containing the specified terms.

### Example Output

A representative record produced by the Actor has this structure:

```json
{
  "network": "Amazon.com",
  "keyword": "skincare",
  "title": "Example Amazon Result",
  "description": "Example publicly visible search-result description with contact@example.com",
  "url": "https://www.amazon.com/",
  "email": "contact@example.com"
}
```

The exact title, description, URL, and email depend on the Google search results available during the run.

### Data Quality and Reliability

The **Amazon Email Scraper** uses several mechanisms designed to make collection more resilient.

Google search pages are fetched through the Apify `GOOGLE_SERP` proxy group. If a request fails, the Actor retries the page after rotating the proxy URL. After repeated failures, processing for the current keyword-domain pair can stop rather than continuing indefinitely.

The Actor also uses pagination to examine multiple Google result pages. It can process up to 1,000 pages for a single keyword-domain combination, subject to its stopping conditions and available results.

Collection can stop early when several pages provide no new emails, when result pages become empty, or when later pages become inefficient. This prevents unnecessary searching when additional pages are unlikely to provide useful new addresses.

The **Amazon Email Scraper** also maintains a set of previously discovered emails. If the same email appears again, it is not pushed as a duplicate.

### Progress and Resume Behavior

The **Amazon Email Scraper** persists its progress in the Apify Key-Value Store.

The saved state includes the emails already discovered and the current position in the keyword-domain processing matrix. When processing is interrupted, the Actor can load the persisted state and continue from the stored cursor rather than starting completely from the beginning.

Results are also pushed incrementally to the Dataset. This means discovered records are written during processing instead of waiting until the entire search operation finishes.

### Search Intent and Amazon Data Extraction

The **Amazon Email Scraper** is intended for users searching for ways to discover Amazon-related publicly visible contact information using targeted search queries.

Typical search intent can include finding an Amazon email scraper, extracting Amazon email addresses, collecting Amazon contact data, searching Amazon-related results by keyword, or automating public email discovery.

The Actor's keyword and domain controls make it possible to tailor discovery to a particular search objective. Adding more relevant keyword variations can broaden topical coverage, while more specific terms can make searches narrower.

Location can also be used when geographic context matters, although it should not be treated as a verified physical-location field.

### Getting Better Results

Search quality depends heavily on the terms and domains supplied.

For broader coverage, consider:

- Adding several closely related keywords.
- Including specific phrases instead of only broad terms.
- Testing multiple email domains.
- Leaving the location empty when geographic targeting is unnecessary.
- Using broader geographic terms when a narrow location produces sparse results.
- Adjusting `maxEmails` according to the amount of available public data.
- Using `excludeWords` to remove irrelevant result snippets.

For example, a broad keyword such as `fitness` may be supplemented with more specific searches such as `fitness coach`, `fitness trainer`, and `online fitness coach`.

The **Amazon Email Scraper** cannot create email addresses that are not publicly exposed in the search results. If a search produces fewer addresses than the requested target, that generally means fewer matching results were available or the configured search criteria were restrictive.

### Why Use the Amazon Email Scraper

The **Amazon Email Scraper** removes repetitive manual work from a keyword-based Amazon contact discovery workflow.

Instead of manually performing searches, opening results, checking snippets, copying addresses, and organizing them, the Actor handles search processing and structured dataset collection automatically.

Its main practical advantages are:

- **Keyword targeting:** Search according to your own terms.
- **Domain targeting:** Select the email suffixes that matter to your workflow.
- **Location targeting:** Add optional geographic context.
- **Exclusion filtering:** Skip descriptions containing unwanted terms.
- **Duplicate prevention:** Avoid repeatedly storing the same email.
- **Incremental storage:** Push discovered records during the run.
- **Progress persistence:** Store processing state for resume support.
- **Proxy rotation:** Retry failed Google requests using rotated proxy URLs.
- **Structured output:** Keep contact information connected to its source context.

### API and Automation

The **Amazon Email Scraper** runs as an Apify Actor and stores its results in an Apify Dataset.

This makes it suitable for workflows where an Apify Actor is started with configured input and the resulting Dataset is consumed afterward. The Actor itself does not define additional third-party integrations in the supplied implementation.

For automation, configure the Actor inputs according to your search requirements and use the resulting Dataset records within the Apify environment or your own downstream data workflow.

The **Amazon Email Scraper** does not require you to manually manage Google search-page pagination or individually process every result page.

### Frequently Asked Questions

#### What is the Amazon Email Scraper?

The **Amazon Email Scraper** is an Apify Actor that searches Google for Amazon.com results and extracts matching publicly visible email addresses from result descriptions.

#### How does the Amazon Email Scraper find emails?

The Actor creates Google search queries targeting `site:amazon.com`, the selected keyword, and the selected email-domain suffix. It then parses organic search results and extracts matching email addresses from their descriptions.

#### What data does the Amazon Email Scraper return?

The **Amazon Email Scraper** returns the keyword, result title, description, URL, email address, and a `network` value identifying Amazon.com in the raw record.

#### Can I use multiple keywords?

Yes. The `keywords` input accepts an array of strings, allowing multiple search terms to be processed during one run.

#### Can I search multiple email domains?

Yes. The `customDomains` input accepts multiple domain suffixes. Each keyword-domain combination is processed separately.

#### Is `maxEmails` a total run limit?

No. The implementation uses `maxEmails` as a target for each keyword-domain combination. For example, three keywords and two domains create six combinations.

#### Does the Amazon Email Scraper remove duplicate emails?

Yes. The Actor maintains a set of previously discovered email addresses and skips an email if it has already been collected during the run.

#### Can I filter by location?

Yes. You can provide a country, state, or city in the `location` field. The value is added to the Google search query to narrow discovery.

#### Is location a strict geographic filter?

No. Location is used as part of the search query. The Actor does not perform a separate post-scrape verification of a profile's actual geographic location.

#### Can I exclude unwanted results?

Yes. `excludeWords` allows you to provide words or phrases. If a matching term appears in a result description, the complete result is skipped.

#### Does the Actor scrape private Amazon information?

No. The implementation searches publicly available Google result information and extracts email addresses exposed within those result descriptions. It does not provide access to private Amazon accounts or restricted information.

#### Why did I receive fewer emails than my target?

The requested target is not a guarantee. Google may provide limited matching results, duplicate addresses may already have been collected, exclusion rules may remove results, or the search may become inefficient and stop early.

#### Does the Amazon Email Scraper use proxies?

Yes. The Actor configures the Apify `GOOGLE_SERP` proxy group for Google search requests and can rotate the proxy when a request fails.

#### Does the Actor support pagination?

Yes. The Actor processes multiple Google search pages and has stopping conditions based on empty results, duplicate/no-new-email pages, and search efficiency.

#### What happens if a request fails?

The Actor retries the request after rotating the proxy. Repeated failures can cause the current keyword-domain collection process to stop.

### Responsible Data Use

The **Amazon Email Scraper** is intended for extracting publicly exposed information for legitimate research and business workflows.

Users are responsible for determining whether their collection and subsequent use of data complies with applicable laws, regulations, contractual requirements, and the terms governing the websites or services involved.

Avoid using extracted contact information for unwanted, deceptive, abusive, or unlawful communications. Treat publicly visible information responsibly and apply appropriate privacy and compliance practices to your downstream workflows.

### Support

If you encounter an issue with the **Amazon Email Scraper**, first review your keywords, email domains, location, exclusion terms, and maximum-email settings.

Sparse results can often be improved by adding related keywords, testing additional domains, broadening the location, or removing unnecessarily restrictive filters.

For Actor-specific support, use the support or issue-reporting options available through the Apify Store Actor page. For custom modifications or bespoke scraper requirements, the Actor description also provides the creator's contact channel.

### Summary

The **Amazon Email Scraper** provides a structured way to search Google for Amazon.com results and extract publicly visible email addresses matching your selected domains.

With keyword targeting, optional location filtering, custom email domains, exclusion rules, duplicate prevention, pagination, proxy rotation, incremental dataset output, and persisted progress, the Actor is designed to simplify keyword-driven Amazon contact discovery.

For the best results, use several relevant and specific search terms, select the email domains that match your objective, and avoid overly narrow filters. The resulting Dataset keeps each discovered email connected to its keyword, search-result context, and URL for easier review and downstream analysis.

# Actor input Schema

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

A list of keywords or queries to search for.

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

Optional country, state or city used to narrow the search. Leave it empty to search without a geographic filter.

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

List of custom email domains

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

How many addresses each search keyword + domain suffix combination may collect before the finder moves on to the next one. This is a per-combination target, not a run-wide total: with 3 keyword and 2 Domains and a limit of 20, the run works through all 6 combinations and aims for up to 20 addresses in each, so up to 120 overall. Lower values finish sooner and cost less; higher values dig deeper but never guarantee a fuller result, since the run can only find what is publicly listed.

## `excludeWords` (type: `array`):

Words or phrases you do not want to see.

## Actor input object example

```json
{
  "keywords": [
    "Supplier",
    "Vendor"
  ],
  "location": "New york",
  "customDomains": [
    "@gmail.com"
  ],
  "maxEmails": 10,
  "excludeWords": []
}
```

# 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 = {
    "keywords": [
        "Supplier",
        "Vendor"
    ],
    "location": "New york",
    "customDomains": [
        "@gmail.com"
    ],
    "excludeWords": []
};

// Run the Actor and wait for it to finish
const run = await client.actor("email_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": [
        "Supplier",
        "Vendor",
    ],
    "location": "New york",
    "customDomains": ["@gmail.com"],
    "excludeWords": [],
}

# Run the Actor and wait for it to finish
run = client.actor("email_scraper/amazon-email-scraper").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 '{
  "keywords": [
    "Supplier",
    "Vendor"
  ],
  "location": "New york",
  "customDomains": [
    "@gmail.com"
  ],
  "excludeWords": []
}' |
apify call email_scraper/amazon-email-scraper --silent --output-dataset

```

## MCP server setup

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

```

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/temYPlN8u5dzmFFL1/builds/odko2hvq6iVjqvDld/openapi.json