# Amazon Category Product Scraper (`powerai/amazon-category-product-scraper`) Actor

Powerful Amazon category product scraper that automatically extracts up to 10,000 products from specific categories. Includes comprehensive filtering, multiple countries support, and detailed product information with automatic rate limit handling.

- **URL**: https://apify.com/powerai/amazon-category-product-scraper.md
- **Developed by:** [PowerAI](https://apify.com/powerai) (community)
- **Categories:** E-commerce, Other, Integrations
- **Stats:** 8 total users, 3 monthly users, 97.4% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

from $4.99 / 1,000 results

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 a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use 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 Product Scraper

Browse an Amazon **category** (by category ID) and export products as structured rows: titles, prices, ratings, links, images, and more—plus a **scrapedAt** time on each row.

### ✨ Key Features

- Target a category with its **category ID** (from the category browse URL on Amazon)
- Collect up to your chosen **maximum** count; continues across pages until that limit or until there are no more items
- Typical fields per product (see output example):
  - **asin**, **product_title**
  - **product_price**, **product_original_price**, **currency**
  - **product_star_rating**, **product_num_ratings**
  - **product_url**, **product_photo**
  - **product_num_offers**, **product_minimum_offer_price**
  - **is_best_seller**, **is_amazon_choice**, **is_prime**, **climate_pledge_friendly**
  - **sales_volume**, **delivery**, **has_variations**
- Optional filters: marketplace (**country**), sort order, price range, condition, brand, Prime, deals, minimum star rating, language, and more
- Each record includes **scrapedAt** so you know when it was collected

### 💪 Why Use It?

- **Category-focused**: Ideal when you already know the category’s **node** ID  
- **Structured**: One JSON object per product  
- **Configurable**: Filters help narrow the list before export  

### 🎯 Great For

- Category assortment and price snapshots  
- Competitive research within a category  
- Building product lists for analysis or monitoring  

### 📝 Input Parameters

| Parameter | Required | Description |
|-----------|----------|-------------|
| `category_id` | Yes | The category’s numeric ID (often visible in the category URL as `node=…`). Comma-separated IDs are supported if you need multiple categories in one request. |
| `maxResults` | No | Maximum number of products to collect (default: 20). |
| `country` | No | Marketplace / country (default: `US`). Pick **GB** in the list for the United Kingdom. |
| `sort_by` | No | How to order results (e.g. relevance, price, reviews, newest). |
| `min_price` / `max_price` | No | Optional price range in the marketplace currency. |
| `product_condition` | No | New, used, renewed, collectible, or all. |
| `brand` | No | Optional brand filter. |
| `is_prime` | No | Limit to Prime-eligible offers when enabled. |
| `deals_and_discounts` | No | Optional focus on discounts or today’s deals. |
| `four_stars_and_up` | No | Prefer higher customer ratings when enabled. |
| `language` | No | Preferred language for text where the site offers it (see the input form for common codes). |
| `additional_filters` | No | Extra filter text when you need advanced narrowing. |
| `fields` | No | Optional comma-separated list if you only want certain attributes per row. |

#### Input Example

```json
{
  "category_id": "281407",
  "maxResults": 16,
  "country": "US",
  "sort_by": "RELEVANCE"
}
````

#### Output Example

One JSON object per product:

```json
{
  "asin": "B0FQFB8FMG",
  "product_title": "Apple AirPods Pro 3 Wireless Earbuds, Active Noise Cancellation, Live Translation, Heart Rate Sensing, Hearing Aid Feature, Bluetooth Headphones, Spatial Audio, High-Fidelity Sound, USB-C Charging",
  "product_price": "$183.99",
  "product_original_price": null,
  "currency": "USD",
  "product_star_rating": "4.4",
  "product_num_ratings": 7175,
  "product_url": "https://www.amazon.com/dp/B0FQFB8FMG",
  "product_photo": "https://m.media-amazon.com/images/I/61solmQSSlL._AC_UL960_QL65_.jpg",
  "product_num_offers": 74,
  "product_minimum_offer_price": "$183.99",
  "is_best_seller": false,
  "is_amazon_choice": false,
  "is_prime": false,
  "climate_pledge_friendly": false,
  "sales_volume": "10K+ bought in past month",
  "delivery": null,
  "has_variations": false,
  "scrapedAt": "2026-03-24T03:10:30.332Z"
}
```

Some rows may include an optional badge or extra keys when the listing provides them.

### ⚠️ Notes

- Prices and labels depend on the **country** you select.
- **product\_original\_price** or **delivery** may be empty when the page doesn’t show them.
- Collection stops when your **maxResults** is reached, there are no more products in the category for your filters, or a page returns no rows.

# Actor input Schema

## `category_id` (type: `string`):

Amazon category ID to filter results. The category ID can be obtained from the Amazon category results URL, for example: https://amazon.com/s?node=2858778013 - the Amazon Category ID is 2858778013. Multiple category values can be separated by comma (e.g. categoryId1,categoryId2).

## `maxResults` (type: `integer`):

Maximum number of products to collect across pages.

## `country` (type: `string`):

Amazon marketplace (country). Choose GB for the United Kingdom.

## `sort_by` (type: `string`):

Sort results by criteria

## `min_price` (type: `integer`):

Minimum price filter. Only return product offers with price greater than a certain value. Specified in the currency of the selected country. For example, in case country=US, a value of 105.34 means $105.34.

## `max_price` (type: `integer`):

Maximum price filter. Only return product offers with price lower than a certain value. Specified in the currency of the selected country. For example, in case country=US, a value of 105.34 means $105.34.

## `product_condition` (type: `string`):

Filter by product condition

## `brand` (type: `string`):

Filter by specific brand. Only return products of a specific brand. Multiple brands can be specified as a comma (,) separated list. The brand values can be seen from Amazon's search left filters panel.Examples: SAMSUNG,Google

## `is_prime` (type: `boolean`):

Show only Prime eligible products

## `deals_and_discounts` (type: `string`):

Filter by deals and discounts

## `four_stars_and_up` (type: `boolean`):

Show only products with 4 stars or higher

## `language` (type: `string`):

Language code for results

## `additional_filters` (type: `string`):

Additional filtering criteria

## `fields` (type: `string`):

Specific fields to return in results

## Actor input object example

```json
{
  "category_id": "281407",
  "maxResults": 20,
  "country": "US",
  "sort_by": "RELEVANCE",
  "product_condition": "ALL",
  "is_prime": false,
  "deals_and_discounts": "NONE",
  "four_stars_and_up": false,
  "language": "en_US"
}
```

# 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 = {
    "category_id": "281407",
    "maxResults": 20,
    "country": "US",
    "sort_by": "RELEVANCE"
};

// Run the Actor and wait for it to finish
const run = await client.actor("powerai/amazon-category-product-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 = {
    "category_id": "281407",
    "maxResults": 20,
    "country": "US",
    "sort_by": "RELEVANCE",
}

# Run the Actor and wait for it to finish
run = client.actor("powerai/amazon-category-product-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "category_id": "281407",
  "maxResults": 20,
  "country": "US",
  "sort_by": "RELEVANCE"
}' |
apify call powerai/amazon-category-product-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=powerai/amazon-category-product-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Amazon Category Product Scraper",
        "description": "Powerful Amazon category product scraper that automatically extracts up to 10,000 products from specific categories. Includes comprehensive filtering, multiple countries support, and detailed product information with automatic rate limit handling.",
        "version": "0.0",
        "x-build-id": "EdJUH97k9HcXse9bs"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/powerai~amazon-category-product-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-powerai-amazon-category-product-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/powerai~amazon-category-product-scraper/runs": {
            "post": {
                "operationId": "runs-sync-powerai-amazon-category-product-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/powerai~amazon-category-product-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-powerai-amazon-category-product-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "category_id"
                ],
                "properties": {
                    "category_id": {
                        "title": "Category ID",
                        "type": "string",
                        "description": "Amazon category ID to filter results. The category ID can be obtained from the Amazon category results URL, for example: https://amazon.com/s?node=2858778013 - the Amazon Category ID is 2858778013. Multiple category values can be separated by comma (e.g. categoryId1,categoryId2).",
                        "default": "281407"
                    },
                    "maxResults": {
                        "title": "Maximum Results",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of products to collect across pages.",
                        "default": 20
                    },
                    "country": {
                        "title": "Country",
                        "enum": [
                            "US",
                            "AU",
                            "BR",
                            "CA",
                            "CN",
                            "FR",
                            "DE",
                            "IN",
                            "IT",
                            "MX",
                            "NL",
                            "SG",
                            "ES",
                            "TR",
                            "AE",
                            "GB",
                            "JP",
                            "SA",
                            "PL",
                            "SE",
                            "BE",
                            "EG"
                        ],
                        "type": "string",
                        "description": "Amazon marketplace (country). Choose GB for the United Kingdom.",
                        "default": "US"
                    },
                    "sort_by": {
                        "title": "Sort By",
                        "enum": [
                            "RELEVANCE",
                            "LOWEST_PRICE",
                            "HIGHEST_PRICE",
                            "REVIEWS",
                            "NEWEST",
                            "BEST_SELLERS"
                        ],
                        "type": "string",
                        "description": "Sort results by criteria",
                        "default": "RELEVANCE"
                    },
                    "min_price": {
                        "title": "Minimum Price",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Minimum price filter. Only return product offers with price greater than a certain value. Specified in the currency of the selected country. For example, in case country=US, a value of 105.34 means $105.34."
                    },
                    "max_price": {
                        "title": "Maximum Price",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum price filter. Only return product offers with price lower than a certain value. Specified in the currency of the selected country. For example, in case country=US, a value of 105.34 means $105.34."
                    },
                    "product_condition": {
                        "title": "Product Condition",
                        "enum": [
                            "ALL",
                            "NEW",
                            "USED",
                            "RENEWED",
                            "COLLECTIBLE"
                        ],
                        "type": "string",
                        "description": "Filter by product condition",
                        "default": "ALL"
                    },
                    "brand": {
                        "title": "Brand",
                        "type": "string",
                        "description": "Filter by specific brand. Only return products of a specific brand. Multiple brands can be specified as a comma (,) separated list. The brand values can be seen from Amazon's search left filters panel.Examples: SAMSUNG,Google"
                    },
                    "is_prime": {
                        "title": "Prime Only",
                        "type": "boolean",
                        "description": "Show only Prime eligible products",
                        "default": false
                    },
                    "deals_and_discounts": {
                        "title": "Deals and Discounts",
                        "enum": [
                            "NONE",
                            "ALL_DISCOUNTS",
                            "TODAYS_DEALS"
                        ],
                        "type": "string",
                        "description": "Filter by deals and discounts",
                        "default": "NONE"
                    },
                    "four_stars_and_up": {
                        "title": "4 Stars and Up",
                        "type": "boolean",
                        "description": "Show only products with 4 stars or higher",
                        "default": false
                    },
                    "language": {
                        "title": "Language",
                        "enum": [
                            "en_US",
                            "es_US",
                            "en_AU",
                            "pt_BR",
                            "en_CA",
                            "fr_CA",
                            "fr_FR",
                            "en_GB",
                            "de_DE",
                            "cs_CZ",
                            "nl_NL",
                            "pl_PL",
                            "tr_TR",
                            "da_DK",
                            "en_IN",
                            "hi_IN",
                            "ta_IN",
                            "te_IN",
                            "kn_IN",
                            "ml_IN",
                            "bn_IN",
                            "mr_IN",
                            "it_IT",
                            "es_MX",
                            "en_SG",
                            "es_ES",
                            "pt_PT",
                            "ar_AE",
                            "ja_JP",
                            "zh_CN",
                            "sv_SE",
                            "fr_BE"
                        ],
                        "type": "string",
                        "description": "Language code for results",
                        "default": "en_US"
                    },
                    "additional_filters": {
                        "title": "Additional Filters",
                        "type": "string",
                        "description": "Additional filtering criteria"
                    },
                    "fields": {
                        "title": "Fields",
                        "type": "string",
                        "description": "Specific fields to return in results"
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
