# Amazon Brand Store Page & Merchandising Crawler (`dataspryva/amazon-brand-store-page-and-merchandising-crawler`) Actor

Crawl an Amazon Brand Store's navigation, creative modules (images, video, CTAs), and every product link found on its pages. Resolves a brand's Store URL automatically from a product page or ASIN.

- **URL**: https://apify.com/dataspryva/amazon-brand-store-page-and-merchandising-crawler.md
- **Developed by:** [Dataspryva](https://apify.com/dataspryva) (community)
- **Categories:** E-commerce, Automation, Developer tools
- **Security:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.49 / 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/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## 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.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Amazon Brand Store Page & Merchandising Crawler

Brands design their Amazon Store page like a mini storefront — navigation tabs, banner creative, merchandising rows, and a curated product mix. This actor crawls that storefront, walking the navigation menu into subpages, and returns its structure at every level: pages, sections, products, and links.

### What this actor does

- Crawls a Brand Store's landing page and, optionally, the subpages reachable through its own navigation menu.
- Resolves a brand's Store URL automatically when you only have a product page URL or ASIN instead.
- Emits one record per store page, one per merchandising section, one per distinct product, and one per unique target link inside each section.
- Captures each section's widget type, position, heading, body copy, call-to-action, primary image/video, and product/link counts.
- Tags every product and link with the section it came from, so a merchandising audit can be grouped or filtered without re-parsing the page.
- Reports a page explicitly as blocked or missing rather than silently returning it as an empty store.

A Brand Store is curated by the brand, not a full product catalog — Amazon doesn't guarantee every item a brand sells appears there. This actor reports every product link it can find on the pages it crawls; for a seller's complete catalog, a seller-shop scraper is the better tool.

### Output: store page record (recordType: storePage)

| Field | Description |
|---|---|
| `storeUrl` | The Brand Store URL this page belongs to |
| `brand` | Brand name |
| `storePageId` | Page identifier from the URL |
| `pageName` | Navigation label for this page, e.g. "HOME", "FEATURED DEALS" |
| `description` | Page meta description, when present |
| `logoUrl` | Brand logo image |
| `navigation` | Subpage links found on this page, each with `name`, `url`, `storePageId`, `order` (populated when `crawlSubpages` is on) |
| `sectionCount` | Merchandising sections found on this page |
| `productCount` | Distinct products linked from this page |
| `linkCount` | Unique links found on this page |
| `depth` | How many navigation hops from the landing page this page is |
| `pagePosition` | Position in the crawl order |
| `scrapedAt` | When the actor collected the record |

### Output: merchandising section record (recordType: section, when includeSections is on)

| Field | Description |
|---|---|
| `storeUrl`, `brand`, `pageName`, `storePageId` | Which store and page the section appears on |
| `sectionType` | Widget type, e.g. `Header`, `EditorialRow`, `MultiMediaCarousel`, `Hero` |
| `sectionId` | Amazon's widget ID for this section |
| `sectionPosition` | Position of the section in page order |
| `heading`, `bodyText` | Section title and body copy, when present |
| `ctaText` | Section call-to-action text, e.g. "Shop now", "Learn more" |
| `imageUrl`, `imageAlt`, `imageCount` | Primary section image and how many section-level images it contains |
| `videoUrl`, `videoThumbnail`, `videoTitle`, `videoCount` | Video module fields |
| `destinationUrl` | Primary non-product link target of the section |
| `productCount`, `linkCount` | Distinct products and unique links inside the section |
| `depth` | Navigation depth of the page |
| `scrapedAt` | When the actor collected the record |

### Output: product record (recordType: product)

| Field | Description |
|---|---|
| `asin` | Amazon product ID |
| `title` | Product title, when visible next to the link |
| `url` | Product page URL |
| `thumbnailImage` | Product thumbnail |
| `price`, `listPrice` | Price and list price, each with `value`, `currency`, `display`, only when visible on the page |
| `stars`, `reviewsCount` | Rating and review count, only when visible near the link |
| `badge` | One of `BestSeller`, `AmazonsChoice`, `OverallPick`, `LimitedTimeDeal`, `NewOnAmazon`, `SmallBusiness`, only when shown |
| `discountPercent` | Percent off, only when a discount badge is shown |
| `brand` | Brand name |
| `storeUrl`, `storeSubPage` | Store and page the product was found on |
| `sectionType`, `sectionId`, `sectionPosition` | The merchandising section that contains the product tile |
| `modulePosition` | Position of the product tile on the page |
| `scrapedAt` | When the actor collected the record |

### Output: link record (recordType: link, when includeLinks is on)

| Field | Description |
|---|---|
| `storeUrl`, `brand`, `pageName`, `storePageId` | Which store and page the link appears on |
| `linkType` | `product`, `storePage`, `search`, `external`, or `other` |
| `url` | Absolute target URL, with store-page tracking parameters removed |
| `text`, `ariaLabel` | Visible link text and accessibility label |
| `asin` | Product ID for product links |
| `destinationStorePageId` | Target page ID for store-page links |
| `isExternal` | Present and `true` for links that leave the store's Amazon domain |
| `sectionType`, `sectionId`, `sectionPosition` | The section the link appears in |
| `linkPosition` | Position of the link in page order |
| `depth` | Navigation depth of the page |
| `scrapedAt` | When the actor collected the record |

### Output: page error record (recordType: storePageError)

Emitted instead of a `storePage` record when a page couldn't be read. Fields: `storeUrl`, `pageClassification` (e.g. `NOT_FOUND`, `CAPTCHA`, `AUTH_REQUIRED`), `depth`, `pagePosition`.

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `storeUrls` | Array of strings | `[]` (prefill: soundcore landing page) | Brand Store URLs to crawl. At least one of `storeUrls`, `productUrls`, or `asins` is required. |
| `productUrls` | Array of strings | – | Product page URLs; the actor finds that product's "Visit the Store" link and crawls the store instead. |
| `asins` | Array of strings | – | ASINs on amazon.com with the same auto-resolve behavior as `productUrls`. |
| `crawlSubpages` | Boolean | `true` | Follow the store's own navigation menu into subpages. |
| `maxDepth` | Integer | `1` | How many navigation hops to follow from the landing page (1–5). |
| `maxPages` | Integer | `10` | Maximum store pages fetched per store, landing page included (1–50). |
| `maxProducts` | Integer | `200` | Maximum distinct product records emitted per store (1–2000). |
| `includeSections` | Boolean | `true` | Emit a `section` record for every merchandising module. |
| `includeLinks` | Boolean | `true` | Emit a `link` record for every unique on-page link. |
| `proxyConfiguration` | Proxy | Apify Proxy | Used for every request; automatically escalates to a different proxy tier if the store keeps blocking requests. |

#### Example: crawl a Brand Store including its subpages

```json
{
  "storeUrls": ["https://www.amazon.com/stores/soundcore/page/AD6AD8C0-90C7-4C65-8000-0AC741FA2633"],
  "crawlSubpages": true,
  "maxDepth": 2,
  "maxPages": 15,
  "maxProducts": 100
}
```

#### Example: landing page only, pages and products (no sections or links)

```json
{
  "storeUrls": ["https://www.amazon.com/stores/soundcore/page/AD6AD8C0-90C7-4C65-8000-0AC741FA2633"],
  "crawlSubpages": false,
  "includeSections": false,
  "includeLinks": false
}
```

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

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

### Use cases

- **Brand monitoring teams** track how a competitor merchandises and navigates their Amazon storefront.
- **Merchandising researchers** compare section types, headings, CTAs, and featured-product mix across brands.
- **Catalog discovery teams** find every product a brand currently features on its Store page.
- **Creative audit teams** collect a brand's storefront imagery, video, and CTA copy in one pass.
- **Link-integrity teams** export every navigation, store-page, product, and external target in one dataset.

### FAQ

**What is the difference between a section and a link?**
A section is a merchandising module (one widget on the page). Links are the individual targets inside those sections. A target that appears in more than one section gets one link record per section, so `linkCount` on a page can be lower than the number of link records. Both carry `sectionType`/`sectionId`, so they join cleanly.

**Why don't I see everything behind a "See products" modal?**
Shoppable-image modals load their product list only after a click. The actor reads the products already rendered on the page (carousels, grids, editorial tiles) and does not click through modals.

**My saved task sends `includeAssets` — will it still work?**
Yes. The old key is still accepted and mapped in code. Tasks that send it keep receiving the original flat `asset` records; new tasks should use `includeSections` and `includeLinks`.

**Is this the same as a seller's product catalog?**
No. A Brand Store is a curated page the brand designs; a seller catalog lists everything that seller has for sale. Use this actor for the storefront experience, and a seller-shop tool for the full catalog.

**Why do some products have no price or rating?**
Brand Store product tiles don't always render price or rating in the page itself — a field is only included when it's actually visible next to the product link, never a guessed 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 that product page, follows its "Visit the Store" link, and crawls that store instead.

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

**Why does the actor sometimes report a `storePageError` instead of products?**
Amazon occasionally serves a block or rate-limit page instead of the real store. Rather than reporting zero products as if the store were simply empty, the actor records explicitly what happened on that page.

**Does this capture every product a brand sells?**
No — see "What this actor does" above; a Brand Store is editorially curated, not a full catalog.

**Which Amazon marketplaces are supported?**
Any Amazon domain — amazon.com, amazon.co.uk, amazon.de, and so on — just pass the full Store URL for that marketplace.

**Is this affiliated with Amazon?**
No. This actor independently reads Amazon's public Brand Store pages and is not affiliated with or endorsed by Amazon.

# 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.

## `includeSections` (type: `boolean`):

Emit a `section` record for every merchandising module on each crawled page: its type, ID, position, heading, body copy, CTA, primary image/video, and product/link counts.

## `includeLinks` (type: `boolean`):

Emit a typed `link` record for every unique target on each crawled page (navigation, store page, product, search, external), with its section context.

## `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": false,
  "maxDepth": 1,
  "maxPages": 3,
  "maxProducts": 30,
  "includeSections": true,
  "includeLinks": true,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

Dataset containing storePage, section, product, link, and storePageError 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,
    "includeSections": true,
    "includeLinks": true,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("dataspryva/amazon-brand-store-page-and-merchandising-crawler").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,
    "includeSections": True,
    "includeLinks": True,
    "proxyConfiguration": { "useApifyProxy": True },
}

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

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,dataspryva/amazon-brand-store-page-and-merchandising-crawler"
        }
    }
}
```

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/NoDN50TMXljcpzeSO/builds/FPoln0nC5cwZuNgvj/openapi.json