# Amazon Seller Emails (`s-r/amazon-seller-emails`) Actor

- **URL**: https://apify.com/s-r/amazon-seller-emails.md
- **Developed by:** [SR](https://apify.com/s-r) (community)
- **Categories:** Lead generation, E-commerce, Business
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $20.00 / 1,000 seller with contact details

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

Find the businesses behind Amazon listings and get their contact details.
Search by keyword, or hand it seller IDs directly.

### Why the data is there, and where it is not

EU consumer law obliges a marketplace to publish the identity and contact
details of its professional sellers. Amazon complies by rendering a seller
information block on each seller's profile page. This actor reads that block.
The email is published under a legal obligation, not prised out of a wall.

That also sets the boundary of the product, so here it is measured rather than
asserted. All 22 Amazon marketplaces were swept on 2026-09-13:

| Marketplace | Sellers checked | With email |
|---|---|---|
| Germany | 10 | **90%** |
| Spain | 7 | **86%** |
| Belgium | 7 | **86%** |
| Sweden | 5 | **80%** |
| Ireland | 4 | **75%** |
| Poland | 3 | 67% |
| Italy | 2 | 50% |
| Netherlands | 4 | 50% |
| **EU total** | **42** | **79%** |
| United Kingdom | 10 | **0%** |
| 11 non-EU markets | 30 | **0%** |

Two things in that table are worth reading twice.

**The information block is not a promise of an email.** Nine of the ten UK
seller pages rendered the block and not one contained an address. Japan, the
UAE, Saudi Arabia and Egypt rendered it too, also with nothing in it. Outside
the EU, Amazon shows the panel and omits the contact details, because nothing
compels them. Inside the EU the two matched exactly: 33 blocks, 33 emails.

**The UK is not the EU any more, and the data says so.** Post-Brexit it sits
outside the obligation, and it behaves like a non-EU market rather than a
European one.

**France is currently unreachable.** Amazon answers it with an empty body under
HTTP 202 on every attempt, from pinned residential exits and a direct
connection alike. That is a standing gate, not the intermittent stub, so the
actor says so at the start of the run instead of retrying into a timeout.

Every non-EU marketplace is still selectable, because you may have a specific
seller ID to look up. The actor warns you what to expect rather than quietly
returning empty rows.

### What you get

One row per seller:

| Field | Example |
|---|---|
| `business_name` | Anker Technology (UK) Ltd |
| `email` | ankerdirect-eu@anker.com |
| `phone` | +4917663893206 |
| `business_address` | 39, Clarendon Road, WATFORD, Hertfordshire, WD17 1JA, GB |
| `vat_number` | DE295307777 |
| `trade_register_number` | 8766135 |
| `business_type` | Unternehmen in Privatbesitz |
| `merchant_id`, `seller_url`, `marketplace` | the seller on Amazon |
| `verification` | format, MX, role account, business domain, status |

### Every address is validated over DNS

Format is checked, then the domain's MX records are looked up. **No mail is
ever sent and nothing notifies the seller.**

A lookup that fails returns `has_mx: null` and `status: "unknown"`, never
`false`. A resolver timeout is not evidence that a domain cannot receive mail,
and an earlier actor in this family learned that the expensive way by reporting
gmail.com as invalid when its upstream went behind a challenge page.

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `keywords` | string\[] | none | Searched, listings opened, sellers looked up |
| `marketplace` | string | `de` | 22 markets, ordered by measured hit rate |
| `seller_ids` | string\[] | none | Skip discovery and go straight to these merchants |
| `products_per_keyword` | integer | 10 | Listings opened per keyword |
| `max_sellers` | integer | 50 | Cost ceiling per run |
| `only_sellers_with_email` | boolean | `true` | Pay only for sellers that carry contact details |
| `verify_emails` | boolean | `true` | DNS validation |

### What it will not pretend

Amazon intermittently serves a 2 KB stub with HTTP 200 in place of the real
page, on a proxy and on a direct connection alike. The next attempt returns the
full page, so it is a per-request lottery rather than a block. Every response is
size-checked and retried before it is parsed, because a parser that trusts the
status code reports "no sellers" for a page that never arrived.

When a seller's page never arrives after every retry, it is counted under
`sellers_fetch_failed` in the run `SUMMARY`. It is **not** reported as a seller
without an email. Those are different facts and the output keeps them apart.

### Lawful use

The contact details are published by Amazon because the law requires it, and
they identify businesses rather than private individuals. Use them for B2B
research, supplier discovery, compliance and due diligence, and follow the
marketing and data-protection rules that apply where you operate.

# Actor input Schema

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

Product keywords. Each one is searched, the listings are opened, and the sellers behind them are looked up. Leave empty if you are supplying seller IDs directly.

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

Measured 2026-09-13. EU marketplaces publish seller contact details by law and returned an email for 79% of sellers. The UK sits outside that obligation since Brexit: 9 of 10 UK seller pages rendered the information block and none carried an email. Eleven non-EU marketplaces returned 0%.

## `seller_ids` (type: `array`):

Amazon merchant IDs such as A2PGPJL0BBLHLX. Supply these to skip keyword discovery and go straight to the seller pages.

## `products_per_keyword` (type: `integer`):

How many listings to open per keyword when discovering sellers. More listings means more distinct sellers.

## `max_sellers` (type: `integer`):

Hard ceiling on seller pages looked up in one run. This is your cost ceiling.

## `only_sellers_with_email` (type: `boolean`):

On by default, so you pay only for sellers that actually carry contact details. Turn off to also receive sellers where Amazon published no email.

## `verify_emails` (type: `boolean`):

Check format and look up the domain's MX records over DNS. No mail is ever sent and nothing notifies the seller.

## Actor input object example

```json
{
  "keywords": [
    "yoga mat"
  ],
  "marketplace": "de",
  "products_per_keyword": 10,
  "max_sellers": 50,
  "only_sellers_with_email": true,
  "verify_emails": true
}
```

# Actor output Schema

## `sellers` (type: `string`):

One row per seller.

## `summary` (type: `string`):

Counts, hit rate and fetch stats.

# 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": [
        "yoga mat"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("s-r/amazon-seller-emails").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": ["yoga mat"] }

# Run the Actor and wait for it to finish
run = client.actor("s-r/amazon-seller-emails").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": [
    "yoga mat"
  ]
}' |
apify call s-r/amazon-seller-emails --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,s-r/amazon-seller-emails"
        }
    }
}
```

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/B8vSx7EUNId58FP3K/builds/F537WGL9XzMoPo4Bp/openapi.json