Amazon Bestsellers Scraper By Category

Amazon Scraper — Extract Rankings, Categories and Product Details

Amazon Bestsellers Scraper By Category pulls the ranked product list from any Amazon Best Sellers category page, then recurses the left-nav subcategory tree into the full browse-node category graph — node IDs, parent links, depth, and per-node product counts included. Unlike scraping frameworks that return raw HTML, Amazon Bestsellers Scraper By Category returns typed JSON, with every product already tagged with its categoryPath, ready for your model, your database, or your pipeline without any parsing. This guide covers every input and output field and how teams deploy it for taxonomy building, price and rank monitoring, and bulk catalogue datasets.

🧭 What Does Amazon Bestsellers Scraper By Category Do?

Amazon Bestsellers Scraper By Category takes one or more Amazon Best Sellers category URLs and returns two things in the same dataset: ranked best-seller products (name, ASIN, price, rating, review count) and the category / browse-node tree those products sit inside (node ID, parent node, depth, product count). No Amazon account, login, or API key is required — it reads the public Best Sellers HTML directly. Every row carries a type field ("product" or "category") so both fit in one dataset and are trivial to split.

• Extracts ranked best-seller products per category, with price, star rating, review count, and thumbnail
• Recurses the Best Sellers left-nav into the full category / browse-node graph, up to a configurable depth
• Resolves the numeric Amazon nodeId from each category URL, never fabricating one when only a text slug is present
• Links every category node to its parent via parentNode, so the graph can be rebuilt
• Tags every product with an ordered categoryPath — the chain of categories leading to it
• Optionally attaches an extended per-product details block (offer count, parsed price, thumbnail)
• Optionally runs extra retries against Amazon's Robot Check / captcha block

⚡ Features & Capabilities

Capabilities split into three areas: what gets extracted, what the output looks like, and where this Actor sits relative to other Scrapio Amazon tools.

Core features

• Best-seller product extraction — for every category URL, returns the ranked list with name, url, asin, position, price (value/currency), numberOfOffers, stars, reviewsCount, thumbnailUrl
• Category / browse-node tree discovery — walks the zg subcategory navigation up to treeDepth levels, emitting one {type: "category", categoryName, categoryUrl, nodeId, parentNode, depth, productCount} record per node
• categoryPath on every product — an ordered array of {categoryName, categoryUrl, nodeId, depth} from the root category down to where the product was found
• Configurable product depth vs. tree depth — productSubcategoryLevels controls how deep PRODUCTS are scraped; treeDepth controls how many levels of the CATEGORY GRAPH are discovered, independently
• Extended per-product details — when includeExtendedProductDetails is on, each product gets a detailedInformation block with parsed priceValue, currency, numberOfOffers, stars, reviewsCount, thumbnailUrl, and detailPageUrl
• Per-run category dataset mirror — discovered category nodes are also written to a separate categories-<runId> dataset for taxonomy-only consumers
• Row-level tagging — every row carries type (product/category) and isChild, so mixed output stays queryable in place

Amazon Bestsellers Scraper By Category within the Scrapio data stack

Amazon Bestsellers Scraper By Category covers Best Sellers rankings and the category tree. For live Amazon search-results pages by keyword, use amazon-search-products-scraper. For seller/storefront-level data, use amazon-seller-data-extractor. Together these cover ranking discovery, keyword search, and seller-side data without overlapping scope, so a category-taxonomy pipeline and a competitor-seller pipeline can run as separate, focused jobs instead of one overloaded Actor.

Why do developers and data teams scrape Amazon?

🏢 Category managers, brand teams and marketplace sellers

A brand or category manager feeds in the Best Sellers URLs for the categories they compete in, runs with outputCategoryTree on, and gets back both the current ranking (position, price.value, stars, reviewsCount) for every competing ASIN and the exact subcategory (categoryPath) each one ranks under. That output lands in a spreadsheet or BI tool to track where a brand's own SKUs rank against the category, which subcategories carry the most competing products (productCount per node), and where a new SKU could enter with less competition. Marketplace sellers use the same run to decide which subcategory to list a new product under before it goes live.

📊 AI training data and RAG indexing

name, categoryFullName, and categoryPath are the highest-information text fields for AI use: they describe the product and its exact place in Amazon's taxonomy in natural language, not just a numeric ID. For RAG enrichment, indexing name + categoryFullName + categoryPath lets a retrieval layer answer "what ranks under Best Sellers in Headphones" with grounded, current data instead of a stale model prior. For training data, price, stars, reviewsCount, and productCount are structured numeric fields with a consistent shape across every row, useful for building ranking or price-prediction datasets without a separate normalization pass.

