Amazon Storefront Scraper avatar

Amazon Storefront Scraper

Pricing

from $0.2625 / result

Go to Apify Store
Amazon Storefront Scraper

Amazon Storefront Scraper

Amazon Brand Store Scraper turns one public Store URL into one 29-field row with IDs, marketplace, categories, product URLs and media—no advertiser account required. Supports 10 Amazon marketplaces; rich prices and ratings appear when exposed. $0.15 per Store result plus $0.01 start.

Pricing

from $0.2625 / result

Rating

0.0

(0)

Developer

AgentX

AgentX

Maintained by Community

Actor stats

1

Bookmarked

2

Total users

1

Monthly active users

7 days ago

Last modified

Share

Amazon Storefront Scraper is an amazon brand store scraper that turns one Store page URL into a single 29-field row — Store identity, marketplace, branding, navigation, media and product references, with rich product details when Amazon exposes them.

Amazon describes Brand Stores as branded destinations built from products, dedicated pages, imagery and video; this Actor turns that public presentation into a Dataset row without advertiser credentials.

Apify Users Apify Runs $0.15 per store 10 marketplaces API + MCP ready

  • One URL in, one rectangular row out. All 29 keys appear on every row; anything Amazon does not publish is null rather than absent, so exports stay diffable.
  • Products ride along with the store. Product references from the Store and category pages arrive deduplicated by ASIN inside products; ProductGrid entries add price, rating and other rich details when Amazon exposes them.
  • Ten accepted marketplaces. Input validation recognizes amazon.com, .co.uk, .de, .fr, .it, .es, .ca, .com.au, .co.jp and .in.
  • No advertiser account or Ads API quota. The Actor reads the public Store page, so there is no Ads API credential or advertiser-owned Store restriction.

One Store costs one Actor Start plus one Result — $0.16 on the FREE tier.

Why Choose Amazon Storefront Scraper

Because two fields decide what a row means, and this Actor publishes both instead of flattening them away.

store_type separates a Brand Store from an ad page. STORE is a real Brand Store, HSA a sponsored-ad landing page, NAV a navigation shell. Scrapers that return "an Amazon page" mix all three into one dataset.

entity_type separates a brand's own store from a vendor's. BRAND and VENDOR answer who runs the storefront, which changes what a competitive comparison means.

Navigation is data, not chrome. categories carries the Store's own menu, and the products behind each entry are fetched and merged, so one row reflects the whole Store rather than its landing page.

The record stays rectangular. All 29 top-level fields remain present, with unavailable source values represented as null, so repeated Store snapshots can be compared without schema drift.

Quick Start Guide

Three steps, and the input arrives prefilled with a working Store.

Step 1: Configure

Open the Actor input and put any Brand Store page URL in store_url/stores/page/{id} or /stores/{brand}/page/{id} both resolve.

Step 2: Run

Click Start. The run reads the Store page and follows the category navigation it publishes.

Step 3: Collect

Open the default Dataset after SUCCEEDED. One run writes one Store row; inspect store_type, then use categories, products and product_count for Store analysis.

Input Parameters

One input, required, and nothing else to configure.

ParameterTypeRequiredDescriptionExample
store_urlstringYesAmazon Brand Store page URL. The path carries the store id; the domain selects which of the ten marketplaces answers.https://www.amazon.com/stores/Logitech/page/01EFDE77-7D1A-41D7-9EEA-7C2FA22AB12F
{
"store_url": "https://www.amazon.com/stores/Logitech/page/01EFDE77-7D1A-41D7-9EEA-7C2FA22AB12F"
}

Output Data Schema

One row per Store, with 29 fields in a fixed set.

GroupFields
Identityurl, root_url, page_id, root_page_id, brand_id, browse_node
Storename, storefront_name, description, page_title, store_type, entity_type
Marketplacecountry, country_code, search_enabled, page_version, last_submitted_at
Schedulelive_start_at, live_end_at
Brandingtheme, logo_url, hero_url, images, videos
Cataloguecategories, products, product_count
Provenanceprocessor, processed_at

products holds one record per deduplicated ASIN reference across the Store and category pages. Every item has its ASIN and product URL; title, media, price, rating, availability and other rich fields appear only when Amazon publishes ProductGrid details or a readable product card.

