# Amazon Seller Leads Scraper (`pequod-labs/amazon-seller-intelligence`) Actor
Find third-party Amazon seller leads by product keyword. Standard ($6/1k) or Pro ($14/1k) discovery tiers. Business name, address, email, phone, FBA/FBM, own-shop domain. EU marketplaces.
- **URL**: https://apify.com/pequod-labs/amazon-seller-intelligence.md
- **Developed by:** [Pequod](https://apify.com/pequod-labs) (community)
- **Categories:** Lead generation, E-commerce
- **Stats:** 2 total users, 0 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet
## Pricing
from $6.00 / 1,000 seller (standard)s
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 a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.
In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js/docs.md):
```bash
npm install apify-client
```
In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.md):
```bash
pip install apify-client
```
In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):
````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash
In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/integrations/mcp.md).
If your project is in a different language, use 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 Intelligence
Turn a handful of product keywords into a list of third-party Amazon sellers with their legal business name, registered address, email, phone and fulfillment model (FBA/FBM).
### Why this exists
Amazon publishes a surprising amount of business data on every third-party seller: the registered company name, the full legal address, often an email address and a phone number. The problem is that this data lives on thousands of individual seller pages that nobody wants to open by hand.
If you sell software or services to e-commerce merchants, that data is a lead list. If you run brand protection, it tells you who is actually behind a storefront. If you do market research, it tells you where the sellers in a niche are based and whether they ship themselves or rely on Amazon's warehouses.
This actor does the tedious part. You give it keywords, it returns clean, deduplicated seller records.
### Who uses it
| Who | What they do with it |
| --- | --- |
| B2B sales teams (logistics, shipping, SaaS) | Build lists of merchant-fulfilled sellers with a direct email or phone |
| Brand owners and IP lawyers | Identify the legal entity behind a storefront selling their products |
| Market researchers | Map how many sellers compete in a niche, by country and fulfillment model |
| Aggregators and investors | Source FBA businesses in a category, with size signals from feedback counts |
| Agencies | Find sellers with their own web shop (from business emails, live domain checks and web search) |
### Quick start
1. Enter a few product keywords, the way a shopper would type them.
2. Pick the marketplace (amazon.com, .co.uk, .de, .fr, .it, .es or .nl).
3. Set the maximum number of sellers you want.
4. Run it. Results land in the dataset, one row per seller.
That's the whole setup. The defaults (deep discovery, fulfillment detection, China-based sellers excluded) are the ones most users want.
### Example output
```json
{
"sellerId": "A1B2C3D4E5F6G7",
"marketplace": "amazon.de",
"sellerName": "AlpineGear Shop",
"businessName": "AlpineGear GmbH",
"businessAddress": "Industriestrasse 12 | 82467 Garmisch-Partenkirchen | DE",
"countryCode": "DE",
"email": "service@alpinegear.de",
"phone": "+49 8821 123456",
"websiteDomain": "alpinegear.de",
"websiteSource": "email_domain",
"sellerUrl": "https://www.amazon.de/sp?seller=A1B2C3D4E5F6G7",
"storefrontUrl": "https://www.amazon.de/s?me=A1B2C3D4E5F6G7",
"about": "Family-run outdoor equipment retailer since 1998.",
"fulfillmentModel": "fbm_only",
"fbaRatio": 0.0,
"offersChecked": 4,
"feedbackCountLifetime": 12480,
"feedbackCount12Months": 1893,
"positivePercent12Months": 97.0,
"productAsins": ["B08XYZ1234", "B09ABC5678"],
"keywordsMatched": ["ski helmet"],
"productsSeen": 3,
"hasContact": true,
"error": false
}
````
### Output fields
| Field | Description |
| --- | --- |
| `sellerId` | Amazon merchant ID, unique per marketplace |
| `sellerName` | Public storefront display name |
| `businessName` | Registered legal company name |
| `businessAddress` | Registered business address |
| `countryCode` | Two-letter country code parsed from the address |
| `email`, `phone` | Contact details published on the seller profile, when present |
| `websiteDomain` | The seller's own web shop domain, when one could be found |
| `websiteSource` | How the web shop was found: `email_domain`, `brand_probe` or `web_search` |
| `sellerUrl` | Link to the seller's public profile page |
| `fulfillmentModel` | `fba_only`, `fbm_only`, `mixed`, `unknown` or `not_checked` |
| `fbaRatio` | Share of sampled offers fulfilled by Amazon (0–1) |
| `feedbackCountLifetime`, `feedbackCount12Months`, `positivePercent12Months` | Seller size and reputation signals |
| `productAsins` | Sample of products the seller was seen offering |
| `keywordsMatched` | Which of your keywords surfaced this seller |
| `hasContact` | True when at least one direct contact channel was found |
### Input options worth knowing
- `deepDiscovery` (default on) fetches every seller's full profile page after finding them. This is what gets you addresses, emails and phone numbers. Turn it off for a faster, cheaper run that returns seller identity and fulfillment model only — note that without profiles there is no registered address, so the country filter and China exclusion cannot apply.
- `checkFulfillment` (default on) classifies each seller as FBA, FBM or mixed from the offers seen during discovery, at no extra cost. Useful when you specifically target merchant-fulfilled sellers.
- `discoverWebsite` (default on) looks for each seller's own e-commerce site: business email domain first, then a direct check of brand-name domains, then a web search. Sellers with their own shop are often the most valuable rows in the list.
- `excludeChineseSellers` (default on) drops sellers whose registered address points to mainland China, Hong Kong, Taiwan or Macau.
- `sellerCountryFilter` keeps only sellers registered in one country, e.g. `DE`.
- `maxSellers` caps the number of paid results. The run also respects the spending limit you set on the platform, whichever is lower.
### Reliability
- Sellers are deduplicated by merchant ID across all your keywords.
- Failed lookups never land in your dataset by default, so you don't pay for errors. They are stored in the `FAILED_ITEMS` record of the run's key-value store, together with a `RUN_SUMMARY` record with coverage statistics.
- Transient fetch errors are retried automatically before being reported.
- If the whole run cannot fetch anything, it fails with a clear message and you are not charged for results.
### Limitations
- Email and phone coverage depends on what each seller publishes. Expect an email or phone on a meaningful share of sellers, not on all of them. `hasContact` tells you instantly which rows have one.
- Country parsing relies on the registered address format; a small share of sellers come back with `countryCode: null`. These rows pass any country filter, so review them manually if the filter matters to you.
- With strict filters (country filter plus China exclusion in a mixed niche) the run can return fewer sellers than `maxSellers`. Discovery over-fetches to compensate, but it cannot invent sellers that do not exist in the niche.
- Fulfillment classification is based on the offers observed during discovery. It is a strong signal, not a guarantee; sellers whose observed offers carry no shipping origin come back `unknown`.
- Website discovery is heuristic. `websiteSource` tells you how each domain was found: `email_domain` and `brand_probe` are strong signals, `web_search` is a good lead worth a quick check before outreach.
- Supported marketplaces are amazon.com, .co.uk, .de, .fr, .it, .es and .nl.
- All data comes from publicly visible Amazon pages. Nothing is scraped from behind a login.
# Actor input Schema
## `keywords` (type: `array`):
Product search terms used to discover third-party sellers, one per line. Think like a shopper: yoga mat, dog harness, espresso grinder. More specific keywords surface more niche sellers.
## `marketplace` (type: `string`):
Which Amazon site to search. Seller contact details come from the seller's public storefront page on this marketplace.
## `maxSellers` (type: `integer`):
Upper bound on the number of seller profiles returned. Each returned seller counts as one paid result. The run also respects the spending limit you set on the platform.
## `discoveryTier` (type: `string`):
Standard ($6/1k): faster listing-only discovery. Pro ($14/1k): full storefront profiles with business name, address, email and phone.
## `deepDiscovery` (type: `boolean`):
Deprecated — use discoveryTier instead. When discoveryTier is omitted, false maps to standard and true to pro.
## `checkFulfillment` (type: `boolean`):
Classifies each seller as FBA (Fulfilled by Amazon), FBM (merchant fulfilled) or mixed, based on the offers seen during discovery. No extra cost.
## `discoverWebsite` (type: `boolean`):
Tries to find each seller's own e-commerce website. Uses the business email domain when available, then checks brand-name domains directly, then falls back to a web search. Fills the websiteDomain and websiteSource fields.
## `proxyConfiguration` (type: `object`):
Optional proxy used only for the direct website checks performed by the own-web-shop discovery. Marketplace and search traffic is handled upstream and does not use this setting.
## `excludeChineseSellers` (type: `boolean`):
Filters out sellers whose registered business address points to mainland China, Hong Kong, Taiwan or Macau. Useful for lead lists targeting domestic merchants.
## `sellerCountryFilter` (type: `string`):
Optional two-letter country code (for example US, DE, IT). Only sellers whose registered business address matches this country are returned. Sellers with no parseable country are kept.
## `pushFailed` (type: `boolean`):
Failed lookups are always saved to the FAILED\_ITEMS record in the key-value store, free of charge. Enable this only if you also want them in the dataset, where they count as paid results.
## Actor input object example
```json
{
"keywords": [
"yoga mat",
"resistance bands"
],
"marketplace": "amazon.com",
"maxSellers": 50,
"discoveryTier": "pro",
"deepDiscovery": true,
"checkFulfillment": true,
"discoverWebsite": true,
"proxyConfiguration": {
"useApifyProxy": true
},
"excludeChineseSellers": true,
"pushFailed": false
}
```
# Actor output Schema
## `sellers` (type: `string`):
No description
## `failedItems` (type: `string`):
No description
## `runSummary` (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 '' with your token
const client = new ApifyClient({
token: '',
});
// Prepare Actor input
const input = {
"keywords": [
"yoga mat",
"resistance bands"
],
"proxyConfiguration": {
"useApifyProxy": true
}
};
// Run the Actor and wait for it to finish
const run = await client.actor("pequod-labs/amazon-seller-intelligence").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 '' with your token.
client = ApifyClient("")
# Prepare the Actor input
run_input = {
"keywords": [
"yoga mat",
"resistance bands",
],
"proxyConfiguration": { "useApifyProxy": True },
}
# Run the Actor and wait for it to finish
run = client.actor("pequod-labs/amazon-seller-intelligence").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": [
"yoga mat",
"resistance bands"
],
"proxyConfiguration": {
"useApifyProxy": true
}
}' |
apify call pequod-labs/amazon-seller-intelligence --silent --output-dataset
```
## MCP server setup
```json
{
"mcpServers": {
"apify": {
"command": "npx",
"args": [
"mcp-remote",
"https://mcp.apify.com/?tools=pequod-labs/amazon-seller-intelligence",
"--header",
"Authorization: Bearer "
]
}
}
}
```
## OpenAPI specification
```json
{
"openapi": "3.0.1",
"info": {
"title": "Amazon Seller Leads Scraper",
"description": "Find third-party Amazon seller leads by product keyword. Standard ($6/1k) or Pro ($14/1k) discovery tiers. Business name, address, email, phone, FBA/FBM, own-shop domain. EU marketplaces.",
"version": "1.0",
"x-build-id": "81oQr1ncYZyrRjQNE"
},
"servers": [
{
"url": "https://api.apify.com/v2"
}
],
"paths": {
"/acts/pequod-labs~amazon-seller-intelligence/run-sync-get-dataset-items": {
"post": {
"operationId": "run-sync-get-dataset-items-pequod-labs-amazon-seller-intelligence",
"x-openai-isConsequential": false,
"summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
"tags": [
"Run Actor"
],
"requestBody": {
"required": true,
"content": {
"application/json": {
"schema": {
"$ref": "#/components/schemas/inputSchema"
}
}
}
},
"parameters": [
{
"name": "token",
"in": "query",
"required": true,
"schema": {
"type": "string"
},
"description": "Enter your Apify token here"
}
],
"responses": {
"200": {
"description": "OK"
}
}
}
},
"/acts/pequod-labs~amazon-seller-intelligence/runs": {
"post": {
"operationId": "runs-sync-pequod-labs-amazon-seller-intelligence",
"x-openai-isConsequential": false,
"summary": "Executes an Actor and returns information about the initiated run in response.",
"tags": [
"Run Actor"
],
"requestBody": {
"required": true,
"content": {
"application/json": {
"schema": {
"$ref": "#/components/schemas/inputSchema"
}
}
}
},
"parameters": [
{
"name": "token",
"in": "query",
"required": true,
"schema": {
"type": "string"
},
"description": "Enter your Apify token here"
}
],
"responses": {
"200": {
"description": "OK",
"content": {
"application/json": {
"schema": {
"$ref": "#/components/schemas/runsResponseSchema"
}
}
}
}
}
}
},
"/acts/pequod-labs~amazon-seller-intelligence/run-sync": {
"post": {
"operationId": "run-sync-pequod-labs-amazon-seller-intelligence",
"x-openai-isConsequential": false,
"summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
"tags": [
"Run Actor"
],
"requestBody": {
"required": true,
"content": {
"application/json": {
"schema": {
"$ref": "#/components/schemas/inputSchema"
}
}
}
},
"parameters": [
{
"name": "token",
"in": "query",
"required": true,
"schema": {
"type": "string"
},
"description": "Enter your Apify token here"
}
],
"responses": {
"200": {
"description": "OK"
}
}
}
}
},
"components": {
"schemas": {
"inputSchema": {
"type": "object",
"required": [
"keywords"
],
"properties": {
"keywords": {
"title": "Search keywords",
"uniqueItems": true,
"type": "array",
"description": "Product search terms used to discover third-party sellers, one per line. Think like a shopper: yoga mat, dog harness, espresso grinder. More specific keywords surface more niche sellers.",
"items": {
"type": "string"
}
},
"marketplace": {
"title": "Amazon marketplace",
"enum": [
"amazon.com",
"amazon.co.uk",
"amazon.de",
"amazon.fr",
"amazon.it",
"amazon.es",
"amazon.nl"
],
"type": "string",
"description": "Which Amazon site to search. Seller contact details come from the seller's public storefront page on this marketplace.",
"default": "amazon.com"
},
"maxSellers": {
"title": "Maximum sellers",
"minimum": 1,
"maximum": 2000,
"type": "integer",
"description": "Upper bound on the number of seller profiles returned. Each returned seller counts as one paid result. The run also respects the spending limit you set on the platform.",
"default": 50
},
"discoveryTier": {
"title": "Discovery tier",
"enum": [
"standard",
"pro"
],
"type": "string",
"description": "Standard ($6/1k): faster listing-only discovery. Pro ($14/1k): full storefront profiles with business name, address, email and phone.",
"default": "pro"
},
"deepDiscovery": {
"title": "Deep discovery (legacy)",
"type": "boolean",
"description": "Deprecated — use discoveryTier instead. When discoveryTier is omitted, false maps to standard and true to pro.",
"default": true
},
"checkFulfillment": {
"title": "Detect fulfillment model (FBA/FBM)",
"type": "boolean",
"description": "Classifies each seller as FBA (Fulfilled by Amazon), FBM (merchant fulfilled) or mixed, based on the offers seen during discovery. No extra cost.",
"default": true
},
"discoverWebsite": {
"title": "Find the seller's own web shop",
"type": "boolean",
"description": "Tries to find each seller's own e-commerce website. Uses the business email domain when available, then checks brand-name domains directly, then falls back to a web search. Fills the websiteDomain and websiteSource fields.",
"default": true
},
"proxyConfiguration": {
"title": "Proxy configuration",
"type": "object",
"description": "Optional proxy used only for the direct website checks performed by the own-web-shop discovery. Marketplace and search traffic is handled upstream and does not use this setting."
},
"excludeChineseSellers": {
"title": "Exclude China-based sellers",
"type": "boolean",
"description": "Filters out sellers whose registered business address points to mainland China, Hong Kong, Taiwan or Macau. Useful for lead lists targeting domestic merchants.",
"default": true
},
"sellerCountryFilter": {
"title": "Seller country filter",
"type": "string",
"description": "Optional two-letter country code (for example US, DE, IT). Only sellers whose registered business address matches this country are returned. Sellers with no parseable country are kept."
},
"pushFailed": {
"title": "Push failed items to dataset",
"type": "boolean",
"description": "Failed lookups are always saved to the FAILED_ITEMS record in the key-value store, free of charge. Enable this only if you also want them in the dataset, where they count as paid results.",
"default": false
}
}
},
"runsResponseSchema": {
"type": "object",
"properties": {
"data": {
"type": "object",
"properties": {
"id": {
"type": "string"
},
"actId": {
"type": "string"
},
"userId": {
"type": "string"
},
"startedAt": {
"type": "string",
"format": "date-time",
"example": "2025-01-08T00:00:00.000Z"
},
"finishedAt": {
"type": "string",
"format": "date-time",
"example": "2025-01-08T00:00:00.000Z"
},
"status": {
"type": "string",
"example": "READY"
},
"meta": {
"type": "object",
"properties": {
"origin": {
"type": "string",
"example": "API"
},
"userAgent": {
"type": "string"
}
}
},
"stats": {
"type": "object",
"properties": {
"inputBodyLen": {
"type": "integer",
"example": 2000
},
"rebootCount": {
"type": "integer",
"example": 0
},
"restartCount": {
"type": "integer",
"example": 0
},
"resurrectCount": {
"type": "integer",
"example": 0
},
"computeUnits": {
"type": "integer",
"example": 0
}
}
},
"options": {
"type": "object",
"properties": {
"build": {
"type": "string",
"example": "latest"
},
"timeoutSecs": {
"type": "integer",
"example": 300
},
"memoryMbytes": {
"type": "integer",
"example": 1024
},
"diskMbytes": {
"type": "integer",
"example": 2048
}
}
},
"buildId": {
"type": "string"
},
"defaultKeyValueStoreId": {
"type": "string"
},
"defaultDatasetId": {
"type": "string"
},
"defaultRequestQueueId": {
"type": "string"
},
"buildNumber": {
"type": "string",
"example": "1.0.0"
},
"containerUrl": {
"type": "string"
},
"usage": {
"type": "object",
"properties": {
"ACTOR_COMPUTE_UNITS": {
"type": "integer",
"example": 0
},
"DATASET_READS": {
"type": "integer",
"example": 0
},
"DATASET_WRITES": {
"type": "integer",
"example": 0
},
"KEY_VALUE_STORE_READS": {
"type": "integer",
"example": 0
},
"KEY_VALUE_STORE_WRITES": {
"type": "integer",
"example": 1
},
"KEY_VALUE_STORE_LISTS": {
"type": "integer",
"example": 0
},
"REQUEST_QUEUE_READS": {
"type": "integer",
"example": 0
},
"REQUEST_QUEUE_WRITES": {
"type": "integer",
"example": 0
},
"DATA_TRANSFER_INTERNAL_GBYTES": {
"type": "integer",
"example": 0
},
"DATA_TRANSFER_EXTERNAL_GBYTES": {
"type": "integer",
"example": 0
},
"PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
"type": "integer",
"example": 0
},
"PROXY_SERPS": {
"type": "integer",
"example": 0
}
}
},
"usageTotalUsd": {
"type": "number",
"example": 0.00005
},
"usageUsd": {
"type": "object",
"properties": {
"ACTOR_COMPUTE_UNITS": {
"type": "integer",
"example": 0
},
"DATASET_READS": {
"type": "integer",
"example": 0
},
"DATASET_WRITES": {
"type": "integer",
"example": 0
},
"KEY_VALUE_STORE_READS": {
"type": "integer",
"example": 0
},
"KEY_VALUE_STORE_WRITES": {
"type": "number",
"example": 0.00005
},
"KEY_VALUE_STORE_LISTS": {
"type": "integer",
"example": 0
},
"REQUEST_QUEUE_READS": {
"type": "integer",
"example": 0
},
"REQUEST_QUEUE_WRITES": {
"type": "integer",
"example": 0
},
"DATA_TRANSFER_INTERNAL_GBYTES": {
"type": "integer",
"example": 0
},
"DATA_TRANSFER_EXTERNAL_GBYTES": {
"type": "integer",
"example": 0
},
"PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
"type": "integer",
"example": 0
},
"PROXY_SERPS": {
"type": "integer",
"example": 0
}
}
}
}
}
}
}
}
}
}
```