# Amazon Seller Data Extractor: AI Sentiment & Feedback Analytics (`scraper-engine/amazon-seller-scraper`) Actor

The Amazon Seller Data Extractor Scraper efficiently collects key seller information from Amazon, including store name, ratings, feedback, and product listings. Ideal for market research, competitor analysis, and eCommerce intelligence, it delivers accurate, structured data ready for API or export.

- **URL**: https://apify.com/scraper-engine/amazon-seller-scraper.md
- **Developed by:** [Scraper Engine](https://apify.com/scraper-engine) (community)
- **Categories:** E-commerce, Agents, Lead generation
- **Stats:** 30 total users, 0 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$14.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 Scraper — Ratings, Feedback and Reputation Data

Amazon seller scraper that extracts a storefront's name, star rating, 30/90/12-month rating-window counts, and individual buyer feedback comments as structured JSON — no HTML parsing required. It also computes a derived reputation score from that data and can optionally run AI sentiment/theme analysis on feedback text using your own LLM key. Feed it ASINs, seller IDs, storefront URLs, or search keywords and start pulling seller data in minutes.

### What is Amazon Seller Data Extractor: AI Sentiment & Feedback Analytics?

It's an Amazon seller scraper that opens a product or seller storefront page and extracts the seller's profile, ratings, feedback comments, and policy text, then derives non-AI reputation metrics (numeric rating, positive-feedback score, feedback velocity, recency, a blended reputation score) from the same data. An optional module sends each feedback comment's text to an AI provider (Claude, GPT, Gemini, Grok, DeepSeek, Perplexity, or Mistral — your own API key) for sentiment and theme classification. No Amazon account or login is required — it scrapes publicly visible storefront pages over HTTP with residential proxies. Built for sourcing/procurement analysts, marketplace researchers, and developers building reputation-scoring or lead-gen pipelines.

### What Amazon seller feedback data is publicly available to scrape?

Amazon publishes a seller's storefront page — name, rating, feedback comments, and policies — to any visitor, no account needed. What's gated sits behind the seller's own Seller Central login.

| Data Category | Publicly Available | Restricted behind Seller Central login |
| --- | --- | --- |
| Seller name, ID, storefront URL | Yes | — |
| Star rating & % positive feedback | Yes | — |
| Buyer feedback comments & dates | Yes | — |
| 30d/90d/12mo/lifetime rating counts | Yes | — |
| Shipping, return, privacy policy text | Yes | — |
| Business name/address/phone | If seller discloses | — |
| Order history, inventory, sales data | No | Seller's own account only |
| Direct buyer-seller messaging | No | Amazon's messaging system |

This Actor only returns publicly visible data — what any visitor sees. Nothing behind a login wall.

### What data can I extract with Amazon Seller Data Extractor: AI Sentiment & Feedback Analytics?

Every run returns seller identity fields, ratings and reputation metrics, and full feedback records — with AI sentiment/theme fields added when enabled.

| Field Name | Description |
| --- | --- |
| `seller_name` | Seller's storefront display name |
| `seller_id` | Amazon seller ID (e.g. `A33W53J5GVPZ8K`) |
| `url` | Seller storefront URL that was scraped |
| `products_link` | Link to the seller's full product listing on Amazon |
| `country` | Marketplace country, derived from `marketplaceDomain` |
| `seller_phone_number` | Phone number, only when the seller discloses one on the page |
| `description` | "About seller" free text |
| `detailed_info[]` | Every business-info label row Amazon renders (`title`/`value` pairs — business name, address, etc., when disclosed) |
| `return_policy[]` | Return/refund policy text, split into sentences |
| `shipping_policies` | Shipping policy text |
| `privacy_security` | Privacy & security disclosure text |
| `privacy_policy` | Privacy policy text |
| `help_content` | Return/refund/contact help text |
| `stars` | Amazon's own rating text (e.g. `"4.5 out of 5 stars"`) |
| `starRatingNumeric` | `stars` parsed to a float (e.g. `4.5`) |
| `rating_positive` | Amazon's own positive-feedback text (e.g. `"88% positive"`) |
| `positiveFeedbackScore` | `rating_positive` parsed to a number (e.g. `88.0`) |
| `feedbacks_percentages` | Star-by-star percentage breakdown (`star_5`…`star_1`) |
| `rating_count_m1` | Real 30-day rating count, parsed from the page's embedded ratings-window data |
| `rating_count_m3` | Real 90-day rating count |
| `rating_count_m12` | Real 12-month rating count |
| `rating_count_lifetime` | Lifetime rating count |
| `feedbackVelocity` | `rating_count_m1 ÷ rating_count_lifetime` — recent activity as a share of all-time volume |
| `feedbackRecencyDays` | Days since the most recent feedback entry |
| `reputationScore` | 0–100 blended score: 50% positive-feedback rate, 30% log-scaled lifetime rating volume, 20% recency |
| `feedbacks[]` | Buyer feedback comments, each with `stars`, `text`, `date` (plus `sentiment`, `sentimentScore`, `themes` when AI is enabled) |
| `sentimentSummary` | Per-seller tally of positive/neutral/negative/failed AI classifications (`null` unless AI ran) |
| `aiSentimentEnabled` | Whether AI sentiment/theme analysis actually ran for this row |
| `section_index`, `section` | Which input (ASIN, seller ID, URL, or keyword) produced this row |
| `timestamp` | UTC time the row was scraped |

#### Seller identity & storefront details

`seller_name`, `seller_id`, `url`, `products_link`, `country`, `seller_phone_number`, `description`, `detailed_info[]`

#### Ratings, feedback volume & reputation metrics

`stars`, `starRatingNumeric`, `rating_positive`, `positiveFeedbackScore`, `feedbacks_percentages`, `rating_count_m1`, `rating_count_m3`, `rating_count_m12`, `rating_count_lifetime`, `feedbackVelocity`, `feedbackRecencyDays`, `reputationScore`

#### Buyer feedback & AI sentiment/theme analysis

`feedbacks[]`, `sentimentSummary`, `aiSentimentEnabled`

#### 🤖 Add-on: Need additional Amazon data?

Pair this seller scraper with [Amazon Best Sellers Scraper](https://apify.com/scraper-engine/amazon-bestsellers-scraper) to pull top-100 category rankings, price, and review counts, or [Amazon Search Products Scraper: Top Rated & Best Reviewed](https://apify.com/scraper-engine/amazon-search-products-scraper-top-rated-best-reviewed) to find and rank products by star rating before resolving their sellers here.

### How does Amazon Seller Data Extractor: AI Sentiment & Feedback Analytics differ from the official Amazon API?

Amazon's Selling Partner API (SP-API) is scoped to the seller account that authorizes it — a third-party developer cannot use it to pull another seller's storefront, feedback, or rating data without that seller's own authorization, per Amazon's SP-API developer documentation.

| Feature | Amazon SP-API | Amazon Seller Data Extractor |
| --- | --- | --- |
| Scope of accessible sellers | Only the authorizing seller's own account | Any public seller storefront, by ASIN/ID/URL/keyword |
| Approval process | Seller must authorize the app (public or private app workflow) | None — runs directly on Apify |
| Feedback/rating-window data | Own-account order/feedback reports only | Public 30d/90d/12mo/lifetime rating counts for any seller |
| Sentiment/theme analysis | Not provided | Optional, via your own AI provider key |
| Setup | Developer registration + per-seller authorization | Provide ASINs, IDs, or URLs and run |

Use SP-API when you manage your own seller account and need order/inventory operations. Use this Actor when you need public reputation data on sellers you don't control — competitors, prospects, or suppliers.

### How to use Amazon Seller Data Extractor: AI Sentiment & Feedback Analytics

This Actor runs on the Apify platform — no separate signup or API integration is required to try it.

1. Open the Actor's page in Apify Console and click **Start**.
2. Provide at least one input — none are required by the schema, but you'll typically fill `productAsins`, `sellerIds`, `sellerProfileUrls`, or `keywordInputs`.
3. Optionally set `marketplaceDomain` (e.g. `amazon.co.uk`) and `maxFeedbackPerSeller`.
4. Start the run.
5. Download results as JSON, CSV, or another format from the Apify dataset export options once the run finishes.

#### How to scale to bulk Amazon seller extraction

`productAsins`, `sellerIds`, `sellerProfileUrls`, and `keywordInputs` are all arrays — list as many rows as you want in a single run, and each is processed concurrently up to `maxParallelSellers`. `keywordInputs` additionally runs a real search → product → seller discovery pipeline per keyword, de-duplicating discovered sellers by seller ID, so one keyword can surface many sellers without listing them individually.

### What can you do with Amazon seller feedback data?

- A procurement analyst vetting suppliers uses `reputationScore` and `rating_count_lifetime` to shortlist storefronts before requesting quotes.
- A marketplace researcher tracking competitor sellers uses `rating_count_m1`/`rating_count_m3`/`rating_count_m12` against `rating_count_lifetime` to see whether a seller's recent activity is accelerating or stalling.
- A lead-gen team building an outreach list uses `seller_name`, `detailed_info[]`, and `seller_phone_number` (when disclosed) to compile contactable storefronts.
- A brand-reputation team monitors `positiveFeedbackScore` and `feedbackRecencyDays` over repeated runs to catch a seller's rating trending down.
- An AI engineer feeds `feedbacks[].text` through the built-in AI sentiment/theme module (or into their own RAG pipeline) to surface recurring complaint themes — shipping, packaging, service — across hundreds of comments without reading each one.

### How does Amazon Seller Data Extractor: AI Sentiment & Feedback Analytics handle rate limits and blocking?

Every request runs through a residential proxy session (Apify's `RESIDENTIAL` proxy group), with a session warm-up request to the marketplace homepage before each page fetch and randomized delays between requests. Each page fetch retries up to 4 times on a blocked or empty response (robot-check pages, CAPTCHA interstitials, empty bodies), with increasing backoff between attempts; turning on `useCaptchaSolver` doubles that to 8 attempts with longer backoff — it does not call any third-party CAPTCHA-solving service, it just retries harder. Proxy sessions rotate automatically on a blocked attempt. If all attempts for a given seller are exhausted, that seller is skipped (logged, not pushed to the dataset) and the run continues with the remaining inputs; if nothing is extracted at all, the run logs a suggestion to retry later or set `proxyCountryCode` to match the marketplace domain.

### ⬇️ Input

None of the following parameters are required — the Actor accepts any combination of `productAsins`, `sellerIds`, `sellerProfileUrls`, or `keywordInputs`.

| Parameter | Required | Type | Description | Example Value |
| --- | --- | --- | --- | --- |
| `productAsins` | No | array | One ASIN per row; the seller behind each product's offer is resolved and scraped | `["B00P8XQPY4"]` |
| `sellerIds` | No | array | Amazon seller IDs to scrape directly | `["A33W53J5GVPZ8K"]` |
| `sellerProfileUrls` | No | array | Full Amazon seller storefront URLs | `["https://www.amazon.com/sp?seller=A33W53J5GVPZ8K"]` |
| `keywordInputs` | No | array | Search phrases; runs search → product → seller discovery, de-duplicated by seller ID | `["handmade ceramics UK"]` |
| `marketplaceDomain` | No | string | Amazon marketplace domain to scrape | `"amazon.com"` |
| `language` | No | string | Locale for the `Accept-Language` header; blank lets Amazon decide | `"en-US"` |
| `aiSentimentEnabled` | No | boolean | Turn on AI sentiment/theme analysis of feedback text (default `false`) | `false` |
| `aiModel` | No | string | AI model/provider to use when AI sentiment is enabled | `"claude-haiku-4-5"` |
| `aiApiKey` | No | string | Your own API key for the selected provider; falls back to a matching env var | `"sk-ant-..."` |
| `maxFeedbacksForAi` | No | integer | Max feedback comments analyzed by AI per seller (1–200, default 20) | `20` |
| `maxFeedbackPerSeller` | No | integer | Max feedback rows collected per seller (0–1000, 0 = all available) | `10` |
| `maxParallelSellers` | No | integer | Max sellers fetched concurrently (1–20) | `10` |
| `proxyCountryCode` | No | string | Proxy country for routing, or `"AUTO"` | `"AUTO"` |
| `useCaptchaSolver` | No | boolean | Escalate the anti-bot retry ladder from 4 to 8 attempts (default `false`) | `false` |
| `sortOrder` | No | string | Order of `feedbacks[]` before truncation: `"recent"`, `"helpful"`, or `"rating"` (default `"recent"`) | `"recent"` |
| `proxyConfiguration` | No | object | Proxy configuration; this Actor always runs on residential proxies regardless of this setting | `{"useApifyProxy": false}` |

#### Example input

```json
{
  "productAsins": ["B00P8XQPY4"],
  "sellerIds": ["A33W53J5GVPZ8K"],
  "sellerProfileUrls": [],
  "keywordInputs": ["handmade ceramics UK"],
  "marketplaceDomain": "amazon.com",
  "language": "",
  "aiSentimentEnabled": true,
  "aiModel": "claude-haiku-4-5",
  "aiApiKey": "sk-ant-your-own-key",
  "maxFeedbacksForAi": 20,
  "maxFeedbackPerSeller": 10,
  "maxParallelSellers": 10,
  "proxyCountryCode": "AUTO",
  "useCaptchaSolver": false,
  "sortOrder": "recent",
  "proxyConfiguration": { "useApifyProxy": false }
}
```

### ⬆️ Output

Results are pushed to the Apify dataset as one typed JSON row per seller, with a consistent field set across every run. Download as JSON, CSV, Excel, or another format from the dataset's export options.

#### Example output

```json
{
  "section_index": 1,
  "section": "B00P8XQPY4",
  "url": "https://www.amazon.com/sp?seller=A33W53J5GVPZ8K",
  "seller_id": "A33W53J5GVPZ8K",
  "seller_name": "Coastal Home Goods",
  "products_link": "https://www.amazon.com/s?ie=UTF8&me=A33W53J5GVPZ8K",
  "description": "Family-run storefront specializing in handmade ceramics and home decor.",
  "detailed_info": [
    { "title": "Business Name", "value": "Coastal Home Goods LLC" },
    { "title": "Business Address", "value": "500 Harbor Rd, Portland, ME, 04101, US" }
  ],
  "seller_phone_number": null,
  "stars": "4.5 out of 5 stars",
  "starRatingNumeric": 4.5,
  "rating_positive": "88% positive lifetime",
  "positiveFeedbackScore": 88.0,
  "feedbacks_percentages": { "star_5": "72%", "star_4": "16%", "star_3": "6%", "star_2": "3%", "star_1": "3%" },
  "rating_count_m1": 41,
  "rating_count_m3": 118,
  "rating_count_m12": 512,
  "rating_count_lifetime": 3204,
  "feedbackVelocity": 0.0128,
  "feedbackRecencyDays": 2,
  "reputationScore": 81.4,
  "feedbacks": [
    {
      "stars": "5.0 out of 5 stars",
      "text": "Fast shipping and the mug was packaged very carefully.",
      "date": "on July 21, 2026",
      "sentiment": "positive",
      "sentimentScore": 0.9,
      "themes": ["shipping speed", "packaging"]
    }
  ],
  "sentimentSummary": { "positive": 9, "neutral": 1, "negative": 0, "failed": 0, "analyzed": 10 },
  "aiSentimentEnabled": true,
  "return_policy": ["Items can be returned within 30 days of receipt."],
  "shipping_policies": "Ships within 2 business days via standard carrier.",
  "privacy_security": "",
  "privacy_policy": "",
  "help_content": "",
  "country": "US",
  "timestamp": "2026-07-25T14:02:11Z"
}
```

### How does it work?

Requests go out over Apify's residential proxy network in a sticky session per seller, with a homepage warm-up fetch before the target page to look like normal browser traffic — no headless browser is used, pages are fetched over plain HTTP and parsed with BeautifulSoup. Responses are checked against known Amazon block signals (robot-check pages, CAPTCHA interstitials, short/empty bodies); a blocked response triggers a proxy-session rotation and a retry with backoff. Only what Amazon renders on the public storefront and product pages is extracted — nothing requires a login. The output field set (`seller_name`, `rating_count_m1`, `reputationScore`, and the rest) stays the same from run to run even if Amazon changes its page layout, because the underlying label/section lookups are re-verified against live pages as part of maintaining the Actor.

### Integrations

Amazon Seller Data Extractor: AI Sentiment & Feedback Analytics runs on Apify, so it works with anything that can call the Apify API or client libraries.

#### Calling Amazon Seller Data Extractor: AI Sentiment & Feedback Analytics programmatically

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")

run = client.actor("scraper-engine/amazon-seller-data-extractor-ai-sentiment-feedback-analytics").call(
    run_input={
        "productAsins": ["B00P8XQPY4"],
        "marketplaceDomain": "amazon.com",
    }
)

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["seller_name"], item["reputationScore"])
```

Works in Go, Ruby, Node.js, cURL — any language that can make an HTTP request.

#### No-code tools (n8n, Make, LangChain)

In n8n or Make, use the HTTP Request node (or the dedicated Apify node) pointed at this Actor's run endpoint with your Apify API token, then parse the returned dataset items downstream. In LangChain or a similar agent framework, wrap the Apify client call above as a tool so an agent can request seller reputation data as part of a larger chain.

### Is it legal to scrape Amazon seller feedback data?

Scraping publicly available web data, like the seller storefront pages this Actor reads, is generally legal. Amazon Seller Data Extractor: AI Sentiment & Feedback Analytics only returns data any visitor can already see on a storefront page — no login-gated content. This is business/storefront data (seller name, ratings, feedback text, policies) rather than personal data in most cases, though `detailed_info[]` or `seller_phone_number` can occasionally expose a sole proprietor's personal name, address, or phone number when Amazon discloses it on the page — treat those fields with care if your use case involves storing them at scale. Consult legal counsel if your use case involves bulk storage of personal data.

### Frequently asked questions

#### What Amazon seller fields does this Actor return?

The top fields are `seller_name`, `seller_id`, `stars`/`starRatingNumeric`, `rating_count_m1`/`m3`/`m12`/`lifetime`, and `reputationScore` — see the full data fields table earlier in this README for the complete list.

#### Does this Actor require an Amazon account or login?

No. It scrapes publicly visible seller storefront and product pages over HTTP; no Amazon account, cookies, or login session are used.

#### How many sellers can I extract in one run?

There's no fixed cap in the input schema — `productAsins`, `sellerIds`, `sellerProfileUrls`, and `keywordInputs` all accept arrays, and each entry is processed up to `maxParallelSellers` concurrent fetches. Keyword-based discovery finds up to 15 unique sellers per keyword.

#### What happens if a seller page is missing or the storefront can't be found?

That input is skipped — the run logs it and continues with the remaining inputs. No placeholder or fabricated row is pushed to the dataset for a seller that couldn't be resolved.

#### Can I scrape multiple Amazon sellers at once?

Yes — pass multiple ASINs, seller IDs, URLs, or keywords in their respective array inputs in a single run; they're processed concurrently up to `maxParallelSellers`.

#### Does this Actor work with Claude, ChatGPT, and other AI agent tools?

It's callable as an HTTP endpoint by any agent framework via the Apify API/client, and its own AI sentiment module already calls Claude, GPT, Gemini, Grok, DeepSeek, Perplexity, or Mistral directly using your own provider key.

#### Is the sentiment analysis genuinely AI-generated, and by what model?

Yes — when `aiSentimentEnabled` is `true`, each feedback comment's text is sent to a real LLM API call (Anthropic, OpenAI, or an OpenAI-compatible endpoint for Gemini/Grok/DeepSeek/Perplexity/Mistral) using the model you pick in `aiModel` (default `claude-haiku-4-5`) and your own API key. It is not a keyword-matching label; a failed or missing key returns `null` sentiment fields for that run rather than a faked result.

#### Does this Actor return data in a format LLMs can use directly?

Yes. Every field is typed, normalized JSON with consistent names across runs — pass it directly to an LLM, index it into a vector store, or feed it to an agent tool without any HTML parsing.

#### What happens when Amazon changes its layout or anti-bot system?

The output schema is designed to stay stable — field names don't change — and the underlying page selectors are maintained against Amazon's current markup. No specific update turnaround time is published.

#### Can I use this Actor without managing proxies or browser infrastructure?

Yes — residential proxy sessions, request headers, and block-retry logic are all handled internally; you don't configure or run any proxy or browser infrastructure yourself.

#### Which fields work best for AI training data and RAG indexing?

For RAG, index `feedbacks[].text` alongside `description` and `detailed_info[]` — the highest-information free text on each row. For structured training data, `starRatingNumeric`, `positiveFeedbackScore`, `rating_count_m1/m3/m12/lifetime`, and `reputationScore` return as consistent typed numbers across every record.

### Related scrapers

| Scraper Name | What it extracts |
| --- | --- |
| [Amazon Best Sellers Scraper](https://apify.com/scraper-engine/amazon-bestsellers-scraper) | Top 100 best-selling products per category — name, price, ASIN, rank, rating, review count |
| [Amazon Search Products Scraper: Top Rated & Best Reviewed](https://apify.com/scraper-engine/amazon-search-products-scraper-top-rated-best-reviewed) | Amazon search results filtered and ranked by star rating and review count |
| [eBay Seller Scraper](https://apify.com/scraper-engine/ebay-seller-scraper) | Same seller-reputation extraction pattern, for eBay storefronts |
| [eBay Product Scraper](https://apify.com/scraper-engine/ebay-scraper-pay-per-events) | eBay product listings and pricing data |

### Your feedback

Found a bug or missing a field? Let us know through this Actor's Issues tab on Apify — reports like these directly shape what gets fixed and added next.

# Actor input Schema

## `productAsins` (type: `array`):

One ASIN per row (example: B00P8XQPY4). We open each product page and pull the seller behind the offer. Base-compatible fallback key: asinInputs.

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

Amazon seller IDs like A33W53J5GVPZ8K — perfect when you already know exactly who you're analyzing. Base-compatible fallback key: usernameInputs.

## `sellerProfileUrls` (type: `array`):

Full Amazon seller profile links (e.g. https://www.amazon.com/sp?seller=…). Base-compatible fallback key: startUrls.

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

Search-style phrases (e.g. "handmade ceramics UK"). We run the search, open matching products, and resolve each one's seller — de-duplicated by seller ID — then run the SAME reputation analytics (and optional AI sentiment/theme analysis) on every discovered seller. Great for prospecting new storefronts to analyze.

## `marketplaceDomain` (type: `string`):

Examples: amazon.com, amazon.co.uk, amazon.de, amazon.co.jp. Base-compatible fallback key: amazonDomain.

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

Optional locale string (en-US, en-GB, de-DE…) — sets the Accept-Language request header so Amazon serves that locale's page copy when it has one. Leave blank to let Amazon decide.

## `aiSentimentEnabled` (type: `boolean`):

When ON, each feedback comment's text is classified for sentiment (positive/neutral/negative) and recurring themes (e.g. shipping, packaging, service) via your chosen AI provider.

## `aiModel` (type: `string`):

Provider auto-detected from the name: claude-*=Anthropic, gpt-*/o1/o3=OpenAI, gemini-*=Google, grok-*=xAI, deepseek-*=DeepSeek, sonar*=Perplexity, mistral-\*=Mistral. Cheaper mini/flash/haiku models are recommended.

## `aiApiKey` (type: `string`):

Your own API key for the selected provider (Anthropic/OpenAI/Google/xAI/DeepSeek/Perplexity/Mistral). Required only when AI sentiment analysis is enabled. Falls back to the matching provider env var if left blank.

## `maxFeedbacksForAi` (type: `integer`):

Caps how many of each seller's feedback comments get AI sentiment/theme analysis (cost control). Default 20.

## `maxFeedbackPerSeller` (type: `integer`):

Cap feedback rows per seller (0 = grab everything the page allows). Base-compatible fallback key: maxComments.

## `maxParallelSellers` (type: `integer`):

Higher = faster but hotter on Amazon's radar. Lower (1-5) = gentler. Base-compatible fallback key: maxConcurrency.

## `proxyCountryCode` (type: `string`):

ISO-style country for routing (or AUTO). Base-compatible fallback key: proxyCountry.

## `useCaptchaSolver` (type: `boolean`):

No third-party CAPTCHA-image solving service runs here — flipping this ON instead doubles the anti-bot retry ladder (4 → 8 attempts) with longer backoff, which genuinely rescues more runs against soft blocks/verification interstitials. Leave OFF for typical runs; ON is slower.

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

How feedbacks\[] is actually ordered before maxFeedbackPerSeller truncates it: freshest first, most 'found helpful' votes first, or highest star rating first.

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

Residential routing is enforced for this actor.

## Actor input object example

```json
{
  "productAsins": [
    "B00P8XQPY4"
  ],
  "sellerIds": [],
  "sellerProfileUrls": [],
  "keywordInputs": [],
  "marketplaceDomain": "amazon.com",
  "aiSentimentEnabled": false,
  "aiModel": "claude-haiku-4-5",
  "maxFeedbacksForAi": 20,
  "maxFeedbackPerSeller": 10,
  "maxParallelSellers": 10,
  "proxyCountryCode": "AUTO",
  "useCaptchaSolver": false,
  "sortOrder": "recent",
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

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

All scraped items in the Actor's default dataset.

## `analytics` (type: `string`):

Derived non-AI reputation analytics per seller (rating windows, feedback velocity/recency, reputation score).

## `aiSentiment` (type: `string`):

Per-feedback AI sentiment/theme classification and sentiment summary, when AI sentiment analysis was enabled for the run.

## `full` (type: `string`):

Every field produced for each seller — base scrape, policies, ratings, and analytics/AI sentiment fields.

# 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 = {
    "productAsins": [
        "B00P8XQPY4"
    ],
    "sellerIds": [],
    "sellerProfileUrls": [],
    "keywordInputs": [],
    "marketplaceDomain": "amazon.com",
    "language": "",
    "aiModel": "claude-haiku-4-5",
    "maxFeedbackPerSeller": 10,
    "maxParallelSellers": 10,
    "proxyCountryCode": "AUTO",
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("scraper-engine/amazon-seller-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 = {
    "productAsins": ["B00P8XQPY4"],
    "sellerIds": [],
    "sellerProfileUrls": [],
    "keywordInputs": [],
    "marketplaceDomain": "amazon.com",
    "language": "",
    "aiModel": "claude-haiku-4-5",
    "maxFeedbackPerSeller": 10,
    "maxParallelSellers": 10,
    "proxyCountryCode": "AUTO",
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("scraper-engine/amazon-seller-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 '{
  "productAsins": [
    "B00P8XQPY4"
  ],
  "sellerIds": [],
  "sellerProfileUrls": [],
  "keywordInputs": [],
  "marketplaceDomain": "amazon.com",
  "language": "",
  "aiModel": "claude-haiku-4-5",
  "maxFeedbackPerSeller": 10,
  "maxParallelSellers": 10,
  "proxyCountryCode": "AUTO",
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call scraper-engine/amazon-seller-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,scraper-engine/amazon-seller-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/2PCRnQ2yUXe9piqvW/builds/1mFOlcKzqK1r7gtAV/openapi.json