# Amazon Category Products Scraper (`apt_marble/amazon-category-scraper`) Actor

Export every product Amazon lists in a category. Paste a category link, a category ID or an Amazon search link, narrow it by price band, star rating and Prime before collecting, sort by best selling or price, and optionally attach the complete product record to every product.

- **URL**: https://apify.com/apt\_marble/amazon-category-scraper.md
- **Developed by:** [Hamza](https://apify.com/apt_marble) (community)
- **Categories:** E-commerce, SEO tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.60 / 1,000 category product scrapeds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.
Actors are written with capital "A".

## 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.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

## Amazon Category Products Scraper

Pull an entire Amazon category out as structured data. Give the actor a
category link, a bare category ID or an Amazon search link and it returns the
products Amazon lists there — ASIN, full title, price, stars, rating count,
Prime status, badges and delivery promise — filtered by price band, minimum
star rating and Prime eligibility before anything is collected, so you only pay
for rows you actually want. It is built for brand owners sizing up a category,
buyers building assortment lists, and analysts who need Amazon's own ordering
of a category rather than a hand-assembled sample.

### What you can do with it

- **Map a category.** Export the products Amazon lists in a category, ordered
  by best selling, price or customer rating.
- **Size a price band.** Restrict to a price window and see exactly what
  competes there, with the count and the ratings to back it.
- **Find quality gaps.** Filter to 4 stars and up, or the opposite, to spot
  where a category is under-served.
- **Track a category over time.** Re-run on a schedule and diff which products
  entered, left or moved.
- **Build a lead list of products.** Feed the ASINs straight into pricing,
  sourcing or advertising work.
- **Go deeper on the shortlist.** Switch on full product details to attach the
  complete product record — every specification, every image, the full star
  breakdown and category rankings — to each product.

Paste categories in whatever form you have them: a category landing link, a
category ID on its own, a search link already narrowed to a category, or a Best
Sellers link. They all resolve to the same category listing.

### What you get

One row per product. Abridged sample:

```json
{
  "categoryInput": "https://www.amazon.com/b?node=172282",
  "categoryId": "172282",
  "categoryName": "Electronics",
  "categoryUrl": "https://www.amazon.com/s?rh=n%3A172282&s=exact-aware-popularity-rank",
  "marketplace": "us",
  "page": 1,
  "position": 1,
  "organicPosition": 1,
  "isSponsored": false,
  "asin": "B0F9X3FDYY",
  "title": "HUANUO 32x19 Inch Small Electric Standing Desk, Adjustable Height Sit Stand Workstation",
  "url": "https://www.amazon.com/dp/B0F9X3FDYY",
  "image": "https://m.media-amazon.com/images/I/71c0pTKa8DL._AC_UL320_.jpg",
  "price": 129.99,
  "currency": "USD",
  "listPrice": 169.99,
  "typicalPrice": null,
  "rating": 4.4,
  "ratingsCount": 1284,
  "boughtInPastMonth": "2K+",
  "isPrime": true,
  "isAmazonsChoice": false,
  "isBestSeller": true,
  "badge": "Best Seller",
  "deliveryText": "FREE delivery Thu, Aug 14",
  "variantCount": 6,
  "detailsIncluded": false,
  "scrapedAt": "2026-08-07T09:14:02.881Z"
}
```

With **Include full product details** switched on, the same row also carries
`brand`, `availability`, `inStock`, `buyBoxSeller`, `shipsFrom`,
`bestSellersRank`, `featureBullets`, `specifications`, `breadcrumbs`, `images`,
`starHistogram`, `description`, `dimensions`, `weight`, `hasCoupon` and
`dateFirstAvailable`, and `detailsIncluded` becomes `true`.

### Input reference

| Setting | Type | Default | Description |
| --- | --- | --- | --- |
| Category URLs or node IDs | list of text | — (required) | Categories to collect. Any Amazon category link, category ID, Best Sellers link or Amazon search link. |
| Maximum products per category | integer | `200` | Stop after this many products in each category. |
| Sort products by | select | `bestselling` | How Amazon should order the category: best selling, relevance, price low to high, price high to low, average customer rating, or newest arrivals. |
| Minimum price | integer | — | Only return products at or above this price, in the selected marketplace's own currency. |
| Maximum price | integer | — | Only return products at or below this price. |
| Minimum star rating | integer | — | Only return products rated at least this many stars (whole stars, 1 to 4). |
| Prime eligible only | yes/no | `no` | Only return products flagged as Prime eligible. |
| Exclude sponsored placements | yes/no | `yes` | Drop paid placements. Turn off to keep them, flagged. |
| Include full product details | yes/no | `no` | Attach the complete product record to every product. Much slower and billed separately. |
| Amazon marketplace | select | `us` | Which country's Amazon site to read. Results come back in that marketplace's own currency. |
| Parallel targets | integer | `4` | How many categories to work on at the same time. Higher is faster, but Amazon serves fewer complete results when pushed hard. Leave at 4 unless you have a reason. |

### Output fields

| Field | Type | Description |
| --- | --- | --- |
| `categoryInput` | string | Exactly what you supplied for this category. |
| `categoryId` | string | null | Amazon's own category identifier, resolved from whatever you supplied. `null` for a plain keyword link. |
| `categoryName` | string | null | The category's name as Amazon displays it, when Amazon names it. |
| `categoryUrl` | string | The Amazon listing this row came from. |
| `marketplace` | string | The Amazon marketplace this product came from. |
| `page` | integer | Which block of the listing it appeared in. |
| `position` | integer | Position in the category exactly as Amazon displayed it. |
| `organicPosition` | integer | null | Position with paid placements removed. `null` for a sponsored product. |
| `isSponsored` | boolean | Whether this is a paid placement. |
| `asin` | string | Amazon's product identifier. |
| `title` | string | Full product title, not the shortened version. |
| `url` | string | Clean link to the product, free of tracking. |
| `image` | string | Product image shown in the listing. |
| `price` | number | null | Current price. `null` when Amazon shows no price for that product. |
| `currency` | string | null | Currency the price was published in, read from Amazon itself. |
| `listPrice` | number | null | Struck-through list price, when Amazon shows one. |
| `typicalPrice` | number | null | Amazon's "typical price" market average, kept separate from a real list price so no invented discount appears. |
| `rating` | number | null | Average star rating out of 5. |
| `ratingsCount` | integer | null | How many customers rated it — a much larger number than the count of written reviews. |
| `boughtInPastMonth` | string | null | Amazon's "N+ bought in past month" badge text. |
| `isPrime` | boolean | Prime eligibility as shown in the listing. |
| `isAmazonsChoice` | boolean | Carries Amazon's Choice / Overall Pick badge. |
| `isBestSeller` | boolean | Carries the Best Seller badge. |
| `badge` | string | null | Any other badge text on the product. |
| `deliveryText` | string | null | The delivery promise Amazon printed. |
| `variantCount` | integer | null | How many size/colour options the listing offers. |
| `detailsIncluded` | boolean | Whether the complete product record was attached to this row. |
| `scrapedAt` | string | ISO timestamp of collection. |

### Pricing

Pay-per-event. You are billed for what you actually receive.

| You are charged | When |
| --- | --- |
| **$0.60 per 1,000 products** | For every product written to the dataset. |
| **$1.00 per 1,000 full product records** | Only when *Include full product details* is on, and only for products whose complete record was successfully attached. |

**Worked example.** Five categories at 200 products each gives 1,000 rows and
costs **$0.60**. Turn on full product details and those same 1,000 rows carry
the complete product record for **$1.60** in total. Products whose deeper
record could not be collected are still delivered, still flagged, and are not
charged the second event.

### Limits & what this actor cannot do

- Amazon publishes a limited set of public results for any one category
  listing — a few hundred at most. A larger limit returns what Amazon actually
  makes available rather than a category's entire catalogue. Amazon's own
  printed result count is a rough estimate and is deliberately not reported as
  a total.
- A category that Amazon no longer lists, or one where nothing survives your
  filters, is reported as having no products rather than treated as an error.
- Sponsored placements appear inside Amazon's own listings. They are excluded
  by default and can be kept, flagged, instead.
- Prices, ranks, ratings and stock are a snapshot at the moment of collection
  and keep changing afterwards.
- Prices and availability differ between Amazon marketplaces; results reflect
  the marketplace you select, in that marketplace's own currency. A link pasted
  from another country's Amazon site is collected from the marketplace you
  chose, and the run says so.
- Amazon does not publish a price for every product it lists. Those products
  come back with an empty price rather than a guess, and they are not returned
  at all when a price filter is set.
- Products that are removed, restricted or unavailable in the selected
  marketplace are reported as unavailable rather than returned empty.
- Customer questions and answers are not publicly listed and are not returned.
- Speed depends on the size of the job and on Amazon's own response times; no
  fixed throughput is promised.
- Amazon's terms govern automated access. You are responsible for using the
  data lawfully and in line with the source site's terms, and for handling any
  personal data in line with applicable privacy law.

### FAQ

**Do I need an Amazon account?**
No. The actor only reads what Amazon publishes to anyone.

**Does it need my login or password?**
No, and there is nowhere to enter one.

**Can I schedule it?**
Yes. Schedule it on Apify like any other actor and diff the output over time to
watch a category move.

**Is the data complete?**
It is complete for what Amazon publicly lists. Amazon caps how deep any one
category listing goes, so a very large category returns the few hundred
products Amazon actually makes available rather than every item it stocks.

**What exactly can I paste into the category field?**
A category landing link, a bare category ID, a Best Sellers link, or an Amazon
search link already narrowed to a category. Duplicates that resolve to the same
listing are collected once. A single product link or a seller storefront link
is rejected with an explanation.

**Why do some products have no price?**
Because Amazon showed none in that listing. The actor reports it honestly
rather than substituting a delivery fee or a related product's price. Switch on
full product details if you need a price for every product.

# Actor input Schema

## `categoryUrls` (type: `array`):

Categories to collect. Paste any Amazon category or search link, or a bare category ID.

## `maxProductsPerCategory` (type: `integer`):

Stop after this many products in each category.

## `sortBy` (type: `string`):

How Amazon should order the category before it is collected.

## `minPrice` (type: `integer`):

Only return products at or above this price, in the marketplace's own currency.

## `maxPrice` (type: `integer`):

Only return products at or below this price.

## `minRating` (type: `integer`):

Only return products rated at least this many stars.

## `primeOnly` (type: `boolean`):

Only return products flagged as Prime eligible.

## `excludeSponsored` (type: `boolean`):

Drop paid placements and keep only organic listings.

## `includeProductDetails` (type: `boolean`):

Open each category item to collect the complete product record — full specifications, every image, the full rating breakdown and category rankings. Much slower and billed separately; leave off for a fast list.

## `marketplace` (type: `string`):

Which country's Amazon site to read. Prices, availability and rankings differ between marketplaces, and results come back in that marketplace's own currency.

## `maxConcurrency` (type: `integer`):

How many targets to work on at the same time. Higher is faster but Amazon serves fewer complete pages when pushed hard. Leave at 4 unless you have a reason.

## Actor input object example

```json
{
  "categoryUrls": [
    "https://www.amazon.com/s?rh=n%3A172282"
  ],
  "maxProductsPerCategory": 100,
  "sortBy": "bestselling",
  "primeOnly": false,
  "excludeSponsored": true,
  "includeProductDetails": false,
  "marketplace": "us",
  "maxConcurrency": 4
}
```

# Actor output Schema

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

Every row this run produced.

## `runSummary` (type: `string`):

What this run collected, and anything it could not read.

# 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 = {
    "categoryUrls": [
        "https://www.amazon.com/s?rh=n%3A172282"
    ],
    "maxProductsPerCategory": 100,
    "sortBy": "bestselling",
    "primeOnly": false,
    "excludeSponsored": true,
    "includeProductDetails": false,
    "marketplace": "us",
    "maxConcurrency": 4
};

// Run the Actor and wait for it to finish
const run = await client.actor("apt_marble/amazon-category-scraper").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 = {
    "categoryUrls": ["https://www.amazon.com/s?rh=n%3A172282"],
    "maxProductsPerCategory": 100,
    "sortBy": "bestselling",
    "primeOnly": False,
    "excludeSponsored": True,
    "includeProductDetails": False,
    "marketplace": "us",
    "maxConcurrency": 4,
}

# Run the Actor and wait for it to finish
run = client.actor("apt_marble/amazon-category-scraper").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 '{
  "categoryUrls": [
    "https://www.amazon.com/s?rh=n%3A172282"
  ],
  "maxProductsPerCategory": 100,
  "sortBy": "bestselling",
  "primeOnly": false,
  "excludeSponsored": true,
  "includeProductDetails": false,
  "marketplace": "us",
  "maxConcurrency": 4
}' |
apify call apt_marble/amazon-category-scraper --silent --output-dataset

```

## MCP server setup

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

```

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/thbcSnKrWdRakTS4k/builds/3gCiIeX3SALf7B86r/openapi.json