Amazon Store API

Amazon Brand Store API for developers and data teams: send one Brand Store page URL, receive one rectangular 28-field record covering Store identity, marketplace, page presentation, navigation, media and the ProductGrid products Amazon renders on that Store.

• A fixed record shape. All 28 keys appear on every row; anything Amazon did not expose is null, so exports stay rectangular and diffable.
• No advertiser or seller credentials. Public Brand Store pages only, read-only.
• 10 marketplaces validated at the input. amazon.com, .ca, .co.uk, .de, .fr, .it, .es, .co.jp, .com.au, .in — an unsupported host is rejected before a request leaves.
• Billing predictable from the input. One URL, at most one row, one result event, however many products the Store carries.

Run a one-result test · View API

The smallest useful run is one Store URL: on the free tier its whole cost is one Actor start plus one result — $0.21000 — with no per-product component to estimate.

What does Amazon Store API do?

It resolves one Amazon Brand Store page into a single normalized record. Given a URL of the form /stores/{optional-brand}/page/{store-id}, it canonicalizes the address, identifies the Store root behind it, reads the identifiers and configuration Amazon attaches to the page, enumerates the published category navigation, and merges the ProductGrid entries from the Store page and every category page into one ASIN-keyed deduplicated list.

The record is deliberately flat. Store-level facts sit beside two nested collections, categories and products, so a pipeline can join at Store level without unpacking them, or explode products when it needs ASIN granularity.

Two classification fields decide whether a row belongs in your analysis at all. store_type distinguishes a genuine Brand Store (STORE) from a sponsored-ad landing page (HSA) and a navigation-only shell (NAV); entity_type reports whether Amazon attributes the Store to a brand owner (BRAND) or a vendor (VENDOR). Both come straight from Amazon's page configuration.

Anti-definition: this is not a product catalog API, an offer or buy-box feed, a price history, a seller-account lookup, or a Store management endpoint. The products collection is page evidence, and Amazon may render recommendation cards inside Store layouts, so brand attribution belongs downstream.

How do I run Amazon Store API?

1. Copy the Store address from the browser, keeping the /stores/ prefix, any brand slug, /page/, and the Store identifier.
2. Put that string in store_url — the only input — and start the run.
3. Wait for a terminal status. One run consumes one URL and writes at most one item; limits are per run, not per product.
4. Read the default Dataset and branch on store_type first.

{
  "store_url": "https://www.amazon.com/stores/Anker/page/D24FDA17-DECF-46BB-AF47-AF4647D2B1F8"
}

Anything that is not a Brand Store page — a /dp/ product URL, a seller profile, a search result, a short vanity link — is rejected during validation with a message stating the accepted shape.

What data does Amazon Store API return?

Field group	Keys
Provenance	processor, processed_at
Addresses	url, root_url
Identifiers	page_id, root_page_id, brand_id, browse_node
Classification	store_type, entity_type
Naming and copy	name, storefront_name, description, page_title
Market	country, country_code
Page state	page_version, last_submitted_at, live_start_at, search_enabled
Presentation	theme, logo_url, hero_url
Navigation	categories
Products	products, product_count
Media	images, videos

Each entry in categories carries name, url, level, parent and product_count. Each entry in products 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, is_featured and featured_text. Promoted products are flagged with is_featured inside the same list rather than repeated in a parallel array, so one pass over products sees every item exactly once.

Media is collapsed to one entry per asset: Amazon serves the same picture under many crop and size renditions, and images keeps the plainest of each.

{
  "processor": "https://apify.com/truefetch/amazon-store-api",
  "processed_at": "2026-08-04T10:30:00+00:00",
  "url": "https://www.amazon.com/stores/page/D24FDA17-DECF-46BB-AF47-AF4647D2B1F8",
  "root_page_id": "D24FDA17-DECF-46BB-AF47-AF4647D2B1F8",
  "brand_id": "3271",
  "browse_node": 2528932011,
  "store_type": "NAV",
  "entity_type": "BRAND",
  "name": "Anker",
  "country_code": "US",
  "search_enabled": true,
  "theme": "diamond",
  "categories": [
    {"name": "USB-A Hubs", "url": "https://www.amazon.com/stores/page/800BB68A-C3C7-48D5-AB29-B489C02A9715", "level": 3, "parent": "All Hubs&Docks", "product_count": 4}
  ],
  "products": [
    {"asin": "B006T9B6R2", "title": "Anker USB 3.0 Micro SD Card Reader", "price": 8.99, "currency": "USD", "rating": 4.6, "review_count": 45322, "is_featured": false}
  ],
  "product_count": 48,
  "live_start_at": null
}

