# Amazon Seller Data Extractor — Ratings, Contacts and Products (`simpleapi/amazon-seller-data-extractor-scraper`) Actor

Amazon Seller Data Extractor Scraper extracts comprehensive seller information from Amazon: seller names, storefront URLs, ratings, product catalogs, fulfillment methods, feedback scores, locations, and contact links. Use for competitive analysis, supplier discovery, monitoring, and automation

- **URL**: https://apify.com/simpleapi/amazon-seller-data-extractor-scraper.md
- **Developed by:** [SimpleAPI](https://apify.com/simpleapi) (community)
- **Categories:** Automation, Lead generation, E-commerce
- **Stats:** 27 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$19.99/month + usage

To use this Actor, you pay a monthly rental fee to the developer. The rent is subtracted from your prepaid usage every month after the free trial period. You also pay for the Apify platform usage, which gets cheaper the higher Apify subscription plan you have.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#rental-actors

## 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 Data Extractor — Ratings, Contacts and Products

Amazon Seller Data Extractor Plus pulls structured seller records — storefront name, seller ID, ratings, feedback history, business address, contact phone/email, fulfillment type, and (optionally) the seller's own product catalog — from Amazon seller pages, product pages, category URLs, and keyword search, and pushes them to your dataset as typed JSON. It resolves the seller behind any `asinInputs`, `usernameInputs`, `startUrls`, `keywordInputs`, or `categoryUrls` you paste in, then optionally paginates each seller's storefront (`includeProducts`) and feedback history (`maxFeedbackPages`) for deeper coverage. Sourcing teams, marketplace analysts, and dropshipping/wholesale buyers use it to build supplier shortlists, vet fulfillment method before reaching out, and track seller-level rating trends over time. The sections below cover every input, every output field, and how to narrow a run down to exactly the sellers you want.

### What is Amazon Seller Data Extractor Plus?

Amazon Seller Data Extractor Plus is an Apify Actor that scrapes public Amazon seller-profile pages (`/sp?seller=…`) and the product pages that link to them, and returns one structured JSON record per seller — plus, if you switch it on, one additional record per product in that seller's storefront. It runs entirely over HTTP (no browser), authenticating each request with a rotating Apify residential-proxy session rather than an Amazon account, and needs no Amazon login or API key of any kind. Results stream to the dataset in real time as each section finishes, so a run with dozens of inputs starts producing rows immediately rather than waiting for the whole batch.

Key capabilities, all present in the current source:

- **Five ways to point at a seller** — a direct `asinInputs` product code, a `usernameInputs` seller ID, a `startUrls` seller-profile link, or discovery via `keywordInputs` search terms or `categoryUrls` category/search-result pages.
- **Optional child entity: product listings.** With `includeProducts` on, the Actor paginates the seller's own storefront (`/s?me=<sellerId>`) and emits each product as its own row (`type: "product"`, `isChild: true`) linked back to the seller via `parentSellerId`.
- **Feedback beyond page 1.** `maxFeedbackPages` walks the seller's feedback pagination, and `sortOrder` controls whether the merged feedback list comes back newest-first, in Amazon's on-page order, or highest-rated first.
- **Structured contact and address fields.** `businessName`, a parsed `businessAddress` (line1/city/state/postalCode/country), `contactPhone`, and `contactEmail` are extracted where the seller has published them.
- **Quality and fulfillment filters applied before billing.** `minRatingPositive`, `minLifetimeRatings`, and `fulfillmentType` drop sellers that don't clear your bar — those rows are never pushed and never charged.
- **Locale and marketplace control.** `amazonDomain` targets any Amazon storefront (amazon.com, amazon.co.uk, amazon.de, amazon.co.jp, …) and `language` sets the Accept-Language header Amazon replies to.

### What data can I extract with Amazon Seller Data Extractor Plus?

Every run returns two related record types — `seller` (the parent record) and, when `includeProducts` is enabled, `product` (a child of that seller) — both pushed to the same dataset and both billed under the same charged event.

| Field | Example value | Use case |
| --- | --- | --- |
| `type` | `"seller"` or `"product"` | Split seller vs. product rows in downstream processing |
| `isChild` | `false` / `true` | Filter parent seller rows from child product rows |
| `section_index` | `3` | Trace a row back to its position in the input list |
| `section` | `"B00P8XQPY4"` or `"keyword:wireless earbuds"` | Trace a row back to the input value that produced it |
| `sellerId` | `"A33W53J5GVPZ8K"` | Primary key for joining seller and product rows |
| `sellerName` | `"Peckomatic"` | Human-readable storefront name |
| `url` | `"https://www.amazon.com/sp?seller=A33W53J5GVPZ8K"` | The exact page scraped |
| `canonicalSellerUrl` | `"https://www.amazon.com/sp?seller=A33W53J5GVPZ8K"` | Stable link back to the seller profile |
| `description` | `"Peckomatic is committed to providing…"` | Storefront "About" copy |
| `businessName` | `"Francis Kunnumpurath"` | Legal/registered business name behind the storefront |
| `businessAddress` | `{ "line1": "2612 State Route 80", "city": "Lafayette", "state": "NY", "postalCode": "13084", "country": "US" }` | Structured mailing address for outreach or compliance checks |
| `contactPhone` | `"+1 555-0134"` | Direct phone line, when the seller has published one |
| `contactEmail` | `"support@example.com"` | Direct email, when the seller has published one |
| `stars` / `ratingStarsNumeric` | `"4.5 out of 5 stars"` / `4.5` | Raw and numeric overall star rating |
| `rating_positive` / `ratingPositivePercent` | `"88% positive"` / `88` | Raw and numeric positive-feedback percentage |
| `rating_count_lifetime` | `42` | Total lifetime ratings — feeds `minLifetimeRatings` filtering |
| `ratingCountM1` / `ratingCountM3` / `ratingCountM12` | `2` / `7` / `30` | Rating volume over the last 30 / 90 / 365 days, for trend detection |
| `feedbacks` | `[{ "stars": "5 out of 5 stars", "starsNumeric": 5.0, "text": "Bird arrived in great condition.", "date": "By Kao Y. on November 16, 2021." }]` | Individual buyer feedback rows, ordered per `sortOrder` |
| `feedbackCount` | `1` | Number of feedback rows attached to this seller record |
| `feedbacks_percentages` | `{ "star_5": "79%", "star_4": "10%", "star_1": "5%" }` | Star-rating distribution as published on the profile |
| `fulfillment` | `"FBA"` or `"FBM"` | Detected fulfillment method — feeds `fulfillmentType` filtering |
| `productCount` | `30` | Number of product rows collected for this seller (when `includeProducts` is on) |
| `products_link` | `"https://www.amazon.com/s?ie=UTF8&me=A33W53J5GVPZ8K"` | Direct link to the seller's storefront search page |
| `shipping_policies` | `"Unless noted otherwise…ships all items within two days…"` | Seller-published shipping terms |
| `privacy_policy` / `privacy_security` | `"Peckomatic values the privacy of your personal data."` | Seller-published privacy copy |
| `country` | `"US"` | Marketplace country, derived from `amazonDomain` |
| `scrapedAt` | `"2026-07-01T10:11:16Z"` | ISO-8601 timestamp of extraction |
| `parentSellerId` / `parentSellerName` (product rows) | `"A33W53J5GVPZ8K"` / `"Peckomatic"` | Joins a product row back to its parent seller |
| `asin` (product rows) | `"B00P8XQPY4"` | Amazon product identifier |
| `price` / `priceRaw` / `currency` (product rows) | `29.99` / `"$29.99"` / `"USD"` | Parsed numeric price plus the original on-page string |
| `rating` / `reviewCount` (product rows) | `4.3` / `1024` | Product-level rating and review volume |

`seller_id` and `seller_name` also ship as legacy lower-snake-case aliases of `sellerId`/`sellerName` for backward compatibility with earlier versions of this Actor.

#### Ratings and feedback data

The rating block is the decision-driving data on every seller record: `ratingStarsNumeric` and `ratingPositivePercent` give you two directly comparable scores, `rating_count_lifetime` plus the `ratingCountM1`/`ratingCountM3`/`ratingCountM12` trio let you see whether a seller's feedback volume is accelerating or has gone quiet, and `feedbacks` carries the actual buyer text, per-review star rating, and posting date — pulled from as many pages as `maxFeedbackPages` allows and capped per seller by `maxComments`. A wholesale buyer screening 200 candidate sellers might sort on `ratingPositivePercent` and `rating_count_lifetime` first, then spot-check `feedbacks` text on the top 20 before reaching out.

#### Targeting and fulfillment data

`fulfillment` (FBA vs. FBM, detected from the product offer when a run starts from `asinInputs`), `country` (derived from `amazonDomain`), and `productCount` (populated only when `includeProducts` is on) are the fields you segment on. Combined with the three quality filters — `minRatingPositive`, `minLifetimeRatings`, `fulfillmentType` — they let a run return only, say, FBA sellers on amazon.co.uk with at least 100 lifetime ratings and 90%+ positive feedback, without any post-processing.

### Why not build this yourself?

Amazon does not publish a general-purpose API for looking up arbitrary third-party sellers — the Selling Partner API is scoped to a seller's own account and requires Amazon's developer approval, so it cannot answer "who sells this ASIN" or "what's this competitor's rating history" for a business you don't control. Building that lookup by hand means solving three problems this Actor's source code already handles: seller-ID extraction has to fall back across several DOM selectors and a regex scan because Amazon doesn't expose one stable "seller ID" element on every page layout; blocked or CAPTCHA'd responses have to be detected (the Actor checks page length and a list of known block phrases such as "robot check" and "enter the characters you see below") and retried with a fresh residential-proxy session and rotated browser headers up to several times before giving up; and a cold request without a prior homepage visit is itself a bot signal, so the Actor warms up each session against the Amazon homepage before requesting the target page. None of that is exposed as a documented, rate-limited public endpoint anywhere — it's scraping-specific plumbing, which is exactly what this Actor packages up.

### How to use data extracted from Amazon?

#### Sourcing and procurement teams

Paste candidate `usernameInputs` or `startUrls` for sellers you're evaluating, set `minRatingPositive` and `minLifetimeRatings` to your minimum bar, and turn on `includeProducts` with a `maxProductsPerSeller` cap to pull each seller's current catalog alongside their rating history. The output lands as one row per qualifying seller plus one row per product, ready to filter on `fulfillment`, `businessAddress`, and `contactEmail`/`contactPhone` before a first outreach email goes out.

#### Agencies and marketplace consultants

Running the same seller list on a schedule — weekly or monthly — turns `ratingCountM1`/`ratingCountM3`/`ratingCountM12` into a trend line per client seller: a sudden drop in `ratingCountM1` relative to the `ratingCountM12` average flags a seller worth a closer look before a quarterly review call. `keywordInputs` runs against a client's core search terms also surface newly-appearing competitor sellers in that category between reports.

#### Market research and intelligence

`categoryUrls` or `keywordInputs` runs resolve the sellers behind a whole category or search result page, and `fulfillmentType` splits the resulting set into FBA vs. FBM to gauge how a niche is fulfilled. Pairing `ratingPositivePercent` distribution across that seller set with `country` (from `amazonDomain`) supports cross-marketplace comparisons — e.g., is FBA share higher on amazon.de than amazon.com for a given keyword.

#### AI agents and automated pipelines

Because output is typed JSON keyed by stable fields (`sellerId`, `ratingPositivePercent`, `fulfillment`, `businessAddress`), an agent can use this Actor as a tool call — "look up the seller behind ASIN B0XXXX and tell me if they're FBA with 90%+ positive feedback" — and reason directly over the returned record without a parsing step, or feed a batch of `sellerId`/`ratingPositivePercent` pairs into a lead-scoring pipeline.

### 🔼 Input sample

All 18 input parameters are optional — the schema sets `required: []` — but a run needs at least one non-empty source array (`asinInputs`, `usernameInputs`, `keywordInputs`, `categoryUrls`, or `startUrls`) or it logs an error and exits without pushing anything.

| Parameter | Required | Type | Description | Example value |
| --- | --- | --- | --- | --- |
| `asinInputs` | No | array | One Amazon ASIN per row; the Actor opens the product page and resolves the seller behind the offer. | `["B00P8XQPY4"]` |
| `usernameInputs` | No | array | Amazon seller IDs (e.g. `A33W53J5GVPZ8K`) when you already know exactly who to look up. | `["A33W53J5GVPZ8K"]` |
| `keywordInputs` | No | array | Search phrases; the Actor runs each search, scans up to the first 8 products, and resolves the seller behind each one. | `["wireless earbuds"]` |
| `categoryUrls` | No | array | Full Amazon search or category result URLs, expanded into products and then sellers. | `["https://www.amazon.com/s?k=coffee+grinder"]` |
| `startUrls` | No | array | Direct Amazon seller-profile URLs (`/sp?seller=…`). | `["https://www.amazon.com/sp?seller=A33W53J5GVPZ8K"]` |
| `includeProducts` | No | boolean | Default `false`. Scrape each seller's storefront and emit each product as its own child row. | `true` |
| `maxProductsPerSeller` | No | integer | Default `20`, range 0–500. Caps product rows collected per seller when `includeProducts` is on; `0` collects everything the storefront paginates. | `30` |
| `maxFeedbackPages` | No | integer | Default `1`, range 1–50. How many seller-feedback pages to paginate; `1` reads only the first page. | `3` |
| `minRatingPositive` | No | integer | Default `0`, range 0–100. Drops sellers whose positive-feedback percentage is below this; `0` disables the filter. | `90` |
| `minLifetimeRatings` | No | integer | Default `0`, range 0–1,000,000. Drops sellers with fewer lifetime ratings than this; `0` disables the filter. | `100` |
| `fulfillmentType` | No | string (`any`/`FBA`/`FBM`) | Default `"any"`. Keeps only sellers with the given fulfillment method — only known for sellers resolved from `asinInputs`. | `"FBA"` |
| `amazonDomain` | No | string | Default `"amazon.com"`. The Amazon storefront domain to scrape. | `"amazon.co.uk"` |
| `language` | No | string | Default `""` (Amazon's default). Optional locale sent as the Accept-Language header. | `"en-GB"` |
| `sortOrder` | No | string (`recent`/`helpful`/`rating`) | Default `"recent"`. How the merged feedback list is ordered in each seller row. | `"rating"` |
| `maxComments` | No | integer | Default `10`, range 0–1000. Caps feedback rows kept per seller; `0` keeps everything collected. | `25` |
| `proxyCountry` | No | string | Default `"AUTO"` (derives the country from `amazonDomain`). ISO-style country hint for proxy routing. | `"GB"` |
| `maxConcurrency` | No | integer | Default `10`, range 1–20. Maximum sections processed in parallel; lower values are gentler on fragile storefronts. | `5` |
| `proxyConfiguration` | No | object | Apify Proxy configuration. This Actor always runs on `RESIDENTIAL` proxies regardless of what's set here. | `{ "useApifyProxy": false }` |

```json
{
  "asinInputs": ["B00P8XQPY4"],
  "usernameInputs": [],
  "keywordInputs": ["wireless earbuds"],
  "includeProducts": true,
  "maxProductsPerSeller": 30,
  "maxFeedbackPages": 2,
  "minRatingPositive": 85,
  "minLifetimeRatings": 50,
  "fulfillmentType": "any",
  "amazonDomain": "amazon.com",
  "sortOrder": "recent",
  "maxComments": 15,
  "proxyCountry": "AUTO",
  "maxConcurrency": 10
}
```

**Common pitfall:** `asinInputs` applies a heuristic — any value that starts with `"A"` and is longer than 10 characters is treated as a seller ID, not a product ASIN, and routed straight to a seller-profile fetch instead of a product-page fetch. Real Amazon ASINs are exactly 10 alphanumeric characters, so this only misfires if you paste a seller ID into `asinInputs` by mistake; put seller IDs in `usernameInputs` instead to avoid ambiguity.

### 🔽 Output sample

Each row is typed, normalized JSON with a consistent schema per record type — there is no CSV- or Excel-specific formatting step in the source, but Apify's dataset export supports downloading any run's results as CSV, Excel, JSON, XML, or RSS regardless of how the Actor wrote them.

Seller row (`type: "seller"`):

```json
{
  "section_index": 1,
  "section": "B00P8XQPY4",
  "type": "seller",
  "isChild": false,
  "url": "https://www.amazon.com/sp?seller=A33W53J5GVPZ8K",
  "canonicalSellerUrl": "https://www.amazon.com/sp?seller=A33W53J5GVPZ8K",
  "sellerId": "A33W53J5GVPZ8K",
  "sellerName": "Peckomatic",
  "description": "Peckomatic is committed to providing each customer with the highest standard of customer service.",
  "businessName": "Francis Kunnumpurath",
  "businessAddress": {
    "raw": "2612 State Route 80, Lafayette, NY, 13084, US",
    "line1": "2612 State Route 80",
    "city": "Lafayette",
    "state": "NY",
    "postalCode": "13084",
    "country": "US"
  },
  "contactPhone": null,
  "contactEmail": null,
  "feedbacks": [
    { "stars": "5 out of 5 stars", "starsNumeric": 5.0, "text": "Bird arrived in great condition.", "date": "By Kao Y. on November 16, 2021." }
  ],
  "feedbackCount": 1,
  "stars": "4.5 out of 5 stars",
  "ratingStarsNumeric": 4.5,
  "rating_positive": "88% positive",
  "ratingPositivePercent": 88,
  "rating_count_lifetime": 42,
  "ratingCountM1": 2,
  "ratingCountM3": 7,
  "ratingCountM12": 30,
  "feedbacks_percentages": { "star_5": "79%", "star_4": "10%", "star_3": "7%", "star_2": "0%", "star_1": "5%" },
  "productCount": 30,
  "fulfillment": "FBM",
  "products_link": "https://www.amazon.com/s?ie=UTF8&me=A33W53J5GVPZ8K",
  "shipping_policies": "Unless noted otherwise in the ordering pipeline, Peckomatic ships all items within two days of receiving an order.",
  "country": "US",
  "scrapedAt": "2026-07-01T10:11:16Z"
}
```

Product row (`type: "product"`, child of the seller):

```json
{
  "section_index": 1,
  "section": "B00P8XQPY4",
  "type": "product",
  "isChild": true,
  "parentSellerId": "A33W53J5GVPZ8K",
  "parentSellerName": "Peckomatic",
  "asin": "B00P8XQPY4",
  "title": "Peckomatic Bird Feeder",
  "price": 29.99,
  "priceRaw": "$29.99",
  "currency": "USD",
  "rating": 4.3,
  "reviewCount": 1024,
  "url": "https://www.amazon.com/dp/B00P8XQPY4",
  "scrapedAt": "2026-07-01T10:11:18Z"
}
```

### How do you filter and target specific sellers?

This Actor exposes two independent ways to find sellers, and three thresholds to keep only the ones worth paying for.

**Direct lookup vs. discovery.** When you already know the seller — an ASIN, a seller ID, or a seller profile URL — feed `asinInputs`, `usernameInputs`, or `startUrls`, which cost one fetch (plus one product-page fetch for ASINs) per seller. When you don't, `keywordInputs` or `categoryUrls` run a search or category page first, scan its first products, and resolve each one's seller — more requests per result, but the only way to prospect a category you haven't already scoped down to known sellers.

**Quality thresholds.** `minRatingPositive` and `minLifetimeRatings` filter on the seller's feedback record; `fulfillmentType` filters on FBA vs. FBM. All three are applied to the fully-scraped seller record before it's pushed — a seller that fails any active filter is dropped silently (logged, not pushed, not charged), so a narrow filter set reduces both dataset size and cost, not just dataset size.

**Volume controls.** `maxProductsPerSeller` and `maxFeedbackPages` control how deep each individual seller gets scraped, not how many sellers you can target — the source arrays (`asinInputs`, `usernameInputs`, `keywordInputs`, `categoryUrls`, `startUrls`) are plain lists with no schema-enforced maximum length, so run size scales with how many rows you paste in.

Three real examples:

Cast a wide FBA-only net across one Amazon domain, no volume limits on feedback or products:

```json
{ "keywordInputs": ["ceramic mugs"], "fulfillmentType": "FBA", "minRatingPositive": 0 }
```

Vet a known shortlist of sellers with a strict quality bar before outreach:

```json
{ "usernameInputs": ["A33W53J5GVPZ8K", "A2N5Q13T20FFT2"], "minRatingPositive": 90, "minLifetimeRatings": 200 }
```

Pull one seller's full current catalog plus three pages of feedback history for a deep-dive audit:

```json
{ "startUrls": ["https://www.amazon.com/sp?seller=A33W53J5GVPZ8K"], "includeProducts": true, "maxProductsPerSeller": 0, "maxFeedbackPages": 3 }
```

### ▶️ Want to try other Amazon scrapers?

| Scraper name | What it extracts |
| --- | --- |
| Amazon Best Sellers Scraper (`amazon-bestsellers-scraper`) | Amazon Best Sellers, New Releases, and Most Wished For rankings, with BSR rank, ASIN, price, and rating |

| Comparable contact/directory scrapers | What it extracts |
| --- | --- |
| LinkedIn Profile Contact Lookup (`linkedin-profile-contact-lookup`) | Contact details resolved from LinkedIn profile URLs, public IDs, or name + company |
| Instagram Profile Contact Enricher (`instagram-profile-contact-enricher`) | Contact details enriched from Instagram profile usernames, URLs, or IDs |
| Facebook Groups Search Scraper Plus (`facebook-groups-search-scraper-plus`) | Facebook groups resolved from keyword or group-link search |

### How to extract Amazon data programmatically

This Actor runs as a standard Apify Actor: one authenticated call to the Apify API starts the run, and results come back as structured JSON from the run's dataset — no separate REST endpoint to design or maintain.

#### Python example

```python
from apify_client import ApifyClient

client = ApifyClient("<APIFY_API_TOKEN>")

run = client.actor("SimpleAPI/amazon-seller-data-extractor-plus").call(run_input={
    "usernameInputs": ["A33W53J5GVPZ8K"],
    "minRatingPositive": 85,
    "fulfillmentType": "FBA",
})

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["sellerName"], item["ratingPositivePercent"], item["fulfillment"])
```

#### MCP for AI agents

Apify exposes every Actor, including this one, through its Actors MCP Server at `mcp.apify.com`, so MCP-compatible clients — Claude, Cursor, and other agent frameworks that speak the Model Context Protocol — can call it as a tool without custom integration code:

```bash
npx -y @apify/actors-mcp-server --actors SimpleAPI/amazon-seller-data-extractor-plus
```

A sourcing agent can then call this Actor mid-conversation — "find FBA sellers for ceramic mugs with at least 90% positive feedback" — and get back structured `sellerId`/`ratingPositivePercent`/`fulfillment` rows to reason over directly.

#### Export to spreadsheets or CRM

Every Apify dataset can be downloaded as CSV or Excel directly from the run's Storage tab or via the API's dataset export endpoint. Map `sellerName` → company/contact name, `contactEmail`/`contactPhone` → your CRM's contact fields, and `businessAddress.line1`/`city`/`state`/`postalCode`/`country` → address columns for a direct import into a spreadsheet or CRM outreach list.

### Is it legal to scrape Amazon?

Scraping publicly accessible Amazon seller pages is generally legal — these pages are published by Amazon for any visitor to view without logging in, which is what this Actor's HTTP-only requests do. Storefront descriptions, ratings, and feedback counts are business data with no personal-data component. Business address, `contactPhone`, and `contactEmail`, however, can identify an individual when the seller is a sole trader rather than a registered company, which brings GDPR (for EU/UK data subjects) or CCPA (for California residents) into play for how you store and use that data. Always review Amazon's Conditions of Use for your account and consult legal counsel for commercial applications involving bulk storage of personal data.

### ❓ FAQ

#### How does the Actor know if a seller listing is still active?

The Actor scrapes each seller page live at request time; it does not track or flag delisted or suspended sellers between runs. A seller profile that returns a blocked/empty response (Amazon's "robot check" or CAPTCHA pages, or a response under roughly 2,000 characters) is treated the same as a genuinely missing seller and simply produces no row — re-run the same input later to distinguish a temporary block from a real removal.

#### Can I get the seller's product catalog along with the seller record?

Yes — set `includeProducts` to `true` and the Actor scrapes the seller's storefront (`/s?me=<sellerId>`), paginating up to `maxProductsPerSeller` product rows (or every page the storefront exposes if `maxProductsPerSeller` is `0`). Each product is pushed as its own `type: "product"` row linked to the seller via `parentSellerId`, and product rows are also mirrored to a separate per-run dataset named `products-<runId>`.

#### How accurate is the contact and rating data?

The Actor returns the seller's rating, feedback, and contact fields exactly as published on their Amazon profile at request time — accuracy depends on how current the seller keeps that profile. Ratings and lifetime counts reflect Amazon's own displayed figures; contact fields (`contactPhone`, `contactEmail`) are only populated when the seller has published them publicly. Verify any contact detail before using it for outreach at scale.

#### How many records can I get per run?

There is no schema-enforced cap on how many sellers a single run can process — `asinInputs`, `usernameInputs`, `keywordInputs`, `categoryUrls`, and `startUrls` are all open-ended arrays. What is capped per seller is depth: `maxProductsPerSeller` (0–500, default 20) for product rows, `maxComments` (0–1000, default 10) for feedback rows, and `maxFeedbackPages` (1–50, default 1) for how many feedback pages get paginated. `maxConcurrency` (1–20, default 10) controls how many sellers are processed in parallel, not the run's total ceiling.

#### How does the fulfillment filter work?

`fulfillmentType` (`any`/`FBA`/`FBM`) keeps only sellers whose detected fulfillment method matches. Fulfillment is detected from the buy-box/merchant-info block on the product page, which means it is only known for sellers resolved via `asinInputs` — sellers resolved from `usernameInputs`, `startUrls`, `keywordInputs`, or `categoryUrls` won't have a reliable `fulfillment` value unless that same seller was also reached through an ASIN in the same run.

#### Does Amazon Seller Data Extractor Plus work with Claude, ChatGPT, and AI agent frameworks?

Yes — it's reachable through Apify's Actors MCP Server (`mcp.apify.com`) for MCP-native clients like Claude, and callable as a standard Apify API run by any agent framework that can make an authenticated HTTP request, including custom ChatGPT tool integrations.

#### How does this compare to other Amazon seller scrapers?

As observed on the Apify Store on 2026-07-26, both `pratikdani/amazon-seller-extractor` and `api-empire/amazon-seller-data-extractor` return single seller records (name, rating, feedback, contact fields) without a linked product-catalog child entity; this Actor adds that as an optional `includeProducts` toggle, plus feedback pagination (`maxFeedbackPages`) and pre-billing quality filters (`minRatingPositive`, `minLifetimeRatings`, `fulfillmentType`) that neither competitor's listing describes. Field-level completeness on any individual seller still depends on what that seller has chosen to publish on their Amazon profile, regardless of which scraper is used.

#### Can I use this Actor without an Amazon seller account or API key?

Yes. The Actor needs only your Apify account to run — it authenticates to Amazon's public pages over rotating residential proxy sessions, not an Amazon login, and requires no Amazon Selling Partner API credentials or developer approval.

### Conclusion

Amazon Seller Data Extractor Plus turns a list of ASINs, seller IDs, seller URLs, keywords, or category pages into structured seller intelligence — ratings, feedback trends, business contact details, fulfillment type, and an optional linked product catalog — without an Amazon account, an API key, or hand-built anti-bot handling. It's built for sourcing teams vetting suppliers, agencies tracking client sellers over time, and researchers mapping a category's seller base, and every field it returns traces directly to what Amazon publishes on the seller's own profile. Start a run from the Apify Console with a handful of `usernameInputs` or `asinInputs` to see the seller and product schema on real data before scaling up.

# Actor input Schema

## `asinInputs` (type: `array`):

One ASIN per row (example: B00P8XQPY4). We open each product page and pull the seller behind the offer 🏷️✨

## `usernameInputs` (type: `array`):

Amazon seller IDs like A33W53J5GVPZ8K — perfect when you already know exactly who you're researching 🎯

## `keywordInputs` (type: `array`):

Search phrases (e.g. "wireless earbuds", "handmade ceramics"). We run each search, take the top results, and resolve the seller behind each product — great for prospecting new storefronts 🧠💡 (Example: 1 keyword → up to ~8 products scanned → their unique sellers.)

## `categoryUrls` (type: `array`):

Paste full Amazon search or category URLs (e.g. https://www.amazon.com/s?k=coffee+grinder). We expand each into products and resolve their sellers 🧭

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

Full Amazon seller profile links (e.g. https://www.amazon.com/sp?seller=…). Paste as many as you need — we follow each one 🔗🚀

## `includeProducts` (type: `boolean`):

Scrape each seller's storefront catalog and emit each product as its own row (type=product, isChild=true) linked to the parent seller. Example: includeProducts=true + maxProductsPerSeller=30 → up to 30 product rows per seller. Default is OFF.

## `maxProductsPerSeller` (type: `integer`):

Cap product rows collected per seller (0 = grab everything the storefront paginates — slower). Only used when 'Include product listings' is ON. Default is 20.

## `maxFeedbackPages` (type: `integer`):

How many seller-feedback pages to paginate (1 = first page only). Example: 3 → collect feedback from pages 1–3 (still capped by 'Max reviews per seller'). Default is 1.

## `minRatingPositive` (type: `integer`):

Drop sellers whose positive-feedback percentage is below this (0 = no filter). Example: 90 → only sellers with ≥90% positive. Default is 0.

## `minLifetimeRatings` (type: `integer`):

Drop sellers with fewer lifetime ratings than this (0 = no filter). Example: 100 → only established sellers. Default is 0.

## `fulfillmentType` (type: `string`):

Keep only sellers with a given fulfillment method (detected from the product offer when scraping via ASIN). 'Any' = no filter. Note: fulfillment is only known for ASIN-sourced sellers.

## `amazonDomain` (type: `string`):

Examples: amazon.com, amazon.co.uk, amazon.de, amazon.co.jp — pick the storefront your customers actually see 🗺️

## `language` (type: `string`):

Optional locale string (en-US, en-GB, de-DE…). When set, it is sent as the Accept-Language header so Amazon serves that locale. Leave blank to let Amazon decide 🎛️

## `sortOrder` (type: `string`):

How collected feedback is ordered in each seller row: 🆕 Recent (newest date first), 👍 Helpful (Amazon's on-page order), ⭐ By rating (highest stars first). Default is Recent.

## `maxComments` (type: `integer`):

Cap feedback rows per seller (0 = grab everything the pages allow — slower but exhaustive 📚). Default is 10.

## `proxyCountry` (type: `string`):

ISO-style country for routing (or AUTO ✨, which derives from the Amazon domain) — helps requests feel local and natural 🧭

## `maxConcurrency` (type: `integer`):

Higher = faster 🏎️ but hotter on Amazon's radar. Lower (1–5) = gentler, great for fragile storefronts 🐢💚. Default is 10.

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

🏠 Heads-up: this actor always runs on residential proxies for reliability. UI choices here stay for compatibility but may be overridden automatically — expand when you need granular proxy JSON 🛠️💡

## Actor input object example

```json
{
  "asinInputs": [
    "B00P8XQPY4"
  ],
  "usernameInputs": [],
  "keywordInputs": [],
  "categoryUrls": [],
  "startUrls": [],
  "includeProducts": false,
  "maxProductsPerSeller": 20,
  "maxFeedbackPages": 1,
  "minRatingPositive": 0,
  "minLifetimeRatings": 0,
  "fulfillmentType": "any",
  "amazonDomain": "amazon.com",
  "language": "",
  "sortOrder": "recent",
  "maxComments": 10,
  "proxyCountry": "AUTO",
  "maxConcurrency": 10,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `results` (type: `string`):

All scraped items in the Actor's default dataset.

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

Same dataset, filtered to seller rows with seller-specific fields (ratings, contact info, business address).

## `products` (type: `string`):

Same dataset, filtered to child product-listing rows linked to their parent seller.

# 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 = {
    "asinInputs": [
        "B00P8XQPY4"
    ],
    "usernameInputs": [],
    "keywordInputs": [],
    "categoryUrls": [],
    "startUrls": [],
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("simpleapi/amazon-seller-data-extractor-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 = {
    "asinInputs": ["B00P8XQPY4"],
    "usernameInputs": [],
    "keywordInputs": [],
    "categoryUrls": [],
    "startUrls": [],
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("simpleapi/amazon-seller-data-extractor-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 '{
  "asinInputs": [
    "B00P8XQPY4"
  ],
  "usernameInputs": [],
  "keywordInputs": [],
  "categoryUrls": [],
  "startUrls": [],
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call simpleapi/amazon-seller-data-extractor-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,simpleapi/amazon-seller-data-extractor-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/R9DMMzeLcJMI6dFsa/builds/pGhvl4KkqpXZi2SQ3/openapi.json