# Amazon Store API (`truefetch/amazon-store-api`) Actor

Amazon Brand Store API 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.20 per Store result plus $0.01 start.

- **URL**: https://apify.com/truefetch/amazon-store-api.md
- **Developed by:** [TrueFetch](https://apify.com/truefetch) (community)
- **Categories:** E-commerce, Automation, Integrations
- **Features:** Limited permissions
- **Stats:** 50 total users, 1 monthly users, 100.0% runs succeeded, 3 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $0.15 / 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/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## 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.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## 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**](https://apify.com/truefetch/amazon-store-api) · [**View API**](https://apify.com/truefetch/amazon-store-api/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](https://advertising.amazon.com/solutions/products/stores) 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.

```json
{
  "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 `isFeatured` 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.

```json
{
  "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,
      "reviewCount": 1009,
      "isFeatured": 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`:

```bash
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](https://apify.com/truefetch/amazon-store-api/api).

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

```json
{
  "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](https://docs.apify.com/integrations/mcp).

### 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](https://apify.com/truefetch/amazon-store-api/pricing) 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](https://advertising.amazon.com/API/docs/en-us/reference/2/stores) 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 `storeCategories` 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](https://apify.com/truefetch/amazon-store-api/issues) 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](https://apify.com/truefetch/amazon-price-tracker) follows an ASIN's price over time — the dimension this Store-level record deliberately omits.
- [LinkedIn Company API](https://apify.com/truefetch/linkedin-company-api) resolves the corporate entity behind a brand when a Store row must join to a company.
- [Google Maps Business Listing](https://apify.com/truefetch/google-maps-business-listing) adds a brand's physical-location footprint to the same company record.

### Support

The [Store page](https://apify.com/truefetch/amazon-store-api) carries live pricing and the current input schema, the [API page](https://apify.com/truefetch/amazon-store-api/api) carries generated clients and the OpenAPI definition, and the [Issues tab](https://apify.com/truefetch/amazon-store-api/issues) takes reproducible bug reports. For questions and feature requests, join the [TrueFetch group on Telegram](https://t.me/TrueFetch).

[**Run a one-result test**](https://apify.com/truefetch/amazon-store-api) · [**View API**](https://apify.com/truefetch/amazon-store-api/api)

**Last Updated:** August 12, 2026

# Actor input Schema

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

Link to an Amazon Brand Store page. The path carries the Store ID — `/stores/page/{id}` or `/stores/{brand}/page/{id}` — and the domain selects one of 10 supported marketplaces.

## Actor input object example

```json
{
  "store_url": "https://www.amazon.com/stores/page/5EF421E8-DE42-44BD-888D-052017C90B8F"
}
```

# Actor output Schema

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

Open the Overview view of the default Dataset. It lists all 29 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/page/5EF421E8-DE42-44BD-888D-052017C90B8F"
};

// Run the Actor and wait for it to finish
const run = await client.actor("truefetch/amazon-store-api").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/page/5EF421E8-DE42-44BD-888D-052017C90B8F" }

# Run the Actor and wait for it to finish
run = client.actor("truefetch/amazon-store-api").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).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/page/5EF421E8-DE42-44BD-888D-052017C90B8F"
}' |
apify call truefetch/amazon-store-api --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,truefetch/amazon-store-api"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

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