Abbreviated for readability; a live row carries all 28 keys, with unavailable source values present and null.

What inputs can I configure?

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

That is the complete public input surface — one required string, no optional fields, no result caps, no proxy or country selector. The scheme must be http or https, the host must match a supported marketplace exactly, and the path must contain the Brand Store page pattern; a hostname that merely contains the substring "amazon" does not qualify.

With no batch input, a monitored list becomes one run per URL. Keep your own URL-to-run-ID mapping and set a maximum total charge where the calling surface offers one.

What platforms and markets does Amazon Store API cover?

Ten Amazon marketplaces are accepted at validation time: the United States, Canada, the United Kingdom, Germany, France, Italy, Spain, Japan, Australia and India, each with and without the www prefix. The resolved market is echoed back on every row as country and country_code, and language and currency preferences follow it.

Coverage here means host acceptance, not brand availability. A brand may run a Store in three of those markets and none of the rest, and the same brand's Stores in different markets have different identifiers, navigation depth, assortments and media. Cross-market work should compare like-for-like URLs and keep country_code and processed_at on every record.

Within a marketplace, scope is the Brand Store surface: Store pages and the category pages their own navigation exposes. Product detail pages, search results, seller profiles, influencer storefronts and anything behind Seller Central are outside it.

Why use Amazon Store API?

Capability	What it gives a data team
Fixed 28-key record with explicit nulls	Schema-stable loads and honest diffs: a null is a signal, not a missing column
One URL in, one row out	Run accounting that matches business objects one-to-one
ASIN-level dedupe across Store and category pages	A product list that is already unique, so joins do not double-count
store_type and entity_type from Amazon's own config	A cheap filter keeping ad landing pages and vendor shells out of brand-owned analysis
Dataset, REST, schedules, webhooks and MCP on one input	The same contract from Console, a pipeline, or an AI client

The trade-off is scope: this returns a current Store-page snapshot, not a catalog, offer history or inventory. Pair it with a dedicated product or price source when the question is what a brand sells and at what price; use it alone when the question is how a brand presents itself on Amazon and how that is changing.

Who is Amazon Store API for?

Developers and data teams building brand-monitoring or enrichment pipelines are the primary audience: the fixed record shape and single-input contract are cheap to schedule and trivial to model. Analysts track how a Store's identity, theme, navigation and featured selection shift between reviews; competitive-research teams compare Store architecture across rival brands in one marketplace; agencies verify that campaign landing destinations still look the way the campaign assumed.

It is a poor fit if you need a full ASIN catalog, historical pricing, buy-box or seller metrics, or write access to a Store — and the wrong tool for automated high-stakes decisions about a company, since a polished Store demonstrates channel investment and nothing about revenue, authorization or intent.

How can I use Amazon Store API through the API or MCP?

The Actor ID is truefetch/amazon-store-api. Start a run over REST and read the default Dataset once the run reports SUCCEEDED:

curl -X POST "https://api.apify.com/v2/acts/truefetch~amazon-store-api/runs?token=$APIFY_TOKEN&waitForFinish=180" \
  -H "Content-Type: application/json" \
  -d '{"store_url":"https://www.amazon.com/stores/Anker/page/D24FDA17-DECF-46BB-AF47-AF4647D2B1F8"}'

Terminal status and Dataset item count answer different questions; check both. Generated SDK snippets and the OpenAPI definition are on the API page.

Apify's hosted MCP endpoint uses Streamable HTTP. Use OAuth, or an authorization header holding a token kept outside source control:

{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com",
      "headers": {
        "Authorization": "Bearer <APIFY_TOKEN>"
      }
    }
  }
}

