# Amazon Brand Store Scraper (`crawlerbros/amazon-brand-store-scraper`) Actor

Scrape Amazon Brand Store pages (/stores/{Brand}/page/{ID}) - curated storefront navigation, creative modules (images/video/CTAs), and every validated product link found on the page. Also resolves a brand's store URL from any Amazon product page.

- **URL**: https://apify.com/crawlerbros/amazon-brand-store-scraper.md
- **Developed by:** [Crawler Bros](https://apify.com/crawlerbros) (community)
- **Categories:** E-commerce, Automation, Developer tools
- **Stats:** 3 total users, 2 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 Brand Store Scraper

Scrape **Amazon Brand Store** pages (`/stores/{Brand}/page/{ID}`) — the curated, editorial storefronts brands build on Amazon. Crawls the landing page and its navigation subpages (HOME, FEATURED DEALS, SSD, CARDS & READERS, ...), extracts every validated product link found anywhere on each page, and (optionally) the creative modules — banner images, video, headings/CTAs — used to merchandise the brand. You can also hand it product page URLs or ASINs and it will find the brand's store link automatically. No login, no cookies required.

### What this actor does

- **Store crawl:** navigates a Brand Store's landing page, follows its in-store navigation menu, and walks subpages up to a configurable depth/page cap
- **Auto-resolve:** give it `productUrls` or `asins` instead of a store URL — it visits the product page, finds the "Visit the {Brand} Store" link, and crawls that store
- **Product discovery:** finds every real `/dp/{ASIN}` product link on each store page (not just ones in standard search-card markup — Brand Store products render in custom modules), with title/price/rating only when actually visible next to the link
- **Creative assets:** optionally emits banner images, video modules, and CTA/heading text used to merchandise the brand (`includeAssets`)
- **Empty fields are omitted**

### Data source & limitations

A Brand Store is **editorially curated by the brand**, not a full product catalog — Amazon does not guarantee every SKU a brand sells appears there. This actor reports every product link it can find on the crawled pages; it does not claim "full catalog coverage." If you need a seller's complete catalog, use a seller-shop scraper (`/s?me=`) instead.

### Output: store page (`recordType: "storePage"`)

- `storeUrl`, `brand`, `storePageId`, `pageName`
- `description` — page meta description, when present
- `logoUrl`
- `navigation[]` — subpage links found on this page: `{name, url, storePageId, order}`
- `depth`, `pagePosition`
- `recordType: "storePage"`, `scrapedAt`

### Output: creative asset (`recordType: "asset"`, when `includeAssets=true`)

- `storeUrl`, `brand`, `storeSubPage`
- `moduleType` — `image` or `video`
- `heading` — nearest section heading, when present
- `bodyText` — supporting paragraph/caption text on the module, when present
- `ctaText` — call-to-action button/link text (e.g. "Shop now"), when present
- `imageUrl`, `imageAlt` (image modules)
- `videoUrl`, `videoThumbnail`, `videoTitle` (video modules)
- `destinationUrl` — link target, if the asset is itself a link to another page (non-product)
- `modulePosition`
- `recordType: "asset"`, `scrapedAt`

**Not implemented — shoppable image hotspots.** Some brands' storefronts on other platforms use
"shoppable images" — a single lifestyle photo with multiple clickable regions, each linking to a
different product. On current Amazon Brand Store markup, every creative image/video tile carries at
most one link for the entire tile, never multiple per-region product links or coordinate-based
hotspot markers, so this module type is not currently observed and therefore not emitted as a
separate field.

### Output: product (`recordType: "product"`)

- `asin`, `title`, `url`
- `thumbnailImage`
- `price`, `listPrice` — `{value, currency, display}`, only when visible on the page
- `stars`, `reviewsCount` — only when visible near the product link
- `badge` — one of `BestSeller`/`AmazonsChoice`/`OverallPick`/`LimitedTimeDeal`/`NewOnAmazon`/`SmallBusiness`, only when a badge is visible on the product card
- `discountPercent` — integer percent-off (e.g. `23` for "23% off"), only when a discount badge is visible
- `brand`, `storeUrl`, `storeSubPage`, `modulePosition`
- `recordType: "product"`, `scrapedAt`

### Output: page error (`recordType: "storePageError"`)

Emitted instead of a `storePage` record when a page can't be read (blocked, not found, rate-limited). Fields: `storeUrl`, `pageClassification` (e.g. `NOT_FOUND`, `DOG_PAGE_503`, `CAPTCHA`, `AUTH_REQUIRED`), `depth`, `pagePosition`.

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `storeUrls` | array | `["https://www.amazon.com/stores/soundcore/page/AD6AD8C0-90C7-4C65-8000-0AC741FA2633"]` | Brand Store URLs, e.g. `https://www.amazon.com/stores/{Brand}/page/{ID}` |
| `productUrls` | array | – | Product (`/dp/{ASIN}`) URLs — resolves the brand's store link automatically |
| `asins` | array | – | ASINs on amazon.com — same auto-resolve behavior |
| `crawlSubpages` | bool | `true` | Follow the store's navigation menu to crawl subpages |
| `maxDepth` | int | `1` | Navigation-link hops to follow (1–5) |
| `maxPages` | int | `10` | Hard cap on total store pages fetched per store (1–50) |
| `maxProducts` | int | `200` | Hard cap on product records emitted per store (1–2000) |
| `includeAssets` | bool | `true` | Also emit creative/module asset records |
| `proxyConfiguration` | object | AUTO | Apify proxy. Starts on the free AUTO (datacenter) group; escalates to RESIDENTIAL automatically only after repeated blocks |

#### Example: crawl a Brand Store with subpages

```json
{
  "storeUrls": ["https://www.amazon.com/stores/SanDisk/page/CD971F4B-9F97-4E38-B7D0-4E3E0E0E0E0E"],
  "crawlSubpages": true,
  "maxDepth": 2,
  "maxPages": 15,
  "maxProducts": 100
}
```

#### Example: landing page only, no creative assets

```json
{
  "storeUrls": ["https://www.amazon.com/stores/soundcore/page/HOME"],
  "crawlSubpages": false,
  "includeAssets": false
}
```

#### Example: resolve a store from a product page

```json
{
  "storeUrls": [],
  "productUrls": ["https://www.amazon.com/dp/B09X7MPX8L"]
}
```

### Use cases

- **Brand monitoring** — track how a competitor merchandises their Amazon Brand Store
- **Catalog discovery** — find every product a brand currently features on Amazon
- **Creative audits** — collect a brand's Amazon storefront imagery/video/CTA copy in one pass
- **Merchandising research** — compare navigation structure and featured-product mix across brands
- **Price/rating snapshots** — capture the price/rating shown on Brand Store product tiles

### FAQ

**Is this the same as a seller's product catalog?** No. A Brand Store is a curated, editorial page a brand designs; a seller catalog (`/s?me={sellerId}`) lists everything that seller has listed for sale. Use this actor for the storefront experience, a seller-shop actor for the full catalog.

**Why do some products have no price or rating?** Brand Store product tiles don't always render price/rating in the page markup — the actor only emits these fields when they're actually visible next to the product link, never a guessed or fabricated value.

**What if I only have a product URL, not a store URL?** Pass it via `productUrls` (or the ASIN via `asins`) — the actor opens the product page, finds its "Visit the {Brand} Store" link, and crawls that store instead.

**Does this actor need a login or cookies?** No — Brand Store pages are public.

**Why does the actor sometimes report `storePageError` records instead of products?** Amazon occasionally serves a block/CAPTCHA/rate-limit page instead of the real store. Rather than silently reporting zero products as if the store were simply empty, the actor emits an explicit `storePageError` record documenting what happened.

**Does this get every product a brand sells?** No — a Brand Store is curated by the brand, not a full catalog. See "Data source & limitations" above.

**Which Amazon domains are supported?** Any Amazon marketplace domain (amazon.com, amazon.co.uk, amazon.de, etc.) — pass the full URL for the marketplace you want.

### 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 Seller & Shop Scraper](https://apify.com/crawlerbros/amazon-seller-shop-scraper)
- [Amazon Deals Scraper](https://apify.com/crawlerbros/amazon-deals-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

## `storeUrls` (type: `array`):

Amazon Brand Store URLs, e.g. `https://www.amazon.com/stores/soundcore/page/AD6AD8C0-90C7-4C65-8000-0AC741FA2633`. At least one of storeUrls / productUrls / asins is required.

## `productUrls` (type: `array`):

Amazon product (/dp/{ASIN}) URLs. The actor visits each product page, finds its "Visit the {Brand} Store" link, and crawls that store instead.

## `asins` (type: `array`):

Product ASINs on amazon.com. Same resolution behavior as productUrls.

## `crawlSubpages` (type: `boolean`):

Follow the store's navigation menu (HOME, FEATURED DEALS, SSD, ...) and crawl every linked subpage, not just the landing page.

## `maxDepth` (type: `integer`):

How many navigation-link hops to follow from the landing page when crawlSubpages is enabled (1 = landing page's direct subpages only).

## `maxPages` (type: `integer`):

Hard cap on the total number of store pages (landing + subpages) fetched per store.

## `maxProducts` (type: `integer`):

Hard cap on the number of distinct product (ASIN) records emitted per store.

## `includeAssets` (type: `boolean`):

Also emit module/creative-asset records (images, video, CTA text, shoppable-image hotspots) found on each store page, not just product records.

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

Apify proxy. AUTO (datacenter) is used by default with homepage-priming; the actor escalates to RESIDENTIAL automatically only if it keeps getting blocked.

## Actor input object example

```json
{
  "storeUrls": [
    "https://www.amazon.com/stores/soundcore/page/AD6AD8C0-90C7-4C65-8000-0AC741FA2633"
  ],
  "productUrls": [],
  "asins": [],
  "crawlSubpages": true,
  "maxDepth": 1,
  "maxPages": 3,
  "maxProducts": 30,
  "includeAssets": true,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `storeRecords` (type: `string`):

Dataset containing all scraped Brand Store pages, modules/assets, and 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 '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "storeUrls": [
        "https://www.amazon.com/stores/soundcore/page/AD6AD8C0-90C7-4C65-8000-0AC741FA2633"
    ],
    "productUrls": [],
    "asins": [],
    "crawlSubpages": false,
    "maxDepth": 1,
    "maxPages": 3,
    "maxProducts": 30,
    "includeAssets": true,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/amazon-brand-store-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 = {
    "storeUrls": ["https://www.amazon.com/stores/soundcore/page/AD6AD8C0-90C7-4C65-8000-0AC741FA2633"],
    "productUrls": [],
    "asins": [],
    "crawlSubpages": False,
    "maxDepth": 1,
    "maxPages": 3,
    "maxProducts": 30,
    "includeAssets": True,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("crawlerbros/amazon-brand-store-scraper").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 '{
  "storeUrls": [
    "https://www.amazon.com/stores/soundcore/page/AD6AD8C0-90C7-4C65-8000-0AC741FA2633"
  ],
  "productUrls": [],
  "asins": [],
  "crawlSubpages": false,
  "maxDepth": 1,
  "maxPages": 3,
  "maxProducts": 30,
  "includeAssets": true,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call crawlerbros/amazon-brand-store-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=crawlerbros/amazon-brand-store-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/Y8Sjz8lRWwtqZEoPN/builds/kxVLw3xErCeaJmSLP/openapi.json