# Amazon Brand Storefront Scraper (`automation-lab/amazon-brand-storefront-scraper`) Actor

Extract public Amazon Brand Store navigation, merchandising modules, creative image URLs, target links, and linked product ASINs.

- **URL**: https://apify.com/automation-lab/amazon-brand-storefront-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** E-commerce
- **Stats:** 3 total users, 2 monthly users, 71.4% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
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 Storefront Scraper

Extract public Amazon Brand Store pages into structured navigation, merchandising-module, creative-asset, link, and ASIN data.

Provide explicit `amazon.com/stores/page/<UUID>` URLs, take a one-page snapshot, or follow a bounded set of same-store navigation links. The Actor uses lightweight server-rendered HTML rather than a browser, so scheduled competitor snapshots stay fast and economical.

### What does Amazon Brand Storefront Scraper do?

Amazon Brand Storefront Scraper turns each meaningful Store widget into a typed dataset record.

It extracts:

- Store ID, page ID, brand name, and page title;
- the Store navigation and current-page marker;
- Amazon module type and module identifier;
- module headings and normalized visible text;
- creative image and responsive source-set URLs;
- links to category, campaign, and product destinations;
- linked Amazon Standard Identification Numbers (ASINs);
- source URL, navigation context, and scrape timestamp.

This Actor intentionally targets first-party **Amazon Brand Stores** at `/stores/page/<UUID>`.

It does not scrape generic Amazon search results, full product details, seller profiles, or `/shop/<creator>` influencer storefronts.

### Who is it for?

**Ecommerce brand teams** can archive their Store navigation and campaign modules before and after launches.

**Marketplace-intelligence teams** can schedule competitor storefront snapshots and compare page structure, featured ranges, links, and creative assets over time.

**Agencies** can monitor multiple client or competitor Store pages with repeatable JSON output instead of manual screenshots.

**Data engineers** can feed Store-page records into a warehouse, change-detection job, dashboard, or alerting workflow.

**Merchandising analysts** can identify linked ASINs and the page/module context in which Amazon presents them.

### Why use this Actor?

- **Module-level evidence:** output preserves which Amazon Store widget contained each text, image, link, or ASIN.
- **Bounded navigation traversal:** optionally follow Store navigation without expanding into generic Amazon crawling.
- **HTTP-first operation:** server-rendered Store markup avoids browser startup and unnecessary image downloads.
- **Useful failure behavior:** CAPTCHA, challenge, thin-shell, invalid URL, and exhausted retry conditions fail visibly instead of returning a misleading empty dataset.
- **Integration-ready results:** one default dataset works with Apify API, webhooks, schedules, Make, Zapier, Google Sheets, and custom ETL.
- **Cost-aware routing:** each request starts direct; configured proxy routing is used only after a failed or challenged response.

### What Amazon Store data can I extract?

| Field | Meaning |
| --- | --- |
| `storeId` | Amazon identifier shared by pages in the Brand Store, when exposed |
| `storePageId` | UUID in the requested `/stores/page/<UUID>` URL |
| `storeName` | Brand or Store name shown in the page title/header |
| `pageTitle` | Current Store page title, such as `What's New` |
| `moduleId` | Amazon widget identifier |
| `moduleType` | Widget type such as `Header`, `EditorialRow`, or `ProductGrid` |
| `moduleTitle` | Best available module heading or image label |
| `moduleText` | Normalized visible merchandising text |
| `imageUrls` | Creative image and responsive source-set URLs |
| `targetUrls` | Absolute links contained inside the module |
| `linkedProducts` | Linked `{ asin, url }` product objects |
| `asins` | Deduplicated ASINs linked in the module |
| `navigationItems` | Store-page navigation entries on Header records |
| `navigationPath` | Store and current-page labels |
| `sourceUrl` | Normalized Store page that produced the record |
| `scrapedAt` | UTC ISO 8601 extraction timestamp |

Fields may be absent or arrays may be empty when Amazon does not expose that property in a particular module.

### How to scrape an Amazon Brand Store

1. Open a public Amazon Brand Store page.
2. Copy a URL containing `/stores/page/<UUID>/`.
3. Create an Actor task or open the Actor input form.
4. Paste one or more URLs into **Amazon Brand Store page URLs**.
5. Leave **Follow same-store navigation pages** disabled for a precise snapshot.
6. Enable it only when you want a bounded crawl of linked Store pages.
7. Set **Maximum pages** and **Maximum module records** for your workflow.
8. Run the Actor.
9. Open the **Store modules** dataset view or download JSON, CSV, Excel, XML, or RSS.

