Amazon Store API

Amazon Store API is an amazon brand store api: send one Brand Store page URL and receive one rectangular 29-field record covering Store identity, marketplace, presentation, navigation, media and product references, with rich details when Amazon exposes them.

• A fixed record shape. All 29 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 identifies the Store root, reads the page facts Amazon publishes, enumerates category navigation, and merges ASIN references and richer ProductGrid entries from the Store and category pages into one deduplicated list.

Store facts stay flat beside categories and products, so pipelines can join one row per Store or explode products by ASIN.

store_type distinguishes a Brand Store (STORE), sponsored landing page (HSA) and navigation shell (NAV); entity_type distinguishes an Amazon-attributed brand (BRAND) from a vendor (VENDOR). These values support downstream filtering.

It is not a catalog, offer feed, price history, seller lookup, or Store management endpoint. Products reflect the page, including recommendation cards, 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/page/5EF421E8-DE42-44BD-888D-052017C90B8F"
}

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?

Each successful run returns one 29-field Store record with nested category and product collections.

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, live_end_at, search_enabled
Presentation	theme, logo_url, hero_url
Navigation	categories
Products	products, product_count
Media	images, videos

Each categories entry carries its name, URL, hierarchy and product count when the page was read. Every products entry has an ASIN and product URL plus Store-category context; title, brand, media, price, rating, availability, variations and badges are nullable ProductGrid details. Products are deduplicated by ASIN, and is_featured flags promoted items in the same list.

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.

{
  "processed_at": "2026-08-09T19:17:04-07:00",
  "url": "https://www.amazon.com/stores/page/5EF421E8-DE42-44BD-888D-052017C90B8F",
  "root_page_id": "0C475117-0B4E-4A37-8762-AD3A221283B0",
  "brand_id": "576793",
  "browse_node": 19833018011,
  "store_type": "HSA",
  "entity_type": null,
  "name": "Keychron",
  "country_code": "US",
  "search_enabled": true,
  "theme": "diamond",
  "categories": [
    {"name": "Switches & Palm Rests", "url": "https://www.amazon.com/stores/page/D0660FE3-F6C3-4C10-A337-1851164E304D", "level": 3, "parent": "ACCESSORIES", "product_count": 0}
  ],
  "products": [
    {"asin": "B07WS7KSGT", "title": "Keychron K4 Wireless Mechanical Keyboard", "price": 79.99, "currency": "USD", "rating": 4.5, "review_count": 1009, "is_featured": true}
  ],
  "product_count": 121,
  "live_start_at": null,
  "live_end_at": null
}

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

What inputs can I configure?

The complete input surface is one required store_url string and no optional fields.

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?

Use this Actor when a Store page is the business object and a stable one-row Dataset contract is more useful than raw page content.

Capability	What it gives a data team
Fixed 29-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 unique reference list with URLs for every product and nullable rich details where available
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 is a current Store-page snapshot, not a catalog, offer history or inventory. Add a product or price source for deeper ASIN analysis; use this Actor for Store presentation and change tracking.

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 real Actor ID is EjaUaJbWvT7CebygA; truefetch/amazon-store-api is the equivalent name form. Start a run over REST and read the default Dataset once it reports SUCCEEDED:

curl -X POST "https://api.apify.com/v2/acts/EjaUaJbWvT7CebygA/runs?token=$APIFY_TOKEN&waitForFinish=180" \
  -H "Content-Type: application/json" \
  -d '{"store_url":"https://www.amazon.com/stores/page/5EF421E8-DE42-44BD-888D-052017C90B8F"}'

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 YOUR_APIFY_TOKEN"
      }
    }
  }
}

Once connected, discover truefetch/amazon-store-api and call it with store_url set to https://www.amazon.com/stores/page/5EF421E8-DE42-44BD-888D-052017C90B8F. MCP availability depends on the account, token permissions and Actor visibility; see the Apify MCP documentation.

How much does Amazon Store API cost?

On the FREE tier, one Store result costs $0.20000, Actor Start costs $0.01000, and the smallest successful run totals $0.21000.

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 each nested product, so product references do not add a separate event. 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 carries the start event only. Live rates can change.

How does Amazon Store API compare with alternatives?

This Actor is best for normalizing public Brand Store pages; management APIs, product tools, and general page extraction serve different units.

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?

Most failures come from URL shape, retired Store IDs, or source-side withholding, and each has a different next step.

Rejected input. The host or /stores/.../page/{id} path did not validate. Re-copy the full browser address; short links may omit 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, while a nonexistent one fails much sooner. 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

The main decision points are credentials, one-URL scope, field semantics, scheduling, and per-Store billing.

Is there an Amazon brand store API without an advertiser account?

Yes. It reads public Brand Store pages without advertiser, seller or Ads API credentials; Amazon's own API is account-scoped.

How do I get Amazon brand store data by URL?

Pass the Store URL as store_url; the default Dataset receives one 29-field record. Over REST, POST the input and read the Dataset after 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 29 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

Three adjacent TrueFetch Actors extend this Store record into price history, company identity, or physical locations.

• 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 a brand when a Store row must join to a company.
• Google Maps Business Listing adds a 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

Last Updated: August 12, 2026