📱 Competitive and market intelligence

Re-running the same categoryTreeRootUrls on a schedule turns position and price.value into a time series per asin — the metric worth tracking is rank movement (a competitor's ASIN climbing from position: 40 to position: 8) and price changes on the same ASIN across runs. productCount per category node is a second signal: a node whose count is growing run over run indicates a subcategory attracting more competing listings.

🔬 Research and academic use

The category graph (nodeId, parentNode, depth) and the ranked product list are both public-page data, useful for academic work on marketplace structure, category concentration, or ranking dynamics. Scope is limited to what Amazon's Best Sellers pages expose publicly — no account-gated or private seller data is collected.

🎥 Product and SaaS development

The typed output is a direct fit for building a category-explorer tool, a price/rank-tracking dashboard, or an enrichment API that resolves an Amazon category URL into its full node graph. Because nodeId/parentNode reconstruct the graph deterministically, a product built on this data doesn't need its own category-taxonomy logic.

🍚 Input Parameters

The Actor takes one array input (the category root URLs) plus scraping-depth, tree-depth, and anti-blocking options, read directly from .actor/input_schema.json. Nothing is required — an empty run simply logs a warning and exits.

Parameter	Required	Type	Description	Example Value
categoryTreeRootUrls	No	array (string list)	Amazon Best Sellers category page URLs. Each one becomes a ROOT of the browse-node/category tree this scraper walks.	["https://www.amazon.com/Best-Sellers-Electronics/zgbs/electronics/"]
maxProductsPerRoot	No	integer (min 1, max 500)	Maximum best-seller products to pull per root category URL. Category-tree nodes are extra and are NOT counted against this cap.	100
productSubcategoryLevels	No	integer (min 1)	How deep to pull PRODUCTS: 1 = root category only, 2+ = also harvest products from the direct subcategories.	2
outputCategoryTree	No	boolean (default true)	Emit category-node records {type:"category", categoryName, categoryUrl, nodeId, parentNode, depth, productCount}. Turn OFF for a products-only run.	true
treeDepth	No	integer (min 1, max 6, default 1)	How many levels of the category graph to discover. 1 = start category + its direct subcategories, 2 = also grandchildren, etc.	2
storefrontLanguage	No	string (enum, select)	Preferred Amazon storefront language. Each Amazon domain supports a different language set; unsupported choices fall back to the domain default.	"en"
includeExtendedProductDetails	No	boolean	Attach an extra per-product details block (offer count, parsed price value/currency, thumbnail) when available.	true
solveBlockingCaptchas	No	boolean	When Amazon shows a Robot Check / captcha, run extra solver retries to get past the block (may incur extra cost).	false
crawlProxyConfiguration	No	object (proxy editor, default {"useApifyProxy": false})	Proxy settings for the crawl. Default is DIRECT. Use residential proxies if Amazon soft-blocks the datacenter IP.	{"useApifyProxy": true, "apifyProxyGroups": ["RESIDENTIAL"]}

{
  "categoryTreeRootUrls": ["https://www.amazon.com/Best-Sellers-Electronics/zgbs/electronics/"],
  "maxProductsPerRoot": 100,
  "productSubcategoryLevels": 2,
  "outputCategoryTree": true,
  "treeDepth": 2,
  "storefrontLanguage": "en",
  "includeExtendedProductDetails": true,
  "solveBlockingCaptchas": false,
  "crawlProxyConfiguration": { "useApifyProxy": true, "apifyProxyGroups": ["RESIDENTIAL"] }
}

Supported URL types and input formats

categoryTreeRootUrls accepts any URL where "best-sellers", "bestsellers", or "zgbs" appears in the string (case-insensitive); anything else is skipped with a warning rather than passed through. List entries can be plain strings or {"url": "..."} objects.

• https://www.amazon.com/Best-Sellers-Electronics/zgbs/electronics/ — canonical /zgbs/ form; the most consistently parsed layout for name/price/stars
• https://www.amazon.com/gp/bestsellers/photo/281052/ — numeric-node /gp/bestsellers/ form; some faceout layouts on this form return null for name/price while asin/stars/reviewsCount still populate
• https://www.amazon.co.uk/Best-Sellers-Kitchen/zgbs/kitchen/ — non-US storefront; combine with storefrontLanguage where the domain supports it

📦 Output Format

Each run pushes a flat stream of typed JSON rows to the default dataset — a mix of type: "product" and type: "category" records, distinguished by the type and isChild fields. Fields stay consistent across runs; there is no separate schema per category. Results are available through the Apify Console table view, the API/SDK dataset endpoints, and Console's built-in CSV/JSON/Excel/XML export.

Output for Bestseller Products

{
  "name": "Wireless Bluetooth Earbuds with Charging Case",
  "url": "https://www.amazon.com/dp/B0EXAMPLE1",
  "asin": "B0EXAMPLE1",
  "position": 1,
  "price": { "value": 24.99, "currency": "$" },
  "numberOfOffers": 5,
  "stars": 4.4,
  "reviewsCount": 18320,
  "thumbnailUrl": "https://m.media-amazon.com/images/I/example._SL300_.jpg",
  "categoryName": "Electronics",
  "categoryFullName": "Best Sellers in Electronics",
  "subcategories": [
    { "categoryName": "Headphones", "categoryUrl": "https://www.amazon.com/gp/bestsellers/electronics/172541/", "nodeId": "172541" }
  ],
  "categoryUrl": "https://www.amazon.com/Best-Sellers-Electronics/zgbs/electronics/",
  "input": "https://www.amazon.com/Best-Sellers-Electronics/zgbs/electronics/",
  "type": "product",
  "isChild": false,
  "depth": 0,
  "categoryPath": [
    { "categoryName": "Electronics", "categoryUrl": "https://www.amazon.com/Best-Sellers-Electronics/zgbs/electronics/", "nodeId": "172282", "depth": 0 }
  ],
  "detailedInformation": {
    "priceValue": 24.99,
    "currency": "$",
    "numberOfOffers": 5,
    "stars": 4.4,
    "reviewsCount": 18320,
    "thumbnailUrl": "https://m.media-amazon.com/images/I/example._SL300_.jpg",
    "detailPageUrl": "https://www.amazon.com/dp/B0EXAMPLE1"
  },
  "scrapedAt": "2026-07-25T09:00:00Z"
}

detailedInformation is null unless includeExtendedProductDetails is on. The default dataset table view surfaces 19 of these keys; numberOfOffers, categoryFullName, subcategories, and detailedInformation are pushed on every product row but not shown in the default view — open the row in the Console or read the API/SDK response to see them.

Output for Category Tree Nodes

{
  "type": "category",
  "isChild": true,
  "categoryName": "Headphones",
  "categoryUrl": "https://www.amazon.com/gp/bestsellers/electronics/172541/",
  "nodeId": "172541",
  "parentNode": "172282",
  "depth": 1,
  "productCount": 30,
  "categoryPath": [],
  "input": "https://www.amazon.com/Best-Sellers-Electronics/zgbs/electronics/",
  "scrapedAt": "2026-07-25T09:00:05Z"
}

productCount reflects the faceout cards found on that node's first page — a coverage signal, not the category's full catalogue size. nodeId is null when a category exposes only a text slug and no numeric browse-node id; the Actor never fabricates one.

Schema stability and export options

Field names are stable across runs and independent of Amazon front-end changes to page layout — the parser targets the underlying HTML structure, and a selector miss returns null rather than a renamed or dropped field. If migrating from the base Amazon Best Sellers scraper, its input keys (categoryUrls, maxResults, subcategoryDepth, language, proxyConfiguration) are still accepted automatically as fallbacks. Export options are whatever the Apify platform provides for any dataset: JSON, CSV, Excel, XML, or RSS from the Console, or programmatic retrieval via the API/SDK.

💡 Amazon Bestsellers Scraper By Category Strategy Guide

🎯 Strategy 1: Real-time enrichment pipeline

Trigger a run per inbound category URL (a new SKU launch, a category a seller just entered) with outputCategoryTree off for speed and productSubcategoryLevels: 1. Take the pushed position, price.value, stars, and reviewsCount for the target asin and append them to the record in your PIM, CRM, or pricing engine. Because every row already carries categoryPath, no separate lookup is needed to know which subcategory the rank applies to before writing back.

🎯 Strategy 2: Scheduled monitoring and alerting

Set up a recurring run on an Apify Console schedule (cron expression) against the same categoryTreeRootUrls. Each run's rows are keyed by asin (products) or nodeId (category nodes); diff the new run's position and price.value against the previous run's dataset and alert when a tracked ASIN's position moves past a threshold or its price.value changes. For category-level drift, diff productCount per nodeId to catch a subcategory gaining competing listings.

🎯 Strategy 3: Bulk dataset build

Feed a list of root Best Sellers URLs across every department you need coverage for, run them (the Actor already parallelizes root URLs within one run via asyncio.gather), and aggregate the resulting dataset to CSV or a database table. Use type: "category" rows plus nodeId/parentNode to reconstruct the full taxonomy, and type: "product" rows for the catalogue itself. treeDepth and the Actor's internal per-root node cap bound how large a single root's tree can grow, so size treeDepth to the coverage you actually need before fanning out to many roots.

Strategy comparison at a glance

Strategy	Best for	Run pattern	Output format
Real-time enrichment	Single-category or single-ASIN lookups feeding an app	One on-demand run per trigger	JSON via API/SDK or dataset
Scheduled monitoring	Rank and price tracking over time	Apify Console schedule (cron), run-over-run diff	Dataset compared across runs
Bulk dataset build	Full taxonomy or multi-department catalogue datasets	Parallel root URLs in one run	CSV/JSON export

🌴 Related Amazon Scrapers & Tools

Scraper Name	What it extracts
amazon-search-products-scraper	Amazon search-results pages by keyword — product listings outside the Best Sellers rankings
amazon-seller-data-extractor	Amazon seller/storefront-level data
extract-emails-contacts-socials-from-any-website-verified-phone-email-list	Emails, phone numbers, and social links from any site URL — useful for enriching a seller or brand storefront once you have its URL

How to integrate Amazon Bestsellers Scraper By Category with your stack

Amazon Bestsellers Scraper By Category works with any language or tool that can call the Apify API — there is no separate scraper-specific API surface, only the standard Apify run/dataset endpoints.

Python

import csv
from apify_client import ApifyClient

client = ApifyClient("<APIFY_API_TOKEN>")

run_input = {
    "categoryTreeRootUrls": [
        "https://www.amazon.com/Best-Sellers-Electronics/zgbs/electronics/",
        "https://www.amazon.com/Best-Sellers-Toys-Games/zgbs/toys-and-games/",
    ],
    "maxProductsPerRoot": 100,
    "productSubcategoryLevels": 2,
    "outputCategoryTree": True,
    "treeDepth": 2,
    "crawlProxyConfiguration": {"useApifyProxy": True, "apifyProxyGroups": ["RESIDENTIAL"]},
}

run = client.actor("Scrapio/amazon-bestsellers-scraper-by-category").call(run_input=run_input)
rows = list(client.dataset(run["defaultDatasetId"]).iterate_items())
products = [r for r in rows if r.get("type") == "product"]

with open("bestsellers.csv", "w", newline="", encoding="utf-8") as f:
    writer = csv.DictWriter(f, fieldnames=["asin", "name", "position", "price", "stars", "reviewsCount", "categoryFullName"])
    writer.writeheader()
    for p in products:
        writer.writerow({
            "asin": p.get("asin"),
            "name": p.get("name"),
            "position": p.get("position"),
            "price": (p.get("price") or {}).get("value"),
            "stars": p.get("stars"),
            "reviewsCount": p.get("reviewsCount"),
            "categoryFullName": p.get("categoryFullName"),
        })

print(f"Saved {len(products)} products to bestsellers.csv")

Node.js

import { ApifyClient } from 'apify-client';
import fs from 'fs';

const client = new ApifyClient({ token: '<APIFY_API_TOKEN>' });

const input = {
    categoryTreeRootUrls: ['https://www.amazon.com/Best-Sellers-Electronics/zgbs/electronics/'],
    maxProductsPerRoot: 100,
    productSubcategoryLevels: 2,
    outputCategoryTree: true,
    treeDepth: 2,
};

const run = await client.actor('Scrapio/amazon-bestsellers-scraper-by-category').call(input);
const { items } = await client.dataset(run.defaultDatasetId).listItems();

const products = items.filter((row) => row.type === 'product');
const categories = items.filter((row) => row.type === 'category');

fs.writeFileSync('bestsellers.json', JSON.stringify(products, null, 2));
console.log(`Saved ${products.length} products, discovered ${categories.length} category nodes`);

Async and scheduled pipelines

For large or recurring jobs, start the run via API/SDK and poll client.run(runId).get() (or client.dataset(datasetId).listItems()) until it finishes instead of holding a connection open, or set up an Apify Console schedule for recurring category-tree refreshes. Console can also fire a webhook on run success/failure for external systems that need a push notification rather than polling.

🎯 Who Needs Amazon Bestsellers Scraper By Category? (Use Cases & Industries)

🏢 Category managers and marketplace sellers

A seller entering a new subcategory pulls the current position, price.value, and reviewsCount for every competing ASIN plus the exact categoryPath to decide where to list and how to price against the field.

📊 AI/ML and RAG teams

Teams building a shopping assistant or product-recommendation model index name, categoryFullName, and categoryPath as grounded, current text, paired with the structured price/stars/reviewsCount fields for ranking signals.

📱 Competitive intelligence analysts

Analysts track position and price.value for a fixed watchlist of ASINs across scheduled runs, and use productCount per nodeId to see which subcategories are gaining or losing competing listings over time.

🔬 Researchers

Academic and market researchers use the category graph (nodeId, parentNode, depth) and ranked product data to study marketplace structure and category concentration, scoped to what Amazon's Best Sellers pages expose publicly.

Is it legal to scrape Amazon?

Scraping publicly accessible web pages, including Amazon's Best Sellers pages, is generally lawful in the US — courts have distinguished accessing public data from unauthorized computer access under the CFAA, notably in hiQ Labs, Inc. v. LinkedIn Corp. (9th Cir. 2019). That precedent does not eliminate risk under Amazon's own Terms of Service: scraping in violation of a platform's ToS can create civil contract liability even where it isn't a CFAA violation. This Actor returns only publicly accessible catalogue data — product names, prices, ratings, review counts, and category structure — with no personal or account-gated data involved, so data protection frameworks like GDPR do not apply to its output. Amazon Bestsellers Scraper By Category returns only publicly accessible data. What you do with that data is your responsibility — consult legal counsel for commercial applications.

❓ Frequently asked questions

Does Amazon Bestsellers Scraper By Category work without an Amazon account?

Yes. It reads public Best Sellers HTML pages over plain HTTP requests with a standard browser user agent — no Amazon login, cookies, or API key are used or required.

How does it handle Amazon's anti-scraping measures?

It detects Amazon's "Robot Check" / blocked-page text and retries (3 attempts by default). When solveBlockingCaptchas is on, it adds 3 extra retries (6 total) with longer backoff before giving up on a page. It also supports routing the crawl through a proxy via crawlProxyConfiguration.

Can I run it at scale without getting blocked?

Direct/datacenter requests can get blocked on Amazon; a residential proxy configuration is recommended for larger or deeper-tree runs. The category-tree crawl is internally capped per root URL so a large treeDepth cannot expand into an unbounded number of node fetches. No uptime or success-rate figure is published for this behavior.

How fresh is the data?

Every run fetches the Best Sellers and category pages live at run time — there is no caching layer. scrapedAt on every row records when that specific page was fetched.

What's the difference between treeDepth and productSubcategoryLevels?

productSubcategoryLevels controls how deep PRODUCTS are scraped (1 = root category only, 2+ = also direct subcategories). treeDepth controls how many levels of the CATEGORY GRAPH are discovered as type: "category" nodes. They are independent — you can map a deep category tree while only pulling products from the root.

How do I get only the category tree, or only products?

Filter the dataset on type == "category" or type == "product", or set outputCategoryTree: false for a products-only run. Discovered category nodes are also mirrored to a separate categories-<runId> dataset for taxonomy-only consumers.

What happens if a category page fails to load during tree discovery?

The node is still emitted using the name and link already known from the parent page's nav tree, with productCount: null rather than a guessed number — a failed fetch never drops a node or fabricates its count.

Which fields work best for AI training and RAG indexing?

For RAG, index name, categoryFullName, and categoryPath — the highest-information text fields describing a product and its place in the taxonomy. For training data, price, stars, reviewsCount, and productCount are structurally consistent numeric fields across every row. All fields return as typed primitives (strings, numbers, booleans, arrays), requiring no normalization before use.

Does Amazon Bestsellers Scraper By Category work with Claude, ChatGPT, and other AI agent tools?

It is callable as a standard Apify API/SDK actor by any agent framework that can make an HTTP request — every response is typed JSON, so an agent can consume it directly without an HTML-parsing step.

ℹ️ Disclaimer

Amazon Bestsellers Scraper By Category extracts only publicly available data from Amazon. This tool is intended for lawful use cases only. Users are responsible for complying with Amazon's terms of service and applicable data protection laws in their jurisdiction.