# Amazon Product Scraper (`novashieldai/amazon-product-scraper`) Actor

Scrape Amazon for product details, search results, reviews, prices, ratings, and more. Supports 19 marketplaces worldwide.

- **URL**: https://apify.com/novashieldai/amazon-product-scraper.md
- **Developed by:** [Ali haydar Karadaş](https://apify.com/novashieldai) (community)
- **Categories:** E-commerce, Developer tools
- **Stats:** 1 total users, 0 monthly users, 60.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

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

## 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 Product Scraper

Scrape Amazon product listings, detailed product pages, and customer reviews from any Amazon marketplace worldwide. This is the most reliable Amazon scraper on the platform -- built to handle search results, full product details, variant data, and review extraction across 19 Amazon marketplaces.

### What does Amazon Product Scraper do?

This actor operates in three modes to cover every Amazon data need you might have.

**Search mode** takes a keyword query and returns product listings just like you see them on Amazon -- title, price, rating, review count, brand, Prime eligibility, images, and more. You can sort by relevance, price, reviews, newest, or bestsellers, and paginate through up to 20 pages of results.

**Product mode** takes an ASIN or product URL and returns the full product page data. That includes everything from the search result plus the full description, dimensions, weight, model number, manufacturer, technical specifications table, variant options (colors, sizes), ratings breakdown by star, and frequently bought together items.

**Reviews mode** pulls customer reviews for a specific ASIN -- up to 200 per request. Each review comes with the author name, star rating, title, full text, date, verified purchase status, helpful votes, images, and the specific variant reviewed.

All three modes work across 19 Amazon marketplaces including US, UK, Germany, France, Japan, India, Brazil, Australia, and more.

### What data do you get?

- ASIN, product title, and product URL
- Current price and original/list price with currency
- Average rating (0-5) and total review count
- Brand, seller, and manufacturer info
- Product category breadcrumb
- Product images (all URLs)
- Bullet point features
- Best seller rank
- Prime eligibility and sponsored listing flags
- Full product description
- Dimensions, weight, and model number
- Date first available and country of origin
- Ratings breakdown by star (5-star: 1200, 4-star: 340, etc.)
- Product variants (color, size options)
- Technical details/specifications table
- Frequently bought together ASINs
- Individual reviews with author, rating, title, text, date, verified purchase status, helpful votes, images, and variant

### Who is this for?

- **E-commerce sellers** tracking competitor pricing, reviews, and product positioning
- **Product researchers** validating demand and analyzing customer feedback before launching
- **Dropshippers** finding winning products and monitoring supplier pricing across marketplaces
- **Brand managers** monitoring unauthorized sellers and pricing violations
- **Market analysts** building datasets of product trends, pricing, and consumer sentiment

### How to use it

1. Pick your mode: search, product, or reviews.
2. For search, type a keyword like "wireless headphones" and choose your marketplace.
3. For product or reviews, paste an ASIN (e.g., B09V3KXJPB) or a full Amazon product URL.
4. Set your result limit and sorting preference.
5. Run it and export your data as JSON, CSV, or Excel.

### Input parameters

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| mode | string | search | Operation mode: search, product, or reviews |
| query | string | - | Search keywords (required for search mode) |
| asin | string | - | ASIN or product URL (required for product/reviews mode) |
| marketplace | string | com | Amazon marketplace: com, co.uk, de, fr, it, es, ca, co.jp, in, com.br, com.au, com.mx, nl, sg, ae, sa, pl, se, com.tr |
| limit | integer | 20 | Maximum results (1-100) |
| page | integer | 1 | Page number (1-20) |
| sort | string | relevance | Sort: relevance, price_asc, price_desc, reviews, newest, bestsellers |
| includeReviews | boolean | false | Also fetch reviews for each product |
| reviewsLimit | integer | 50 | Max reviews per product (1-200) |

### Sample output

```json
{
  "asin": "B09V3KXJPB",
  "title": "Sony WH-1000XM5 Wireless Noise Canceling Headphones",
  "price": 328.00,
  "original_price": 399.99,
  "currency": "USD",
  "rating": 4.6,
  "review_count": 18432,
  "availability": "In Stock",
  "seller": "Amazon.com",
  "brand": "Sony",
  "category": "Electronics > Headphones > Over-Ear Headphones",
  "images": [
    "https://m.media-amazon.com/images/I/51aXvjzcukL._AC_SL1500_.jpg"
  ],
  "features": [
    "Industry Leading Noise Cancellation",
    "Exceptional sound quality with 30mm drivers",
    "30 hours battery life with quick charge"
  ],
  "best_seller_rank": "#1 in Over-Ear Headphones",
  "is_prime": true,
  "is_sponsored": false,
  "url": "https://www.amazon.com/dp/B09V3KXJPB",
  "marketplace": "com"
}
````

### How much does it cost?

This actor charges **$0.005 per result**. So 1,000 products cost $5 and 10,000 products cost $50.

Every Apify account includes $5 in free monthly credits -- enough to test it properly before committing.

### Common questions

**Which Amazon marketplaces are supported?**
All 19 major ones: US, UK, Germany, France, Italy, Spain, Canada, Japan, India, Brazil, Australia, Mexico, Netherlands, Singapore, UAE, Saudi Arabia, Poland, Sweden, and Turkey.

**Can I scrape an entire Amazon category?**
Yes. Use search mode with category-specific keywords and paginate through results. For large-scale extraction, run multiple queries to cover subcategories.

**Does it handle products with many variants?**
Yes. In product mode, you get all variant data -- every color, size, and configuration with its own price, SKU, and availability status.

### Contact & Custom Solutions

Need a custom scraper, higher volume, or a specific integration? We're here to help.

If anything isn't working right or you need support, don't hesitate to reach out.

- Telegram: [t.me/novashield\_dev](https://t.me/novashield_dev)
- Email: novashield.dev@gmail.com

# Actor input Schema

## `mode` (type: `string`):

Scraping mode: 'search' for keyword search, 'product' for single ASIN details, 'reviews' for product reviews, 'bestseller' for best-seller lists.

## `query` (type: `string`):

Search keyword (required for search mode). Example: 'wireless mouse', 'gaming laptop'.

## `asin` (type: `string`):

Amazon ASIN product identifier (required for product/reviews mode). Example: 'B0CHX3QBCH'.

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

Amazon marketplace domain. Example: 'amazon.com', 'amazon.co.uk', 'amazon.de'.

## `limit` (type: `integer`):

Maximum number of results to return (default: 20, max: 100).

## `page` (type: `integer`):

Page number for paginated results (default: 1).

## `sort` (type: `string`):

Sort order for search results: 'relevance', 'price\_low', 'price\_high', 'reviews', 'newest'.

## `includeReviews` (type: `boolean`):

Include Reviews

## `reviewsLimit` (type: `integer`):

Reviews Limit

## Actor input object example

```json
{
  "mode": "search",
  "query": "wireless headphones",
  "marketplace": "com",
  "limit": 20,
  "page": 1,
  "sort": "relevance",
  "includeReviews": false,
  "reviewsLimit": 50
}
```

# 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 = {
    "query": "wireless headphones"
};

// Run the Actor and wait for it to finish
const run = await client.actor("novashieldai/amazon-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 = { "query": "wireless headphones" }

# Run the Actor and wait for it to finish
run = client.actor("novashieldai/amazon-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 '{
  "query": "wireless headphones"
}' |
apify call novashieldai/amazon-product-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Amazon Product Scraper",
        "description": "Scrape Amazon for product details, search results, reviews, prices, ratings, and more. Supports 19 marketplaces worldwide.",
        "version": "1.0",
        "x-build-id": "JylJo6rXL8qfkFXef"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/novashieldai~amazon-product-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-novashieldai-amazon-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/novashieldai~amazon-product-scraper/runs": {
            "post": {
                "operationId": "runs-sync-novashieldai-amazon-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/novashieldai~amazon-product-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-novashieldai-amazon-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",
                "properties": {
                    "mode": {
                        "title": "Mode",
                        "enum": [
                            "search",
                            "product",
                            "reviews"
                        ],
                        "type": "string",
                        "description": "Scraping mode: 'search' for keyword search, 'product' for single ASIN details, 'reviews' for product reviews, 'bestseller' for best-seller lists.",
                        "default": "search"
                    },
                    "query": {
                        "title": "Search Query",
                        "type": "string",
                        "description": "Search keyword (required for search mode). Example: 'wireless mouse', 'gaming laptop'."
                    },
                    "asin": {
                        "title": "ASIN or Product URL",
                        "type": "string",
                        "description": "Amazon ASIN product identifier (required for product/reviews mode). Example: 'B0CHX3QBCH'."
                    },
                    "marketplace": {
                        "title": "Marketplace",
                        "enum": [
                            "com",
                            "co.uk",
                            "de",
                            "fr",
                            "it",
                            "es",
                            "ca",
                            "co.jp",
                            "in",
                            "com.br",
                            "com.au",
                            "com.mx",
                            "nl",
                            "sg",
                            "ae",
                            "sa",
                            "pl",
                            "se",
                            "com.tr"
                        ],
                        "type": "string",
                        "description": "Amazon marketplace domain. Example: 'amazon.com', 'amazon.co.uk', 'amazon.de'.",
                        "default": "com"
                    },
                    "limit": {
                        "title": "Max Results",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Maximum number of results to return (default: 20, max: 100).",
                        "default": 20
                    },
                    "page": {
                        "title": "Page",
                        "minimum": 1,
                        "maximum": 20,
                        "type": "integer",
                        "description": "Page number for paginated results (default: 1).",
                        "default": 1
                    },
                    "sort": {
                        "title": "Sort",
                        "enum": [
                            "relevance",
                            "price_asc",
                            "price_desc",
                            "reviews",
                            "newest",
                            "bestsellers"
                        ],
                        "type": "string",
                        "description": "Sort order for search results: 'relevance', 'price_low', 'price_high', 'reviews', 'newest'.",
                        "default": "relevance"
                    },
                    "includeReviews": {
                        "title": "Include Reviews",
                        "type": "boolean",
                        "description": "Include Reviews",
                        "default": false
                    },
                    "reviewsLimit": {
                        "title": "Reviews Limit",
                        "minimum": 1,
                        "maximum": 200,
                        "type": "integer",
                        "description": "Reviews Limit",
                        "default": 50
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