The default prefill targets a live public Apple Brand Store page and is suitable for a small first run.

### Input parameters

| Parameter | Type | Default | Description |
| --- | --- | --- | --- |
| `startUrls` | array | required | Public Amazon Brand Store `/stores/page/<UUID>` URLs |
| `followNavigation` | boolean | `false` | Follow normalized Brand Store page links from the header navigation |
| `maxPages` | integer | `10` | Maximum unique Store pages across the run, from 1 to 100 |
| `maxItems` | integer | `100` | Maximum module records, from 1 to 10,000 |
| `requestRetries` | integer | `2` | Retries for transient/challenged responses, from 0 to 5 |
| `proxyConfiguration` | object | SHADER fallback | Apify proxy settings used only after a direct request fails |

Example input for one page:

```json
{
  "startUrls": [
    { "url": "https://www.amazon.com/stores/page/3AD65A30-7BC0-42C3-AC6C-4CCE1B02591C/" }
  ],
  "followNavigation": false,
  "maxPages": 1,
  "maxItems": 20,
  "requestRetries": 2
}
```

Example for a bounded monitoring crawl:

```json
{
  "startUrls": [
    { "url": "https://www.amazon.com/stores/page/77D9E1F7-0337-4282-9DB6-B6B8FB2DC98D/" }
  ],
  "followNavigation": true,
  "maxPages": 10,
  "maxItems": 100
}
```

### Output example

A current Store page can produce a Header record followed by content-module records.

```json
{
  "storeId": "77D9E1F7-0337-4282-9DB6-B6B8FB2DC98D",
  "storePageId": "3AD65A30-7BC0-42C3-AC6C-4CCE1B02591C",
  "storeName": "Apple",
  "pageTitle": "What's New",
  "moduleId": "exampleWidgetId",
  "moduleType": "EditorialRow",
  "moduleTitle": "Quick look",
  "moduleText": "Quick look",
  "imageUrls": [
    "https://m.media-amazon.com/images/S/stores-image-uploads-na-prod/example.jpg"
  ],
  "targetUrls": [
    "https://www.amazon.com/stores/page/CDE6D3D1-FF52-4226-9ED9-5C04165875FA/"
  ],
  "linkedProducts": [],
  "asins": [],
  "navigationItems": [],
  "navigationPath": ["Apple", "What's New"],
  "sourceUrl": "https://www.amazon.com/stores/page/3AD65A30-7BC0-42C3-AC6C-4CCE1B02591C/",
  "scrapedAt": "2026-07-27T12:00:00.000Z"
}
```

Amazon controls Store content. Module types, text, images, links, and ASIN presence vary by page and time.

### How much does it cost to scrape Amazon Brand Stores?

The Actor uses pay-per-event pricing:

- **$0.005** one-time start fee per run;
- module records use tiered pricing, beginning at **$0.000041071 per module** on the FREE tier;
- higher subscription tiers receive lower module prices, down to **$0.00001 per module** on DIAMOND.

Example Actor charges on the FREE tier:

| Workflow | Module records | Actor charge |
| --- | ---: | ---: |
| Small page snapshot | 2 | about $0.0051 |
| Ten-page monitoring crawl | 20 | about $0.0058 |
| Larger scheduled snapshot | 100 | about $0.0091 |

These examples use the FREE-tier module price and include the start fee. Actual page structure determines the number of module records. Platform compute and optional proxy usage are accounted for by Apify according to your plan.

No separate event is charged for images, links, navigation entries, or ASINs contained in a module record.

### Monitoring and integration workflows

#### Competitor creative monitoring

Schedule daily or weekly runs, export module records to a warehouse, and compare `imageUrls`, `moduleText`, and `targetUrls` by `storePageId` plus `moduleId`.

#### Navigation change alerts

Filter Header records, normalize `navigationItems`, and trigger an alert when labels or linked page IDs change.

#### Featured-product discovery

Flatten `linkedProducts` from content modules, then join ASINs to your catalog or a separate product-data source.

#### Campaign archive

Store each run's records with `scrapedAt` to preserve the page title, creative URLs, text, and destination links visible at each snapshot.

#### Multi-brand agency reporting

Pass several explicit Store URLs, keep traversal bounded, and group output by `storeId`, `storeName`, and `sourceUrl`.

### Run with the Apify API using cURL

