# Amazon Seller Email Scraper — Public Contact Finder (`khadinakbar/amazon-seller-email-scraper`) Actor

Find publicly disclosed Amazon seller contact emails from seller profiles and official business websites. Returns email provenance, legal name, address, marketplace, and source URLs.

- **URL**: https://apify.com/khadinakbar/amazon-seller-email-scraper.md
- **Developed by:** [Khadin Akbar](https://apify.com/khadinakbar) (community)
- **Categories:** Lead generation, E-commerce, MCP servers
- **Stats:** 1 total users, 0 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $200.00 / 1,000 public seller email founds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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 Seller Email Scraper

Find public contact emails for Amazon third-party sellers and retain the page where each address was disclosed. Provide Amazon seller IDs, seller or storefront URLs, or product URLs. The actor opens the Amazon seller profile, extracts public seller and legal-business details, and returns contact emails that appear on the profile. When a seller page does not disclose an email, optional enrichment can inspect the seller’s official website only when Amazon links it or the caller explicitly supplies an official-site mapping for that seller ID.

This is a contact-data discovery tool for supplier research, reseller investigations, brand protection, and B2B lead enrichment. It is deliberately narrow: it does not generate likely addresses from a person or company name, query a people-search database, collect customer data, or claim that an email mailbox is deliverable. Every returned email is syntactically validated and includes provenance.

### Returned data

The default dataset contains one stable JSON record per Amazon seller profile inspected. A profile that has no public email still receives an honest record with `email: null`, `emailFound: false`, and a warning explaining the limit. That lets a workflow distinguish “not checked” from “checked but no public contact email” without paying the public-email event.

| Field | Description |
| --- | --- |
| `sellerId` | Amazon seller or merchant ID. |
| `sellerName` | Seller’s public Amazon display name. |
| `businessName` | Legal business name Amazon exposes in seller information. |
| `businessAddress` | Public Amazon business address when present. |
| `marketplace` | Marketplace code such as `US`, `DE`, or `UK`. |
| `sellerUrl` | Amazon seller-profile URL used as the primary source. |
| `email` and `emails` | First and all public contact emails found for the seller. |
| `emailSource` | `amazon_seller_page` or `official_website`. |
| `emailSourceUrl` | Exact public page that contained the primary email. |
| `officialWebsiteUrl` | Official site linked by Amazon or supplied in the mapping. |
| `warnings` | Non-fatal limitations, such as an unavailable website or no disclosed email. |

Example:

```json
{
  "sellerId": "A1ODG4ICFE5MU3",
  "sellerName": "Example Seller",
  "businessName": "Example Seller Ltd",
  "marketplace": "DE",
  "sellerUrl": "https://www.amazon.de/sp?seller=A1ODG4ICFE5MU3",
  "email": "sales@seller.example",
  "emails": ["sales@seller.example"],
  "emailSource": "amazon_seller_page",
  "emailSourceUrl": "https://www.amazon.de/sp?seller=A1ODG4ICFE5MU3",
  "officialWebsiteUrl": null,
  "emailFound": true,
  "warnings": []
}
```

### When to use it

Use this actor when you have an Amazon seller ID or a specific Amazon URL and need a traceable public business contact. Typical workflows include identifying a contact point for a reseller, enriching a list of sellers already found by another Amazon actor, researching potential suppliers, or collecting a small and auditable B2B lead list.

Do not use it to broadly search Amazon by a generic keyword, scrape customer information, collect personal contact data, validate email deliverability, or produce email guesses. For seller legal identity, feedback, ratings, and storefront-product details without an email-first workflow, use the related Amazon Seller Scraper.

### Inputs

#### Seller IDs

`sellerIds` accepts 13–14 uppercase Amazon merchant IDs. Use `marketplace` to choose the Amazon domain for IDs that do not arrive with a URL. Seller IDs are not ASINs; ASINs have 10 characters and can instead be passed through product URLs.

```json
{
  "sellerIds": ["A1ODG4ICFE5MU3"],
  "marketplace": "DE",
  "maxResults": 1
}
```

#### Amazon URLs

`startUrls` accepts seller-profile URLs, storefront URLs with `me=`, and product URLs containing `/dp/ASIN`. For a product URL the actor resolves its third-party seller before opening the seller profile. The Amazon domain in an input URL always wins over the generic marketplace setting.

```json
{
  "startUrls": [{ "url": "https://www.amazon.com/sp?seller=A1ODG4ICFE5MU3" }],
  "discoverWebsiteEmails": true,
  "maxResults": 1
}
```

#### Official seller website mappings

Amazon does not always expose a seller’s website. If an existing CRM or research workflow already knows an official company domain, use `companyWebsites` to map it directly to the merchant ID. The actor checks the supplied homepage and up to `maxContactPages` same-site contact, support, imprint, legal, or about pages. It does not search the web for a business-name match and does not follow arbitrary unrelated external URLs.

```json
{
  "sellerIds": ["A1ODG4ICFE5MU3"],
  "companyWebsites": [
    { "sellerId": "A1ODG4ICFE5MU3", "url": "https://seller.example" }
  ],
  "discoverWebsiteEmails": true,
  "maxContactPages": 3
}
```

### Pricing

The actor uses **Pay per event + platform usage**. `apify-actor-start` costs **$0.00005** once per run. The primary value event, `public-email-found`, costs **$0.20** only when a seller record contains at least one syntactically valid email that was publicly disclosed on the Amazon seller page or an eligible official website page. Records with no email do not trigger the primary event. Apify compute and proxy usage are billed separately as platform usage.

`maxResults` is a hard ceiling on seller profiles. For example, `maxResults: 10` caps public-email event charges at $2.00, plus the actor-start event and platform usage. The actor logs the cost ceiling before making requests.

### Limits and reliability

Amazon pages can block high-volume access or change their markup. The actor uses a persistent session pool, controlled concurrency, retries, and session retirement after block responses. Residential proxies are recommended for larger jobs. If Amazon blocks every required route before any usable seller record exists, the actor reports an honest `UPSTREAM_FAILED` result instead of silently completing with an empty dataset.

No email found is not inherently an error: many sellers simply do not disclose one. A valid run with inspected profiles but zero disclosed emails finishes as `VALID_EMPTY`. A run that preserves some data but encounters blocked profiles or write failures is `PARTIAL`. Invalid user input gets an actionable `INVALID_INPUT` message. Every terminal path writes both `OUTPUT`, a compact machine-readable result, and `RUN_SUMMARY`, a detailed diagnostics and billing record.

### API and AI-agent use

Use the same JSON input through the Apify API, Console, or MCP integration. This actor is appropriate for the job “find public contact emails for these Amazon sellers.” It returns flat, stable field names and every email includes a source page. Do not select it for price tracking, reviews, broad category discovery, or personal-contact lookup.

### Responsible use

Use public business contact data in accordance with applicable law, Amazon policies, and your organization’s outreach requirements. An address being public does not establish consent, deliverability, or suitability for unsolicited marketing. Store `emailSourceUrl` with each CRM entry so a human can review the disclosure and its context before making contact.

# Actor input Schema

## `sellerIds` (type: `array`):

Use this when you know Amazon merchant IDs. Enter 13–14 uppercase characters such as A1ODG4ICFE5MU3. The selected marketplace determines the seller profile URL. This is not a 10-character ASIN or a website domain.

## `startUrls` (type: `array`):

Use this when you already have Amazon URLs. Accepted examples include https://www.amazon.com/sp?seller=A1ODG4ICFE5MU3, storefront URLs with me=, and product /dp/ASIN URLs. Product pages resolve their third-party seller before inspection. This is not for company websites; use companyWebsites for those.

## `marketplace` (type: `string`):

Use this for seller IDs that do not include an Amazon URL. Select the marketplace, for example DE for amazon.de; a supplied Amazon URL always overrides it. Defaults to US. This setting is not a proxy-country selector.

## `discoverWebsiteEmails` (type: `boolean`):

Use this to follow a seller website that Amazon itself links, or a matching URL supplied in companyWebsites, when the seller page has no email. The Actor scans the homepage and a few same-site contact pages. Defaults to true. It never searches the open web or guesses addresses from company names.

## `companyWebsites` (type: `array`):

Use this to supply an official company website for a specific seller ID when Amazon does not link one. Each item needs a sellerId and a full HTTPS URL, for example {"sellerId":"A1ODG4ICFE5MU3","url":"https://example.com"}. It is optional and only used when website discovery is enabled. This is not a list of email addresses or a general web-search query.

## `maxResults` (type: `integer`):

Use this to cap the number of Amazon seller profiles inspected in one run. Enter a whole number from 1 to 100; each returned public email is charged at $0.20 and the actor stops adding new seller work at this cap. Defaults to 10. This is a seller-profile cap, not an email-list size target.

## `maxContactPages` (type: `integer`):

Use this to limit extra official-site crawling for a seller without an Amazon-page email. The homepage is included, followed by same-site contact, support, imprint, or legal pages. Defaults to 3 and accepts 1–5. This does not crawl social networks, marketplaces, or arbitrary external links.

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

Use this to configure Apify Proxy for Amazon access. Automatic Apify Proxy is the default; residential proxies are recommended for larger or blocked runs. The Actor keeps a session consistent across requests. This field is not a way to supply website credentials.

## Actor input object example

```json
{
  "sellerIds": [
    "A1ODG4ICFE5MU3"
  ],
  "startUrls": [
    {
      "url": "https://www.amazon.com/sp?seller=A1ODG4ICFE5MU3"
    }
  ],
  "marketplace": "US",
  "discoverWebsiteEmails": true,
  "companyWebsites": [],
  "maxResults": 1,
  "maxContactPages": 3,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

One record per inspected seller with public-email provenance.

## `output` (type: `string`):

Machine-readable final status and counters.

## `runSummary` (type: `string`):

Detailed diagnostics and charge counters.

# 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 = {
    "sellerIds": [
        "A1ODG4ICFE5MU3"
    ],
    "startUrls": [
        {
            "url": "https://www.amazon.com/sp?seller=A1ODG4ICFE5MU3"
        }
    ],
    "marketplace": "US",
    "discoverWebsiteEmails": true,
    "maxResults": 1,
    "maxContactPages": 3,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("khadinakbar/amazon-seller-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 = {
    "sellerIds": ["A1ODG4ICFE5MU3"],
    "startUrls": [{ "url": "https://www.amazon.com/sp?seller=A1ODG4ICFE5MU3" }],
    "marketplace": "US",
    "discoverWebsiteEmails": True,
    "maxResults": 1,
    "maxContactPages": 3,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("khadinakbar/amazon-seller-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 '{
  "sellerIds": [
    "A1ODG4ICFE5MU3"
  ],
  "startUrls": [
    {
      "url": "https://www.amazon.com/sp?seller=A1ODG4ICFE5MU3"
    }
  ],
  "marketplace": "US",
  "discoverWebsiteEmails": true,
  "maxResults": 1,
  "maxContactPages": 3,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call khadinakbar/amazon-seller-email-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/acts/F9WSyqdmOnC76yM4h/builds/vesMECtu8sHcyf25q/openapi.json