# Amazon Seller & Shop Scraper (`crawlerbros/amazon-seller-shop-scraper`) Actor Scrape Amazon third-party seller intelligence: seller profile pages (business name/address/phone, star rating, feedback windows, ratings histogram) and seller storefront catalogs (/s?me=). Built for lead-gen and competitor/seller research. - **URL**: https://apify.com/crawlerbros/amazon-seller-shop-scraper.md - **Developed by:** [Crawler Bros](https://apify.com/crawlerbros) (community) - **Categories:** E-commerce, Lead generation, Automation - **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks - **User rating**: No ratings yet ## Pricing from $3.00 / 1,000 results This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage. Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have. Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event ## What's an Apify Actor? Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows. In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours, and optionally produces a well-defined JSON output, datasets with results, or files in key-value store. In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server. Actors are written with capital "A". ## How to integrate an Actor? If asked about integration, you help developers integrate Actors into their projects. You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready. The best way to integrate Actors is as follows. - **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use). - **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`. - **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`. - **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`. - **Any other language** — the [REST API](https://docs.apify.com/api/v2.md). For usage examples, see the [API](#api) section below. For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt). # README ## Amazon Seller & Shop Scraper Scrape **Amazon third-party seller intelligence** — the seller profile page (business name, address, phone, star rating, feedback windows, ratings histogram) and the seller's storefront product catalog (`/s?me=`), in one actor. Built for lead generation, competitor research, and seller due-diligence use cases. No login, no cookies required. ### What this actor does - **Three modes:** `PROFILE` (seller profile only), `PRODUCTS` (storefront catalog only), `BOTH` (default) - **Two input paths:** supply seller IDs directly, or supply product URLs and the actor auto-derives the seller ID from each product's buy-box "sold by" link - **Seller feedback windows:** 30-day, 90-day, 12-month, and lifetime rating + ratings-count, whichever windows Amazon actually shows for that seller - **Feedback histogram:** percentage breakdown across 5/4/3/2/1 stars - **Public business data:** legal business name, business address, and customer-service phone number — data Amazon itself displays publicly on the seller profile page (toggle off with `includeBusinessDetails`) - **Storefront catalog:** reuses the standard Amazon search-result card schema (title, price, rating, image, badges) for every product in the seller's shop - **23 Amazon marketplaces supported** (all browser-verified) - **Empty fields are omitted** — no null placeholders, no fabricated data ### Output: seller profile record (`recordType: "sellerProfile"`) - `sellerId`, `sellerName`, `profileUrl`, `storefrontUrl` - `starRating` — overall star rating shown in the page header - `positivePercent12m`, `ratingsCount12m` — 12-month positive-feedback percent and count (when shown) - `positivePercentWindow`, `positivePercent`, `positivePercentRatingsCount` — the exact window Amazon's own page header currently displays (usually 12 months, but not guaranteed) - `feedbackWindows[]` — `{window, starRating, ratingsCount}` for each of 30 days / 90 days / 12 months / lifetime that Amazon actually shows data for - `feedbackHistogram` — `{"5": {percent}, "4": {percent}, ...}` - `aboutText` — the seller's "About" description - `phone` — customer-service phone number (public, `includeBusinessDetails=true`) - `businessName`, `businessAddress` — public legal business identity (`includeBusinessDetails=true`). For the common 5-line Western format, `businessAddress` is `{street, city, state, zip, country}`; for addresses that don't fit that exact 5-line shape (common among non-Western/international sellers), `businessAddress` is instead `{addressLines: [...]}` — the real, ordered address lines exactly as Amazon renders them, never force-fit into the wrong field - `returnRefundPolicyText`, `shippingPolicyText`, `privacyPolicyText` — the seller's own return/refund, shipping, and privacy-notice text, when Amazon's page renders one - `scrapedAt` ### Output: seller product record (`recordType: "sellerProduct"`) - `asin`, `sellerId`, `title`, `url` - `price {value, currency, display}`, `listPrice` - `stars`, `reviewsCount` - `thumbnailImage` - `prime`, `sponsored`, `resultType` (`ORGANIC`/`SPONSORED`), `badge` - `boughtInPastMonth` - `position {page, positionOnPage, globalPosition}` - `scrapedAt` ### Output: storefront facets record (`recordType: "storefrontFacets"`) One record per seller (mode `PRODUCTS`/`BOTH`), built from the storefront's own refinement rail and sort dropdown — lets you discover what departments/filters and sort orders exist for a seller's catalog before deciding what to request. - `sellerId`, `storefrontUrl` - `facets[]` — `{groupName, label, url, selected, refinementParameter?}` from the storefront's `#s-refinements` rail (Department, Delivery Day, Free Shipping, etc.) - `sortOptions[]` — `{value, label, selected}` from the storefront's own "Sort by" dropdown — `value` is the exact string the `sortBy` input accepts - `pagesRequested`, `pagesFetched` — how many storefront pages were actually fetched vs. `maxProductPages` requested. Usually equal; `pagesFetched` can be lower either because the storefront's own last page was reached naturally (fewer sellers have hundreds of pages of stock) or, rarely, because a persistent anti-bot block stopped the fetch partway through (in that case a `pagesStoppedReason: "BLOCKED"` field is also present, so a short run is never silently indistinguishable from a genuinely small storefront) - `scrapedAt` ### Output: error/terminal record (`recordType: "sellerError"`) Emitted instead of a normal record when a seller/page could not be resolved (not found, blocked, CAPTCHA, etc.) — the actor never silently returns zero items for a requested seller without explaining why. - `sellerId`, `pageClassification` (e.g. `NOT_FOUND`, `CAPTCHA`, `DOG_PAGE_503`), `scrapedAt` ### Input | Field | Type | Default | Description | |---|---|---|---| | `mode` | string | `BOTH` | `PROFILE` / `PRODUCTS` / `BOTH` | | `sellerIds` | array | – | Seller/merchant IDs to look up directly | | `productUrls` | array | – | Product URLs to derive seller IDs from (buy-box seller link) | | `marketplace` | string | `US` | Amazon marketplace/domain | | `maxProductPages` | int | `3` | Max storefront pages per seller (mode=PRODUCTS/BOTH), ~16 products/page | | `includeBusinessDetails` | bool | `true` | Include public business name/address/phone | | `sortBy` | string | (default/Featured) | Storefront sort order (mode=PRODUCTS/BOTH) -- matches Amazon's own "Sort by" dropdown values | | `useResidentialProxy` | bool | `false` | Force residential proxy from the start | | `proxyCountry` | string | `AUTO` | Proxy geo-targeting country | At least one of `sellerIds` or `productUrls` is required. #### Example: look up two sellers directly ```json { "mode": "BOTH", "sellerIds": ["A294P4X9EWVXLJ", "A35BKAA6VXTYCT"], "maxProductPages": 2 } ``` #### Example: derive the seller from a product page ```json { "mode": "PROFILE", "productUrls": ["https://www.amazon.com/dp/B0BTYCRJSS"] } ``` #### Example: storefront catalog only, UK marketplace ```json { "mode": "PRODUCTS", "sellerIds": ["A294P4X9EWVXLJ"], "marketplace": "GB", "maxProductPages": 5 } ``` ### Use cases - **Lead generation** — build a list of active third-party sellers with public business name/address/phone for outreach - **Competitor research** — monitor a competing seller's full storefront catalog and pricing - **Seller due-diligence** — check a seller's rating history across multiple feedback windows before doing business with them - **Marketplace research** — compare seller reputations (histogram, positive %) across a category - **Supply-chain verification** — confirm a seller's legal business identity before sourcing ### FAQ **Is this affiliated with Amazon?** No. This is an independent third-party actor that scrapes Amazon's own public seller profile and storefront pages — no API keys, cookies, or login required. **Is the business name/address/phone customer personal data?** No. This is the seller's own public business identity that Amazon displays on every seller's public profile page (`/sp?seller=...`), distinct from any Amazon customer's personal/GDPR-sensitive data. You can disable it with `includeBusinessDetails: false`. **Why do some sellers have fewer feedback windows than others?** Amazon only shows a feedback window (30 days / 90 days / 12 months / lifetime) when the seller has ratings data for that window. A newer seller may only show 90-day and lifetime, for example — the actor reports exactly what Amazon displays, never a fabricated shape. **Does this include individual written feedback comments (per-buyer text/author/date)?** No. Amazon's public seller profile page (`/sp?seller=...`) only ever renders the *aggregate* feedback data this actor extracts — star rating, positive-percent, and the 5/4/3/2/1-star histogram per time window. It does not render individual buyer feedback comments/text/author/date anywhere on that page (verified live), so the actor doesn't fabricate a per-comment feedback list. **Why is a seller record sometimes missing instead of empty?** If a seller ID can't be resolved (not found, blocked, CAPTCHA), the actor emits an explicit error/terminal record (`recordType: "sellerError"`) with a `pageClassification` explaining why, rather than silently returning nothing. **How many products does the storefront catalog return?** Up to `maxProductPages` × ~16 products per seller — exactly what Amazon's own storefront pagination currently exposes for that seller, not a fixed/guaranteed count. **Does this work on every Amazon marketplace?** Yes — all 23 supported marketplaces work end-to-end, including ones that show an interactive anti-bot challenge on the seller/storefront pages (it resolves automatically after the actor's normal page-load wait). Non-US marketplaces can occasionally see proxy-routing timeouts; if a run fails on a non-US marketplace, retry it and/or enable `useResidentialProxy: true`. **Why does `profileUrl`/`storefrontUrl` return an error in a plain `curl`/script check?** Amazon's edge WAF blocks non-browser requests (no JS execution, no real browser TLS fingerprint) to `/sp?seller=...` and `/s?me=...` with a `503`, even though the exact same URL loads fine in a real browser (or via this actor's own Playwright session — verified live). `productUrl` (`/dp/ASIN`) and media/thumbnail URLs are not behind this same block and return `200` from a plain client. **Is `sortBy` guaranteed across every storefront page?** Amazon's own storefront reliably honors a non-default `sortBy` on page 1 of the catalog (verified live: `price-asc-rank`/`price-desc-rank` correctly order page 1's results). For `maxProductPages > 1`, the actor carries the sort session forward using Amazon's own "next page" link and query-id where available, but Amazon's storefront backend does not guarantee the same strict order past page 1 for every sort value — treat page 1 as the authoritative sorted sample if you need a strict global order. ### More Amazon Actors Part of a full Amazon scraper suite — also check out: - [Amazon Category Scraper](https://apify.com/crawlerbros/amazon-scraper) - [Amazon Product Scraper](https://apify.com/crawlerbros/amazon-product-scraper) - [Amazon Best Sellers & Rankings Scraper](https://apify.com/crawlerbros/amazon-bestseller-scraper) - [Amazon Reviews Scraper](https://apify.com/crawlerbros/amazon-reviews-scraper) - [Amazon Reviews Scraper Pro](https://apify.com/crawlerbros/amazon-reviews-scraper-pro) - [Amazon Offers Scraper (All Offers Display)](https://apify.com/crawlerbros/amazon-offers-scraper) - [Amazon Deals Scraper](https://apify.com/crawlerbros/amazon-deals-scraper) - [Amazon Brand Store Scraper](https://apify.com/crawlerbros/amazon-brand-store-scraper) - [Amazon Creator Shop Scraper](https://apify.com/crawlerbros/amazon-creator-shop-scraper) - [Amazon Wishlist & Registry Scraper](https://apify.com/crawlerbros/amazon-list-registry-scraper) - [Amazon Keyword Suggestions Scraper](https://apify.com/crawlerbros/amazon-keyword-suggestions-scraper) # Actor input Schema ## `mode` (type: `string`): PROFILE fetches only the seller profile page. PRODUCTS fetches only the seller's storefront catalog. BOTH fetches both for every resolved seller. ## `sellerIds` (type: `array`): Amazon seller/merchant IDs (e.g. A294P4X9EWVXLJ). Accepts bare IDs or IDs embedded in a seller/storefront URL. ## `productUrls` (type: `array`): Amazon product page URLs (e.g. https://www.amazon.com/dp/ASIN). The seller ID is auto-derived from each product's buy-box "sold by" seller link. ## `marketplace` (type: `string`): Amazon marketplace/domain to scrape sellers on. Overrides the domain inferred from productUrls when both are provided. ## `maxProductPages` (type: `integer`): Maximum number of /s?me= storefront pages to fetch per seller (mode=PRODUCTS or BOTH). Each page holds up to ~16 products. ## `includeBusinessDetails` (type: `boolean`): If true, includes the seller's publicly-displayed legal business name, business address, and customer-service phone number (data Amazon itself shows on the public seller profile page -- not customer-level personal data). ## `sortBy` (type: `string`): Sort order for the seller's storefront catalog (mode=PRODUCTS or BOTH), matching Amazon's own storefront "Sort by" dropdown. Leave blank for Amazon's default (Featured). ## `useResidentialProxy` (type: `boolean`): By default the actor uses datacenter (AUTO) proxies with a homepage-priming technique that reliably bypasses Amazon's cold-navigation block, escalating to residential proxies automatically only if repeated blocks occur. Enable this to force residential proxies (more reliable but more expensive) from the start. ## `proxyCountry` (type: `string`): Proxy country for geo-targeting. Use AUTO to automatically select based on the Amazon marketplace/domain. ## Actor input object example ```json { "mode": "BOTH", "sellerIds": [ "A294P4X9EWVXLJ" ], "productUrls": [ "https://www.amazon.com/dp/B0BTYCRJSS" ], "marketplace": "US", "maxProductPages": 1, "includeBusinessDetails": true, "sortBy": "", "useResidentialProxy": false, "proxyCountry": "AUTO" } ``` # Actor output Schema ## `records` (type: `string`): Dataset containing all scraped seller profile and seller-storefront product records. # 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 = { "mode": "BOTH", "sellerIds": [ "A294P4X9EWVXLJ" ], "productUrls": [], "marketplace": "US", "maxProductPages": 1, "includeBusinessDetails": true, "sortBy": "", "useResidentialProxy": false, "proxyCountry": "AUTO" }; // Run the Actor and wait for it to finish const run = await client.actor("crawlerbros/amazon-seller-shop-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 '' with your token. client = ApifyClient("") # Prepare the Actor input run_input = { "mode": "BOTH", "sellerIds": ["A294P4X9EWVXLJ"], "productUrls": [], "marketplace": "US", "maxProductPages": 1, "includeBusinessDetails": True, "sortBy": "", "useResidentialProxy": False, "proxyCountry": "AUTO", } # Run the Actor and wait for it to finish run = client.actor("crawlerbros/amazon-seller-shop-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 '{ "mode": "BOTH", "sellerIds": [ "A294P4X9EWVXLJ" ], "productUrls": [], "marketplace": "US", "maxProductPages": 1, "includeBusinessDetails": true, "sortBy": "", "useResidentialProxy": false, "proxyCountry": "AUTO" }' | apify call crawlerbros/amazon-seller-shop-scraper --silent --output-dataset ``` ## MCP server setup ```json { "mcpServers": { "apify": { "type": "http", "url": "https://mcp.apify.com/?tools=fetch-actor-details,crawlerbros/amazon-seller-shop-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 ` 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/C7ySuVFpVfISbXbVE/builds/cNkvvfogfUZSspG8R/openapi.json