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

Scrape Amazon product data — price, BSR, rating, seller, FBA status, variants — from search, category, URL, or ASIN input across 18 marketplaces. MCP/API-ready.

- **URL**: https://apify.com/khadinakbar/amazon-product-scraper.md
- **Developed by:** [Khadin Akbar](https://apify.com/khadinakbar) (community)
- **Categories:** E-commerce, MCP servers, Agents
- **Features:** Limited permissions
- **Stats:** 31 total users, 4 monthly users, 96.2% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

from $4.00 / 1,000 product scrapeds

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.

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

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.

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

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

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

# README

### What is Amazon Product Scraper?

Amazon Product Scraper is an Apify Actor for product-level Amazon data across 18 marketplaces. It accepts one of three input paths: a keyword search query, a list of ASINs, or direct Amazon URLs. Each returned record represents one product and can include title, price, list price, discount percent, rating, review count, seller, Prime status, FBA status, suitable Sellers Rank, bullets, description, images, variants, breadcrumbs, and a scrape timestamp. The output is flat JSON, which works well for dashboards, enrichment pipelines, and AI agents that read one record at a time. It is available as an Apify Actor and can be used through Apify MCP.

### Best fit and connected workflows

This Actor fits workflows that start with Amazon product discovery and end with structured product records.

It routes cleanly from:

- keyword research, where a search query opens Amazon search results for the selected marketplace,
- catalog checks, where ASINs resolve directly against a marketplace domain,
- page-based collection, where product, search, or category URLs are already available.

A natural downstream workflow is review and sentiment enrichment. When a product record is returned here, you can follow it with Amazon Reviews Scraper - Ratings & Sentiment to add customer feedback context for the same product or URL.

### Practical scenario

Maya is comparing several headphone listings in the US marketplace. She starts with the keyword `wireless earbuds`, sets a product cap, and keeps full product-page scraping enabled. The Actor returns records with `asin`, `title`, `price`, `rating`, `reviewCount`, `seller`, `isPrime`, `isFBA`, and `bestSellerRank`. Maya uses the seller and fulfillment fields to decide which listings are direct-from-Amazon and which are merchant-fulfilled, then she sends the selected product URLs to a review workflow for deeper evaluation.

### Input fields

Provide one of `searchQuery`, `asins`, or `startUrls`. The other fields refine scope and scraping behavior.

| Field | Type | Purpose |
|---|---|---|
| `searchQuery` | string | Keyword search run on Amazon for the selected marketplace, such as `wireless earbuds`. |
| `asins` | array of strings | Specific 10-character ASIN codes to resolve on the selected marketplace. |
| `startUrls` | array | Direct Amazon product, search, or category URLs. The URL domain overrides the marketplace setting. |
| `country` | enum | Marketplace to use for `searchQuery` and `asins`. Supports US, UK, DE, FR, CA, ES, IT, JP, AU, IN, MX, BR, NL, SE, PL, TR, AE, and SG. |
| `maxResults` | integer | Maximum products returned across all inputs combined. |
| `maxSearchPages` | integer | Maximum search or category pages to paginate through per search query or start URL. |
| `scrapeProductDetails` | boolean | When enabled, products found on search or category pages are fetched again on their product pages for fuller product data. |
| `proxyConfiguration` | object | Proxy setup. Residential proxies are the default and Apify Proxy Residential is prefilled. |

#### Valid input example

```json
{
  "searchQuery": "wireless earbuds",
  "country": "US",
  "maxResults": 25,
  "maxSearchPages": 3,
  "scrapeProductDetails": true,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": ["RESIDENTIAL"]
  }
}
```

### Output fields

Each product is pushed to the dataset as a single flat JSON object.

| Field | Type | Meaning |
|---|---|---|
| `asin` | string | Amazon Standard Identification Number. |
| `title` | string | Product title. |
| `url` | string | Canonical product URL. |
| `marketplace` | string | Marketplace code such as US or UK. |
| `brand` | string | null | Brand or manufacturer. |
| `price` | number | null | Current price in marketplace currency. |
| `listPrice` | number | null | Original or list price before discount. |
| `currency` | string | null | ISO currency code. |
| `discountPercent` | number | null | Discount percentage. |
| `rating` | number | null | Star rating from 0 to 5. |
| `reviewCount` | integer | null | Total review count. |
| `boughtInPastMonth` | string | null | Purchase-frequency badge text. |
| `availability` | string | null | Stock-status text. |
| `inStock` | boolean | null | Whether the item is purchasable at scrape time. |
| `isPrime` | boolean | null | Prime eligibility. |
| `seller` | string | null | Merchant name. |
| `isFBA` | boolean | null | Fulfilled by Amazon. |
| `bestSellerRank` | array | null | Array of category and rank entries. |
| `bullets` | array | null | Feature bullet points. |
| `description` | string | null | Full product description. |
| `images` | array | null | Product image URLs. |
| `thumbnail` | string | null | Primary thumbnail URL. |
| `variants` | array | null | Product variants such as color or size. |
| `breadcrumbs` | array | null | Category breadcrumb path. |
| `sourceType` | string | One of `search`, `category`, `product`, or `asin`. |
| `scrapedAt` | string | ISO timestamp of the scrape. |

#### Illustrative output record

```json
{
  "asin": "B08N5WRWNW",
  "title": "Example product title",
  "url": "https://www.amazon.com/dp/B08N5WRWNW",
  "marketplace": "US",
  "brand": "Example Brand",
  "price": 199.99,
  "listPrice": 249.99,
  "currency": "USD",
  "discountPercent": 20,
  "rating": 4.7,
  "reviewCount": 85432,
  "boughtInPastMonth": "10K+ bought in past month",
  "availability": "In Stock",
  "inStock": true,
  "isPrime": true,
  "seller": "Amazon.com",
  "isFBA": true,
  "bestSellerRank": [
    { "category": "Electronics", "rank": 1 }
  ],
  "bullets": [
    "Example feature bullet"
  ],
  "description": "Example long description.",
  "images": [
    "https://m.media-amazon.com/images/I/example.jpg"
  ],
  "thumbnail": "https://m.media-amazon.com/images/I/example.jpg",
  "variants": [
    { "asin": "B0EXAMPLE1", "label": "Black" }
  ],
  "breadcrumbs": ["Electronics", "Headphones"],
  "sourceType": "search",
  "scrapedAt": "2026-04-24T04:20:00.000Z"
}
```

### How it works

The Actor uses a fast HTTP crawler with residential proxy defaults and session pooling. Pages that Amazon challenges on the HTTP pass (for example a JavaScript challenge on some marketplaces) are retried once in a real browser on the same proxy, up to 20 pages per run. Search pages that are still challenged after that are rendered through a managed rendering service (at most 3 pages per run); product pages found there are fetched again on the HTTP route. If every attempt stays blocked, the run ends as failed and no product is charged. It accepts keyword searches, ASIN resolution, and direct Amazon URLs. For search and category pages, it paginates up to the configured page limit. When `scrapeProductDetails` is enabled, each discovered product is fetched again on its own product page to collect fuller details such as bullets, A+ content, suitable Sellers Rank, variants, and seller information. The dataset uses a flat schema designed for direct API consumption and AI-agent workflows.

### Pricing

This Actor uses pay per event plus Apify platform usage. The primary billed event is `Product scraped`, which is charged for each product returned to the dataset. There is also an `Actor Start` event charged when the run starts, based on memory usage.

Live pricing details are available in the Actor's Pricing tab.

As an event-count example written in words: twenty-five returned products means twenty-five product-scraped events, plus the single actor-start event for the run.

### Use with AI agents (MCP)

This Actor is available through Apify MCP and is identified as `khadinakbar/amazon-product-scraper`. It is suitable for tools that need bounded, flat product records with explicit provenance fields.

Tool description: use it to retrieve Amazon product records from search queries, ASIN lists, or direct Amazon URLs, then pass the returned dataset items into an agent workflow for comparison, enrichment, or filtering.

> Scrape Amazon product records for the US marketplace from the keyword "wireless earbuds". Return the first 10 products with price, rating, reviewCount, seller, isPrime, isFBA, bestSellerRank, and scrapedAt so I can compare listings and decide which URLs to pass into a review workflow.

Output interpretation:

- `sourceType` shows whether the record came from search, category, product, or ASIN input.
- `scrapedAt` gives the scrape timestamp for the returned record.
- The dataset is flat, so each record can be read independently by an agent.

Provenance and scope:

- Each dataset item is one product record returned by the Actor.
- The returned fields reflect the selected input mode and whether `scrapeProductDetails` was enabled.
- `startUrls` can carry product, search, or category pages, and the Amazon domain in the URL takes precedence over `country`.

Pagination and cost guidance:

- `maxSearchPages` controls how far search or category pagination can continue.
- `maxResults` controls the total number of products returned across all inputs.
- Since billing is event-based, smaller runs are useful for checking the output shape before larger jobs.

### Apify API example

```javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({
  token: process.env.APIFY_TOKEN,
});

const input = {
  searchQuery: 'wireless earbuds',
  country: 'US',
  maxResults: 5,
  maxSearchPages: 2,
  scrapeProductDetails: true,
  proxyConfiguration: {
    useApifyProxy: true,
    apifyProxyGroups: ['RESIDENTIAL'],
  },
};

const run = await client.actor('khadinakbar/amazon-product-scraper').call(input);

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

### Best results and outcome guidance

Start with a small `maxResults` value so the returned fields match your downstream schema before expanding the run. Use `searchQuery` when you are exploring a product theme, `asins` when you already know the target products, and `startUrls` when you have exact Amazon pages. Keep `scrapeProductDetails` enabled when you need bullets, BSR, variants, or seller data, and turn it off when a lighter search-page record is enough for your workflow. For cross-market analysis, select the marketplace with `country` or use a marketplace-specific Amazon URL in `startUrls`.

### Continue the workflow

- Then use [Amazon Product Search Scraper — Full Detail Data](https://apify.com/khadinakbar/amazon-product-search-scraper) to extend Amazon Product Scraper research with a complementary discovery contract.
- Then use [🛒 Amazon Reviews Scraper — Ratings & Sentiment](https://apify.com/khadinakbar/amazon-reviews-scraper) to add Amazon engagement evidence to records selected with Amazon Product Scraper.

### Design note

I found that the live dataset contract exposes a flat record shape with `asin`, `title`, `url`, `price`, `rating`, `reviewCount`, `seller`, `isPrime`, and `scrapedAt` all available at the top level, which makes the output straightforward to stream into agent prompts and tables.

### FAQ

**Which input should I use if I already have product links?**\
Use `startUrls` for direct Amazon product, search, or category pages.

**When should I use `searchQuery` instead of ASINs?**\
Use `searchQuery` when you want Amazon search results for a keyword. Use `asins` when you already know the exact 10-character product IDs.

**How does marketplace selection work?**\
`country` applies to `searchQuery` and `asins`. If a `startUrls` entry points to a different Amazon domain, that URL's domain takes precedence.

**Can I combine keyword, ASIN, and URL inputs in one run?**\
Yes. The Actor accepts all three input types and returns one combined dataset.

**How can I continue from this Actor into review analysis?**\
Pass returned product URLs or ASINs into Amazon Reviews Scraper - Ratings & Sentiment to add customer review context.

### Responsible use

Use this Actor for publicly visible product information and for workflows that fit Amazon's terms, applicable laws, and local regulations. Respect marketplace rules, rate expectations, and data handling requirements in your environment.

# Changelog

This Actor's version history is a separate document: https://apify.com/khadinakbar/amazon-product-scraper/changelog.md

# Actor input Schema

## `searchQuery` (type: `string`):

Free-text keyword search run on Amazon (e.g. 'wireless earbuds'). Opens the search results page for the selected marketplace and extracts each product. NOT an Amazon URL — paste URLs into 'startUrls' instead. Leave empty if you use 'asins' or 'startUrls'.

## `asins` (type: `array`):

Specific Amazon Standard Identification Numbers (e.g. \['B08N5WRWNW','B09G9HD6PD']). Each ASIN is resolved against the selected marketplace domain. NOT a URL list — for URLs use 'startUrls'. NOT a keyword — for keywords use 'searchQuery'.

## `startUrls` (type: `array`):

Direct Amazon URLs — product pages ('/dp/ASIN'), search result pages ('/s?k=...'), or category pages. The domain inside each URL overrides the 'country' setting below. Use this when you already have the exact URLs to scrape.

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

Which Amazon marketplace to use when you pass 'searchQuery' or 'asins'. Ignored when 'startUrls' contains a different Amazon domain. Defaults to US (amazon.com).

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

Maximum products to scrape across all inputs combined (searchQuery + asins + startUrls). Each product returned is billed as one 'product-scraped' event at $0.004. Start small (5–25) to verify output before large jobs.

## `maxSearchPages` (type: `integer`):

Maximum search or category result pages to paginate through per start URL or search query. Each page has ~48 products. Amazon caps most searches at ~7 pages — higher values are silently clipped.

## `scrapeProductDetails` (type: `boolean`):

When true, every product found on a search/category page is fetched again on its own product page for full data (bullets, A+ content, BSR, variants, seller). When false, the scraper returns only the summary fields visible on the search page — faster and cheaper but shallower.

## `proxyConfiguration` (type: `object`):

Amazon blocks datacenter IPs — residential proxies are required and are the default. Override only if you have a specific compliance reason.

## Actor input object example

```json
{
  "searchQuery": "wireless earbuds",
  "asins": [],
  "startUrls": [],
  "country": "US",
  "maxResults": 1,
  "maxSearchPages": 1,
  "scrapeProductDetails": false,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

## `dataset` (type: `string`):

No description

## `output` (type: `string`):

No description

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

No description

# 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 = {
    "searchQuery": "wireless mouse",
    "asins": [],
    "country": "US",
    "maxResults": 1,
    "maxSearchPages": 1,
    "scrapeProductDetails": false,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("khadinakbar/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 = {
    "searchQuery": "wireless mouse",
    "asins": [],
    "country": "US",
    "maxResults": 1,
    "maxSearchPages": 1,
    "scrapeProductDetails": False,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("khadinakbar/amazon-product-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 '{
  "searchQuery": "wireless mouse",
  "asins": [],
  "country": "US",
  "maxResults": 1,
  "maxSearchPages": 1,
  "scrapeProductDetails": false,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call khadinakbar/amazon-product-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,khadinakbar/amazon-product-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/GnC0iIrT2tZ2POClg/builds/Iohxm3aZs5RHImdiH/openapi.json