{
"url": "https://www.amazon.com/stores/page/01EFDE77-7D1A-41D7-9EEA-7C2FA22AB12F",
"root_page_id": "01EFDE77-7D1A-41D7-9EEA-7C2FA22AB12F",
"brand_id": "213704",
"name": "Logitech",
"country_code": "US",
"store_type": "NAV",
"entity_type": "VENDOR",
"categories": [
{"name": "Webcams", "level": 3, "parent": "By Category"}
],
"products": [],
"product_count": 0,
"live_start_at": null,
"live_end_at": null
}

This is an abbreviated item from the shared Logitech scenario; a real row contains all 29 top-level fields and full category, product, image and video collections. Download the Dataset as JSON, CSV, Excel, XML or RSS, or read it through the API.

Integration Examples

Amazon Storefront Scraper runs through REST, the Apify clients, Make.com, n8n and the hosted Apify MCP server with the same one-field input.

Actor ID

The real API Actor ID is:

bU0hE3ph1FYsypfx4

The name form agentx/amazon-storefront-scraper resolves to the same Actor.

HTTP

curl -X POST 'https://api.apify.com/v2/acts/bU0hE3ph1FYsypfx4/run-sync-get-dataset-items?token=YOUR_APIFY_TOKEN' \
-H 'Content-Type: application/json' \
-d '{"store_url":"https://www.amazon.com/stores/Logitech/page/01EFDE77-7D1A-41D7-9EEA-7C2FA22AB12F"}'

Python

from apify_client import ApifyClient
client = ApifyClient("YOUR_APIFY_TOKEN")
run = client.actor("bU0hE3ph1FYsypfx4").call(
run_input={
"store_url": "https://www.amazon.com/stores/Logitech/page/01EFDE77-7D1A-41D7-9EEA-7C2FA22AB12F"
}
)
items = client.dataset(run["defaultDatasetId"]).list_items().items

JavaScript