Replace `APIFY_TOKEN` with your token.

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~amazon-brand-storefront-scraper/runs?token=APIFY_TOKEN&waitForFinish=120" \
  -H "Content-Type: application/json" \
  -d '{
    "startUrls": [{"url":"https://www.amazon.com/stores/page/77D9E1F7-0337-4282-9DB6-B6B8FB2DC98D/"}],
    "followNavigation": false,
    "maxPages": 1,
    "maxItems": 20
  }'
```

Fetch dataset items using the `defaultDatasetId` returned by the run.

### Run with JavaScript

Install the client:

```bash
npm install apify-client
```

```javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/amazon-brand-storefront-scraper').call({
  startUrls: [{
    url: 'https://www.amazon.com/stores/page/77D9E1F7-0337-4282-9DB6-B6B8FB2DC98D/'
  }],
  followNavigation: true,
  maxPages: 5,
  maxItems: 50
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

### Run with Python

Install the client:

```bash
pip install apify-client
```

```python
import os
from apify_client import ApifyClient

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/amazon-brand-storefront-scraper').call(run_input={
    'startUrls': [{
        'url': 'https://www.amazon.com/stores/page/77D9E1F7-0337-4282-9DB6-B6B8FB2DC98D/'
    }],
    'followNavigation': False,
    'maxPages': 1,
    'maxItems': 20,
})

items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

### Use Amazon Brand Store data with MCP

Add this Actor to Claude Code through Apify MCP:

```bash
claude mcp add --transport http apify \
  "https://mcp.apify.com?tools=automation-lab/amazon-brand-storefront-scraper"
```

Claude Desktop, Cursor, and VS Code can use this MCP server configuration:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=automation-lab/amazon-brand-storefront-scraper"
    }
  }
}
```

Example prompts:

- “Run Amazon Brand Storefront Scraper on this Store page and summarize its navigation.”
- “Extract creative image URLs and target links from this Amazon campaign page.”
- “Crawl up to five linked Store pages and list the ASINs by page and module.”
- “Compare the latest Store snapshot with yesterday's dataset and flag changed creatives.”

### Tips for reliable runs

- Start with one known public `/stores/page/<UUID>` URL.
- Use `followNavigation: false` when you only need the supplied page.
- Increase `maxPages` gradually for scheduled monitoring.
- Keep `requestRetries` at the default unless logs show transient failures.
- Keep the default SHADER fallback unless repeated challenges justify a different proxy group.
- Use a marketplace URL matching the Store's public country surface.
- Deduplicate downstream records by `storePageId` plus `moduleId` when comparing snapshots.
- Treat image URLs as references; the Actor does not download creative files.

### Limits and failure behavior

Amazon may vary Store content by marketplace, geography, campaign timing, and session.

The Actor only follows normalized Amazon Brand Store page links. It does not expand into product pages or arbitrary Amazon URLs.

Navigation traversal stops at `maxPages`; output stops at `maxItems`.

A module with no useful text, images, or links is skipped, except the Header record that carries Store navigation.

A page may legitimately contain only a Header and one content module.

The Actor returns a non-zero failure when:

- input is missing;
- a URL is malformed or is not a supported Amazon Brand Store page;
- Amazon returns 404;
- challenge or thin-shell responses continue after all retries;
- no Store modules can be extracted.

The Actor does not bypass login, solve CAPTCHA, or access private Store data.

### Troubleshooting

#### Why did my URL fail validation?

Check that it uses HTTPS on a supported Amazon marketplace and includes `/stores/page/` followed by a 36-character UUID. Product `/dp/`, seller, search, and influencer `/shop/` URLs are outside this Actor's scope.

#### Why did the run report an Amazon challenge?

Retry later or use Apify Proxy. The default configuration attempts direct access first and then SHADER on retry. If your target marketplace consistently blocks that route, choose a suitable proxy group and country in `proxyConfiguration`.

#### Why are there no ASINs in a module?

Many Store modules link to another campaign/category page rather than directly to a product. ASINs are returned only when a product URL exists inside that specific Store widget.

#### Why are there several image URLs for one creative?

Amazon commonly exposes responsive `srcset` variants. Keeping each URL lets downstream workflows choose the appropriate resolution and detect creative changes accurately.

#### Why did a page produce only two records?

The Actor emits one record per meaningful Store widget, not one record per DOM element. Some public pages currently contain only a Header and one editorial/product module.

### Responsible use and legality

This Actor extracts publicly accessible Amazon Brand Store pages.

You are responsible for:

- complying with Amazon's terms and applicable website rules;
- using reasonable run frequency and limits;
- respecting intellectual-property rights in text and creative assets;
- following privacy, database, and competition laws in your jurisdiction;
- obtaining any permissions required for storage, analysis, or redistribution.