Once connected, discover truefetch/amazon-store-api and call it with the same single-field argument. MCP availability depends on the account, token permissions and Actor visibility; refresh the schema before relying on it, and see the Apify MCP documentation.

How much does Amazon Store API cost?

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.20000	$0.18000	$0.16000	$0.15000	$0.15000	$0.15000

Actor start is charged per gigabyte of run memory with a one-event minimum. The billing unit for data is the Store record, not the product, so a Store with 300 products and a Store with three cost the same. The smallest useful run — one URL, one record — therefore costs $0.01000 + $0.20000 = $0.21000 on the free tier. A run that cannot produce a record fails rather than writing an empty row, so it carries the start event only. Live rates are on the Store page and can change.

How does Amazon Store API compare with alternatives?

Amazon's own Stores API authenticates as an advertiser and is scoped to Stores registered to the calling account: right for managing your own Store, structurally unable to read anyone else's. A general Amazon product scraper is stronger on ASIN depth, offers and reviews, but starts from a product or a query and never describes the Store as an object. A generic HTML scraper retrieves the same pages, but the Store configuration still has to be located, parsed and deduplicated before it becomes a row — that normalization is what you are buying here.

Choose this when the Brand Store page is the unit of analysis; choose one of the others when products, prices or ownership are.

What are the limits and troubleshooting steps?

Rejected input. The host or the /stores/.../page/{id} path did not validate. Re-copy from the browser address bar; share links and shortened URLs frequently drop the page segment.

Run fails saying Amazon has no store at that URL. Amazon returned its own page-not-found response for that identifier, confirmed more than once before the run stops. Retired identifiers do not recover.

Run fails after a long wait. Amazon withheld the page rather than denying it. A withheld Store is retried before the run gives up, so a blocked Store can occupy several minutes while a nonexistent one fails almost immediately. Retry off-peak for that marketplace.

Null fields. Amazon does not render every module on every Store. A null means the value was not exposed on this run — not zero, false, or an error.

Unexpected ASINs in products. Amazon renders recommendation cards within Store layouts; filter on brand and store_categories before joining to a catalog.

Volatile values. Prices, ratings, availability and media URLs reflect the retrieval moment, and media links can expire.

Report anything else on the Issues tab with a sanitized URL, the run ID, expected and actual behaviour, and a short log excerpt. Never include tokens.

Frequently asked questions

Is there an Amazon brand store API without an advertiser account? Yes — this Actor is one. It reads public Brand Store pages and needs no Amazon advertiser, seller or Ads API credentials, whereas Amazon's own Brand Stores API only reaches Stores the authenticated advertiser owns.

How do I get Amazon brand store data by URL? Pass the Store page URL as store_url and start a run; the default Dataset then holds one record with all 28 fields. Over REST that is one POST to the run endpoint with that single-field body, then a Dataset read once the run reports SUCCEEDED.

Can one run process several Store URLs? No. The input accepts exactly one URL and each run writes at most one record, so fan out on your side.

Why is a field null instead of absent? Every row carries all 28 keys by design. Omitting keys would make exports ragged and turn "Amazon stopped exposing this" into an indistinguishable parsing gap.

Is product_count the brand's full catalog size? No. It counts the deduplicated records assembled from the Store page and its category pages — a Store-presentation figure, not a catalog figure.

Does a NAV or HSA value mean the run failed? No. Amazon served a navigation shell or a sponsored landing page at that identifier. The record is valid; filter on store_type if only genuine Brand Stores belong in your dataset.

Can I schedule change tracking? Yes. Repeat runs on the same URL, keep every processed_at, and diff Store-level fields, comparing only identical URLs within one marketplace.

Related TrueFetch Actors

Amazon Price Tracker follows an ASIN's price over time — the dimension this Store-level record deliberately omits. LinkedIn Company API resolves the corporate entity behind the brand when a Store record has to be joined to a company rather than to a catalogue. Google Maps Business Listing attaches the brand's physical-location footprint to the same company record.

Support

The Store page carries live pricing and the current input schema, the API page carries generated clients and the OpenAPI definition, and the Issues tab takes reproducible bug reports. For questions and feature requests, join the TrueFetch group on Telegram.

Run a one-result test · View API