const { ApifyClient } = require('apify-client');
const client = new ApifyClient({ token: 'YOUR_APIFY_TOKEN' });
const run = await client.actor('bU0hE3ph1FYsypfx4').call({
store_url: 'https://www.amazon.com/stores/Logitech/page/01EFDE77-7D1A-41D7-9EEA-7C2FA22AB12F',
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();

Make.com

Add Apify's Run an Actor module, paste Actor ID bU0hE3ph1FYsypfx4, and map this input object:

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

Use the returned default Dataset ID in the following module when the workflow needs the 29-field Store row.

n8n

Use an HTTP Request node with POST, URL https://api.apify.com/v2/acts/bU0hE3ph1FYsypfx4/runs, Bearer authentication, and body {"store_url":"https://www.amazon.com/stores/Logitech/page/01EFDE77-7D1A-41D7-9EEA-7C2FA22AB12F"}. Poll the returned run until SUCCEEDED, then read its defaultDatasetId.

MCP

Connect an MCP client to Apify's hosted Streamable HTTP endpoint using OAuth:

{
"mcpServers": {
"apify": {
"url": "https://mcp.apify.com"
}
}
}

After connecting, use call-actor for agentx/amazon-storefront-scraper and set store_url to https://www.amazon.com/stores/Logitech/page/01EFDE77-7D1A-41D7-9EEA-7C2FA22AB12F. See the current Apify MCP documentation for OAuth and Bearer-token setup.

Pricing

On the FREE tier, each Store result costs $0.15000, Actor Start costs $0.01000, and the smallest successful run totals $0.16000.

TierActor StartStore ResultOne-store total
FREE$0.01000$0.15000$0.16000
BRONZE$0.01000$0.13500$0.14500
SILVER$0.01000$0.12000$0.13000
GOLD$0.01000$0.11250$0.12250
PLATINUM$0.01000$0.11250$0.12250
DIAMOND$0.01000$0.11250$0.12250

Actor Start is one event per gigabyte of run memory with a one-event minimum. Result billing is per Store row, so every product reference inside products is included without a separate per-product event. A one-Store run is both the smallest and typical run because the input accepts exactly one URL. Check live pricing before budgeting because prices can change.

Use Cases

The common thread is needing a brand's Amazon presentation as structured data.

  • Competitive monitoring. Track how a brand arranges its Store, what it features and how prices move, by re-running one URL on a schedule.
  • Brand audits. Confirm that a brand's Store carries the categories, media and products its marketing team believes it does.
  • Catalogue seeding. Pull a brand's ProductGrid ASINs as the starting set for deeper per-product work.
  • Marketplace comparison. Read the same brand's Store on several of the ten marketplaces and compare presentation per market.

Alternatives

Which tool fits depends on whether you have a Store URL or a search need.

  • Amazon's own Stores API — advertiser-authenticated management for Stores tied to the calling account; choose it to manage your own Store rather than read arbitrary public Stores.
  • A generic Amazon product scraper — reads search or product pages and has no notion of a Store, its navigation or its owner type.
  • Google Maps Store Scraper — the same shape of question for physical storefronts rather than Amazon ones.

Limits and Troubleshooting

Most failures come down to which page the URL points at.

  • Store ids are marketplace-specific. A US id on amazon.de redirects to keyword search; the run reports that rather than returning a row for the wrong Store.
  • A retired or mistyped id ends the run immediately with a message, because Amazon's answer is about the id and no retry changes it.
  • HSA and NAV rows are not failures. Amazon served an ad landing page or navigation shell at that identifier; filter on store_type if you only want STORE.
  • Empty engagement or media fields mean Amazon did not publish them for that Store, which is why the contract uses null rather than zero.

For a valid public URL that behaves differently, open an Issue with the run ID, sanitized URL, expected and actual behavior, and a short log excerpt. Never include an API token.

Trust and Reliability

The Actor publishes a 29-field Dataset contract, one required input, and two charged events that can be checked from the Store and API surfaces.

The pricing tab states the billed events and tier rates, while input validation enforces the ten accepted Amazon hosts before retrieval. Run history, logs and Dataset exports for your own runs remain in the Apify Console.

This Actor is not affiliated with Amazon, and reads only what a public visitor can already see on a Brand Store page.

You are responsible for how you use what it returns. Amazon's terms, copyright in product imagery and text, and the database rights in the assembled catalogue all continue to apply. The Actor reaches nothing behind a login, a paywall or an advertiser account, and does not attempt to.

Frequently Asked Questions

How do I scrape an Amazon Brand Store page?

Paste the Store page URL into store_url and start the run. The path carries the store id and the domain selects the marketplace, so nothing else is needed. One run writes one row to the default Dataset.

How do I extract products from an Amazon Brand Store?

They arrive inside the same row. products holds one deduplicated record per ASIN reference found on the Store and its category pages. Every record includes ASIN and URL; title, price, rating, media and availability are nullable because Amazon exposes those rich details only on some Store modules. product_count is the length of that list.

Do I need an Amazon advertiser or seller account?

No. The Actor reads the public Brand Store page a shopper sees, so there is no Ads API credential, no advertiser authentication and no daily quota. Amazon's own Brand Stores API is the opposite trade: contractual and quota-limited, but only for Stores the authenticated advertiser owns.

Which marketplaces are supported?

Ten: amazon.com, .co.uk, .de, .fr, .it, .es, .ca, .com.au, .co.jp and .in. Store ids are marketplace-specific — a US id on amazon.de redirects to keyword search rather than resolving, which the Actor reports instead of returning a wrong row.

What is the difference between STORE, HSA and NAV?

store_type says what Amazon served. STORE is a real Brand Store, HSA a sponsored-ad landing page and NAV a bare navigation shell. All three are valid rows; filter on the field if only genuine Brand Stores belong in your dataset.

Why is a field null rather than missing?

Every row carries all 29 keys. Omitting them would make exports ragged and turn "Amazon stopped publishing this" into something indistinguishable from a parsing gap. A null is a statement about the source, not about the run.

Is there a free Amazon Brand Store API?

Not from Amazon: its Brand Stores API requires an advertiser account. This Actor needs no such account and bills per Store returned, so a single lookup costs $0.16 on the FREE tier rather than a subscription.

Can I schedule runs to monitor an Amazon Brand Store over time?

Yes. Re-run the same URL on a schedule, keep every processed_at, and diff Store-level fields between runs. Compare only identical URLs within one marketplace, since presentation differs per market.

AgentX publishes 79 Actors: the three closest options appear first, followed by the complete 78-Actor catalog grouped by category.

Closest to this Actor:

Business and Market Intelligence

Jobs and Hiring

Social Media

Video, Transcripts and Downloads

E-Commerce and Retail

Classifieds and Automotive

Real Estate

Support and Community

Ask about fields, runs or billing in the AgentX community on Telegram; for a reproducible bug, open an Issue with the run ID and the exact input.

AgentX is an Arcyton brand — arcyton.com.

Last Updated: August 12, 2026