Do not use the Actor to access private information, circumvent authentication, impersonate users, or republish protected creative assets without permission.

This documentation is technical guidance, not legal advice.

### Related Automation Lab Actors

- [Amazon Scraper](https://apify.com/automation-lab/amazon-scraper) — extract Amazon search-result product data.
- [Amazon Sellers Scraper](https://apify.com/automation-lab/amazon-sellers-scraper) — collect seller-focused Amazon information.
- [Amazon Reviews Scraper](https://apify.com/automation-lab/amazon-reviews-scraper) — extract customer reviews for Amazon products.
- [Amazon Influencer Storefront Scraper](https://apify.com/automation-lab/amazon-influencer-storefront-scraper) — target `/shop/<creator>` influencer pages and idea lists instead of Brand Stores.

Choose this Actor when the buyer job is Store navigation, merchandising-module, campaign-creative, and linked-ASIN monitoring.

### FAQ

#### Does it scrape Amazon product details?

No. It extracts links and ASINs present in Brand Store modules. Use a dedicated product Actor when you need price, rating, inventory, or full product-page fields.

#### Does it support Amazon influencer storefronts?

No. Influencer storefronts use `/shop/<creator>` and a different data model. Use Amazon Influencer Storefront Scraper.

#### Can it follow every Store navigation page?

Yes, within the configured `maxPages` and `maxItems` bounds. Start small because large brand navigation trees can change.

#### Can I schedule recurring snapshots?

Yes. Save a task, add an Apify schedule, and retain each run's dataset or export records to durable storage for comparison.

#### Does it need a browser?

Not for the current public Brand Store scope. Amazon includes identity, navigation, and module content in server-rendered HTML, which keeps the Actor at 256 MB memory.

#### Does it download images?

No. It returns creative URLs and responsive variants, minimizing transfer and letting you choose whether to download them downstream.

#### Is proxy use mandatory?

No. The Actor tries direct HTTP first. The configured proxy is a retry route for challenged or transient responses.

#### Can I submit several Store URLs?

Yes. They are normalized and deduplicated. Global page and item limits apply across the run.

#### How fresh is the output?

Each run extracts what Amazon returns at run time and records `scrapedAt`. Amazon controls caching, regional presentation, and campaign publication timing.

#### What should I use as a stable key?

Use `storePageId` plus `moduleId` for module comparisons, and include `scrapedAt` when storing historical snapshots.

# Actor input Schema

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

Public Amazon /stores/page/<UUID>/ URLs. Product, seller, and influencer storefront URLs are not supported.

## `followNavigation` (type: `boolean`):

When enabled, follow Brand Store page links found in the storefront navigation, bounded by Maximum pages.

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

Maximum number of unique Brand Store pages to fetch across the run.

## `maxItems` (type: `integer`):

Stop after saving this many storefront module records.

## `requestRetries` (type: `integer`):

Retry transient or challenged responses with bounded backoff and configured proxy routing.

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

Proxy used only after a direct request fails. The cost-effective SHADER group is the default fallback; choose another group only when needed.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.amazon.com/stores/page/77D9E1F7-0337-4282-9DB6-B6B8FB2DC98D/"
    }
  ],
  "followNavigation": false,
  "maxPages": 10,
  "maxItems": 20,
  "requestRetries": 2,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "SHADER"
    ]
  }
}
```

# Actor output Schema

## `dataset` (type: `string`):

Typed Store page modules with identity, text, creative assets, links, navigation, and ASINs.

# 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 = {
    "startUrls": [
        {
            "url": "https://www.amazon.com/stores/page/77D9E1F7-0337-4282-9DB6-B6B8FB2DC98D/"
        }
    ],
    "followNavigation": false,
    "maxPages": 10,
    "maxItems": 20,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "SHADER"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/amazon-brand-storefront-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 = {
    "startUrls": [{ "url": "https://www.amazon.com/stores/page/77D9E1F7-0337-4282-9DB6-B6B8FB2DC98D/" }],
    "followNavigation": False,
    "maxPages": 10,
    "maxItems": 20,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["SHADER"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/amazon-brand-storefront-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 '{
  "startUrls": [
    {
      "url": "https://www.amazon.com/stores/page/77D9E1F7-0337-4282-9DB6-B6B8FB2DC98D/"
    }
  ],
  "followNavigation": false,
  "maxPages": 10,
  "maxItems": 20,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "SHADER"
    ]
  }
}' |
apify call automation-lab/amazon-brand-storefront-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

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