# Amazon Storefront Scraper (`agentx/amazon-storefront-scraper`) Actor

Amazon Brand Store scraper that turns one Store URL into a 28-field row: store and page IDs, marketplace, store type, brand-or-vendor owner, theme, logo, hero, category navigation and ProductGrid products with prices and ratings, with no advertiser account required.

- **URL**: https://apify.com/agentx/amazon-storefront-scraper.md
- **Developed by:** [AgentX](https://apify.com/agentx) (community)
- **Categories:** E-commerce, Lead generation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.2625 / result

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 Store scraper: paste one Brand Store page URL and get one normalized 28-field row — store identity, marketplace, page presentation, category navigation, media, and the ProductGrid products with prices and ratings.**

- **One required input.** A single `store_url` field; no advertiser account, seller login or API key.
- **28 fields, always the same shape.** Every field is present on every row, and a value Amazon does not expose comes back `null` instead of vanishing.
- **10 marketplaces.** US, Canada, UK, Germany, France, Italy, Spain, Japan, Australia and India, each returning its own `country_code`.
- **One billed result per run.** The products inside the row ride along with it — there is no per-product charge.

[**Run a small test**](https://apify.com/agentx/amazon-storefront-scraper) · [**View API**](https://apify.com/agentx/amazon-storefront-scraper/api)

The smallest useful test is one live Brand Store URL: one Actor start plus one `result` event, and at most one Dataset row.

### What does Amazon Storefront Scraper do?

An [Amazon Brand Store](https://advertising.amazon.com/solutions/products/stores) is the multipage destination an eligible brand builds inside a marketplace — its own URL, navigation, imagery and curated collections. Reading one by hand is fine once; reading it weekly across six brands and three countries is not.

This Actor turns one Brand Store page URL into one row. It resolves the canonical Store URL and the root page behind it, reads the identifiers Amazon attaches to the page, records how the Store presents itself, walks the category navigation the Store exposes, and merges the ProductGrid products from the Store page and each category page into one deduplicated list.

Two fields change what a row means. `store_type` separates a real Brand Store (`STORE`) from a sponsored-ad landing page (`HSA`) and a bare navigation shell (`NAV`). `entity_type` separates a store owned by the brand (`BRAND`) from one run by a vendor (`VENDOR`). Filter on both before comparing stores and ad landing pages stay out of your dataset.

It is not a catalog feed, an offer history, a seller account, or proof of brand ownership. `products` is what the Store displayed at retrieval time, and Amazon can render recommendation cards inside Store pages, so check ASIN and brand relevance before joining the list to a catalog.

It is also not Amazon's official [Stores API](https://advertising.amazon.com/API/docs/en-us/reference/2/stores), which authenticates as an advertiser and only reaches stores registered to that account. This Actor reads any public Brand Store, read-only, with no account relationship to the brand.

### How do I use Amazon Storefront Scraper?

1. Copy the full Store address from the browser. It must contain `/stores/`, an optional brand slug, `/page/`, and the Store identifier.
2. Paste it into `store_url` and start the run.
3. Open the default Dataset — a successful run holds exactly one item.
4. Check `store_type` and `country_code` first: they say whether this is a real Brand Store and which marketplace answered.

```json
{
  "store_url": "https://www.amazon.com/stores/Logitech/page/01EFDE77-7D1A-41D7-9EEA-7C2FA22AB12F"
}
```

Product URLs, seller profiles, search pages, short vanity URLs and influencer storefronts are rejected before any request is made, with a message naming the accepted shape.

### Input

One field, required.

| Field | Type | Required | Accepted format |
| --- | --- | --- | --- |
| `store_url` | string | Yes | `https://<supported host>/stores/{optional-brand}/page/{store-id}` |

The scheme must be HTTP or HTTPS and the hostname must match a supported marketplace exactly — `amazon.com`, `amazon.ca`, `amazon.co.uk`, `amazon.de`, `amazon.fr`, `amazon.it`, `amazon.es`, `amazon.co.jp`, `amazon.com.au`, `amazon.in`, and their `www` forms. A hostname that merely contains the word Amazon is rejected. One run takes one Store, so a watchlist becomes one run per URL.

### Output

One row, 28 fields, every field present.

| Fields | What they carry |
| --- | --- |
| `processor`, `processed_at` | Which Actor produced the row and the UTC second it was produced |
| `url`, `root_url` | Canonical URL of the submitted page and of the Store root page |
| `page_id`, `root_page_id`, `brand_id`, `browse_node` | Amazon's identifiers for the page, Store root, brand and browse node |
| `store_type`, `entity_type` | `STORE`/`HSA`/`NAV` and `BRAND`/`VENDOR` |
| `name`, `storefront_name`, `description`, `page_title` | Brand name, storefront title, Store description and HTML title |
| `country`, `country_code` | Marketplace the URL resolved to |
| `page_version`, `last_submitted_at`, `live_start_at`, `search_enabled` | Config version, last submission time, scheduled live-event start, and whether Store search is on |
| `theme`, `logo_url`, `hero_url` | Named Amazon Store theme and the two primary brand images |
| `categories` | Navigation records with name, URL, level, parent and product count |
| `products`, `product_count` | Deduplicated products merged across the Store page and its categories, plus their count |
| `images`, `videos` | Store media, one entry per asset rather than one per Amazon crop |

A product can carry `asin`, `url`, `title`, `brand`, `image_url`, `image_urls`, `video_urls`, `price`, `currency`, `display_price`, `max_price`, `offer_count`, `rating`, `review_count`, `availability`, `monthly_sales`, `badges`, `feature_bullets`, `product_type`, `display_group`, `has_variations`, `variation_asins`, `store_categories`, `store_category_urls` and `is_featured`. Products promoted on the Store page carry `is_featured: true` and often `featured_text`, so featured items stay filterable inside one list instead of duplicated into a second.

```json
{
  "processor": "https://apify.com/agentx/amazon-storefront-scraper",
  "processed_at": "2026-08-04T10:30:00+00:00",
  "url": "https://www.amazon.com/stores/page/01EFDE77-7D1A-41D7-9EEA-7C2FA22AB12F",
  "page_id": "01EFDE77-7D1A-41D7-9EEA-7C2FA22AB12F",
  "brand_id": "213704",
  "name": "Logitech",
  "store_type": "NAV",
  "entity_type": "VENDOR",
  "country_code": "US",
  "theme": "diamond",
  "categories": [
    {"name": "Featured Deals", "url": "https://www.amazon.com/stores/page/AAB3090C-DE50-4CA9-B3D4-B8D7B12E7476", "level": 2, "parent": "Logitech", "product_count": 191}
  ],
  "products": [
    {"asin": "B00ADBY97G", "title": "Logitech M317 Compact Ambidextrous 2.4 GHz Wireless Mouse - Red", "price": 18.99, "currency": "USD", "rating": 4.5, "is_featured": false}
  ],
  "product_count": 191,
  "live_start_at": null
}
```

Abbreviated to the fields under discussion; a real row carries all 28 keys. Note the classification in this sample: Amazon labels many brand-slug root pages `NAV`/`VENDOR` rather than `STORE`/`BRAND`, which is exactly why those two fields are worth reading before you treat a row as a brand-owned Store.

### Use cases

**Brand Store monitoring.** Schedule one URL and diff `name`, `theme`, `logo_url`, `hero_url`, `categories` and `product_count` over time. Because absent values are `null` rather than missing, a field that turns null is a real change, not a parsing artifact.

**Cross-market presence review.** Run the same brand's Stores on several marketplaces and compare navigation depth, assortment and media, keeping `country_code` and `processed_at` on every row.

**Competitive category research.** `categories` plus `is_featured` is a readable map of what a rival brand wants shoppers to see first.

**Creative and compliance audits.** Collect `logo_url`, `hero_url`, `images` and `videos` for a brand-consistency review, and confirm your rights before redistributing any asset.

**Lead enrichment.** A curated Brand Store says a brand invests in the channel; it says nothing about revenue, authorization or willingness to talk, so keep a human in the loop.

Choose something else for a full ASIN catalog, price history, buy-box data, seller account details, or the ability to edit a Store.

### API and integrations

The Actor ID is `agentx/amazon-storefront-scraper`. Start a run over REST and read the Dataset once the run reports `SUCCEEDED`:

```bash
curl -X POST "https://api.apify.com/v2/acts/agentx~amazon-storefront-scraper/runs?token=$APIFY_TOKEN&waitForFinish=180" \
  -H "Content-Type: application/json" \
  -d '{"store_url":"https://www.amazon.com/stores/Logitech/page/01EFDE77-7D1A-41D7-9EEA-7C2FA22AB12F"}'
```

Check terminal status and item count separately — they answer different questions. The same one-field input works from Console, Tasks, schedules, webhooks and platform integrations, and from an MCP client once an Apify MCP connection is configured:

```json
{
  "store_url": "https://www.amazon.com/stores/Logitech/page/01EFDE77-7D1A-41D7-9EEA-7C2FA22AB12F"
}
```

MCP availability depends on your account, token permissions and Actor visibility; see the [Apify MCP documentation](https://docs.apify.com/platform/integrations/mcp). Generated SDK and OpenAPI snippets are on the [API page](https://apify.com/agentx/amazon-storefront-scraper/api). Keep tokens out of repositories, Datasets and support messages.

### Pricing

Pay per event. Two events are billed.

| Event | Free | Bronze | Silver | Gold | Platinum | Diamond |
| --- | ---: | ---: | ---: | ---: | ---: | ---: |
| Actor start | $0.01000 | $0.01000 | $0.01000 | $0.01000 | $0.01000 | $0.01000 |
| Store result | $0.35000 | $0.31500 | $0.28000 | $0.26250 | $0.26250 | $0.26250 |

Actor start is charged per gigabyte of run memory, minimum one event. A successful free-tier run therefore costs **$0.01000 + $0.35000 = $0.36000** whatever the Store contains: 300 products and three products cost the same, because products are not billed. A run that finds nothing to save fails instead of writing an empty row, so it is charged the start event only. Live rates are on the Store page and can change.

### Alternatives

A general Amazon product scraper covers ASINs and offers far better than this Actor does, but it starts from a product or a search and has nothing to say about how a Store is built or which products a brand chose to feature. A general web scraper can fetch the same HTML, but the Store payload still has to be recognized and normalized downstream — that is the work this Actor removes. Amazon's own Brand Stores API is the right tool when you own the Store and want to change it; it cannot read a competitor's.

Pick this Actor when the Store page itself is the unit of analysis. Pair it with a dedicated product or price source when the products are.

### Limits and troubleshooting

One run, one Store, at most one row. `products` is the Store page's own evidence, not the brand's Amazon catalog.

**The input was rejected.** The hostname or the `/stores/.../page/{id}` path did not match. Copy the URL from the address bar rather than from a share link.

**The run failed saying Amazon has no store at that URL.** Amazon answered that the Store id does not exist, checked against Amazon's own page-not-found response and confirmed more than once before the run stops. Retired ids do not come back.

**The run failed after a long time.** Amazon was withholding the page rather than denying it. A withheld Store is retried patiently before the run gives up, which is why a blocked Store can take many minutes while a nonexistent one fails in seconds. Try again off-peak for that marketplace.

**Fields are null.** Amazon does not render every module on every Store. `null` means the Store did not expose that value on this run — not zero, not false.

**Prices and ratings look stale.** They are a snapshot of the Store page during retrieval and change with time, marketplace and shopper context.

Report anything else on the [Issues tab](https://apify.com/agentx/amazon-storefront-scraper/issues) with a sanitized Store URL, the run ID, and what you expected. Do not paste tokens.

### Frequently asked questions

**How do I scrape an Amazon brand store page?** Paste the Store page URL into `store_url` and run the Actor — that is the whole configuration. The URL must contain `/stores/`, optionally a brand slug, `/page/`, and the Store identifier.

**How do I extract products from an Amazon brand store?** They arrive in the `products` array of the single Dataset row, already deduplicated across the Store page and every category page, with `product_count` giving the total. There is no separate products run and no per-product charge.

**Does it accept Amazon product or seller URLs?** No, Brand Store page URLs only. A seller storefront and a Brand Store are different pages carrying different data.

**Can one run handle several Stores?** No. Start one run per URL and keep the URL-to-run-ID mapping on your side.

**Are all 28 fields always present?** Yes — that is the point of the fixed shape. Values Amazon did not expose are `null`, so exports stay rectangular.

**Do I need an Amazon advertiser or seller account?** No. The Actor reads public Brand Store pages only.

**Can `products` contain another brand's items?** Yes. Amazon renders recommendation and promotional cards inside Store pages, so check `brand` and `store_categories` before treating the list as the brand's own.

### Related AgentX Actors

[eBay Seller Leads API](https://apify.com/agentx/ebay-seller-leads-api) profiles the seller behind a marketplace presence when you need the account rather than the storefront. [AliExpress Product Scraper](https://apify.com/agentx/aliexpress-product-scraper) covers product-level data on a marketplace where Brand Stores do not exist. [Google Maps Store Scraper](https://apify.com/agentx/google-maps-store-scraper) adds the physical-location side of the same brand.

### Enrich your data with AgentX

[All Shopping Scraper](https://apify.com/agentx/all-shopping-scraper) widens a Store's ASIN list into cross-marketplace product data. [All Video Scraper](https://apify.com/agentx/all-video-scraper) pulls the campaign videos a Store links out to. [All Jobs Scraper](https://apify.com/agentx/all-jobs-scraper) adds the brand's hiring footprint to the same company record.

### Support

Start from the [Store page](https://apify.com/agentx/amazon-storefront-scraper), the [API page](https://apify.com/agentx/amazon-storefront-scraper/api), or the [Issues tab](https://apify.com/agentx/amazon-storefront-scraper/issues). For questions and feature requests, join the [AgentX community on Telegram](https://t.me/Apify_Actor). The full AgentX catalog is at [apify.com/agentx](https://apify.com/agentx).

[**Run a small test**](https://apify.com/agentx/amazon-storefront-scraper) · [**View API**](https://apify.com/agentx/amazon-storefront-scraper/api)

# Actor input Schema

## `store_url` (type: `string`):

Full Amazon Brand Store page URL on a supported marketplace. The path must contain `/stores/{optional-brand}/page/{store-id}`.

## Actor input object example

```json
{
  "store_url": "https://www.amazon.com/stores/Logitech/page/01EFDE77-7D1A-41D7-9EEA-7C2FA22AB12F"
}
```

# Actor output Schema

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

Open the Overview view of the default Dataset. It lists all 28 fields with the logo and hero first, then store identity, marketplace, navigation, products and media. A field Amazon does not expose on that Store is present and null.

# 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 = {
    "store_url": "https://www.amazon.com/stores/Logitech/page/01EFDE77-7D1A-41D7-9EEA-7C2FA22AB12F"
};

// Run the Actor and wait for it to finish
const run = await client.actor("agentx/amazon-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 = { "store_url": "https://www.amazon.com/stores/Logitech/page/01EFDE77-7D1A-41D7-9EEA-7C2FA22AB12F" }

# Run the Actor and wait for it to finish
run = client.actor("agentx/amazon-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 '{
  "store_url": "https://www.amazon.com/stores/Logitech/page/01EFDE77-7D1A-41D7-9EEA-7C2FA22AB12F"
}' |
apify call agentx/amazon-storefront-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

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