# Amazon Product Research Scraper — BSR, Reviews & Seller (`khadinakbar/amazon-product-intelligence`) Actor

Research Amazon products by ASIN or keyword: price, Best Sellers Rank, ratings, seller, Prime status, bullet points, images and optional review snippets across 10 marketplaces (US, UK, DE, FR, CA, ES, IT, JP, AU, IN), one analysis-ready row per product.

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

## Pricing

from $5.00 / 1,000 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/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 Research Scraper?

Amazon Product Research Scraper (`khadinakbar/amazon-product-intelligence`) builds an analysis-ready record per Amazon product for sourcing and product research, with optional customer review snippets in the same row. It works through the Apify Console, the API and Apify MCP. It accepts a keyword, a list of ASINs, or direct Amazon product or search URLs, and returns one record per scraped product. Each record can include ASIN, title, brand, price, original price, discount percent, rating, review count, BSR rank and category, Prime eligibility, seller details, fulfillment by Amazon, availability, images, description, bullet points, marketplace, scrape timestamp, and source URL.

### Best fit and connected workflows

This Actor fits workflows that begin with Amazon product discovery and end with a structured product record. Common routing patterns include:

- Keyword-led research: start from a product idea or category term and collect matching Amazon listings.
- ASIN refreshes: monitor known products by passing exact ASIN codes.
- URL-led extraction: process a known product page or search results page directly.
- Marketplace comparison: run the same input across a chosen Amazon marketplace to compare local price, BSR, Prime, and seller fields.
- Review follow-up: use this Actor first for product-level context, then connect the returned record to a review-focused workflow for deeper sentiment analysis.

### Practical scenario

A sourcing team screens 20 supplier ASINs before placing an order. One run with `includeReviews` on and `maxReviews` at 5 returns each product's `price`, `bsr_rank`, `rating`, `review_count`, `seller_name` and `fulfilled_by_amazon`, plus five recent reviews. Products with a strong rank but recurring complaints in the review snippets are dropped from the order list before any samples are bought.

### Input

Choose one input method or combine them.

| Field | Type | Purpose |
|---|---|---|
| `searchQuery` | string | Keyword search for Amazon, such as a product type or topic. |
| `asins` | array of strings | Specific Amazon Standard Identification Numbers to scrape. |
| `startUrls` | array of request objects | Direct Amazon product pages or Amazon search result pages. |
| `country` | string | Amazon marketplace to scrape: US, UK, DE, FR, CA, ES, IT, JP, AU, or IN. |
| `maxResults` | integer | Maximum number of products to extract. Each product counts as one billable event. |
| `includeReviews` | boolean | Loads customer review pages for each scraped product. |
| `maxReviews` | integer | Maximum number of reviews per product when reviews are enabled. |
| `proxyConfiguration` | object | Proxy settings for the browser route. The native page route uses the Apify datacenter pool first and Apify Residential proxies on block; supply your own proxy URLs to use only those. |

#### Focused input example

```json
{
  "searchQuery": "wireless earbuds",
  "country": "US",
  "maxResults": 3,
  "includeReviews": true,
  "maxReviews": 5
}
```

### Output

The default dataset stores one record per scraped product.

| Field | Type | Purpose |
|---|---|---|
| `asin` | string or null | Amazon Standard Identification Number. |
| `title` | string or null | Full product title. |
| `brand` | string or null | Product brand name. |
| `price` | number or null | Current selling price. |
| `currency` | string or null | Currency code or symbol. |
| `original_price` | number or null | Original price before discount. |
| `discount_percent` | number or null | Discount percentage off original price. |
| `rating` | number or null | Average customer rating. |
| `review_count` | number or null | Total number of customer reviews. |
| `bsr_rank` | number or null | suitable Sellers Rank number. |
| `bsr_category` | string or null | suitable Sellers Rank category name. |
| `prime_eligible` | boolean or null | Whether the product has a Prime badge. |
| `seller_name` | string or null | Seller name. |
| `seller_id` | string or null | Seller identifier on Amazon. |
| `fulfilled_by_amazon` | boolean or null | Whether the item is fulfilled by Amazon. |
| `availability` | string or null | Stock availability text. |
| `images` | array or null | Product image URLs. |
| `description` | string or null | Full product description text. |
| `bullet_points` | array or null | Feature bullet points from the product page. |
| `marketplace` | string or null | Amazon marketplace domain. |
| `scraped_at` | string or null | ISO 8601 scrape timestamp. |
| `source_url` | string or null | Source Amazon URL. |

#### Sample output record

A product row (array fields shortened). Fields the product page did not show are `null`.

```json
{
  "asin": "B07DF46NW9",
  "title": "DEWALT 9-in-1 Painter's Tool | Straight Scraper, Curved Scraper, Gouger, Roller Cleaner, Can Opener, Bottle Opener, Nail Puller, Screwdriver, Hammer | Carbon Steel w/Soft Grip Handle | DXTT-2-200",
  "brand": null,
  "price": 14.39,
  "currency": "$",
  "original_price": null,
  "discount_percent": null,
  "rating": 4.8,
  "review_count": 2410,
  "bsr_rank": null,
  "bsr_category": null,
  "prime_eligible": false,
  "seller_name": "LEVEL5 Tools",
  "seller_id": null,
  "fulfilled_by_amazon": true,
  "availability": null,
  "images": [
    "https://m.media-amazon.com/images/I/61y7JLUgQPL._AC_SL1500_.jpg"
  ],
  "description": "This DEWALT 9-in-1 painter's tool has been built to the highest standard using nearly 20 years of input from professional finishers. Premium, hardened carbon st",
  "bullet_points": [
    "PLEASE NOTE: This professional finish tool features a hardened, high-carbon steel blade. It requires proper care and storage or it will corrode/rust (see care instructions in description below).steel blade for added durability.",
    "Curved scrapers, straight scraper, gauger, screwdriver, roller cleaner, nail puller, can opener, bottle opener, and alloy metal hammer end."
  ],
  "marketplace": "www.amazon.com",
  "reviews": [],
  "scraped_at": "2026-10-04T15:20:39.206Z",
  "source_url": "https://www.amazon.com/dp/B07DF46NW9"
}
```

### How it works

The Actor accepts keyword, ASIN, or URL input and runs against the selected Amazon marketplace: US, UK, DE, FR, CA, ES, IT, JP, AU, or IN.

1. **Native page route (primary).** Search pages and product pages are requested as plain HTML and parsed by the Actor itself. Requests go through the Apify datacenter pool first; a blocked page, or a page Amazon shows for another region (prices converted to another currency, or not deliverable), is retried through Apify Residential proxies pinned to the marketplace country, so prices stay in the marketplace's own currency.
2. **Browser route (native fallback).** Only when the first route saves no product at all, the same input is opened in a headless browser.

Every saved row comes from a confirmed product page with a title; a blank or blocked page is retried and never saved or charged. `RUN_SUMMARY` reports `routeServed` and per-route counts so you can see which route produced the rows. When `includeReviews` is enabled, the Actor returns up to `maxReviews` review snippets that Amazon shows on the product page. If a page arrives without its review snippets, it is fetched once more before the row is saved. The dataset schema is product-centric, so each row represents one scraped product. The output contract also exposes `results`, `runOutput`, and `runSummary` for automation and monitoring.

If a supplied ASIN does not exist, the run reports it and continues. Start URLs must be Amazon product or search pages; a run with only other URLs ends with an `INVALID_INPUT` outcome and no product charges. If every route is blocked and no product is saved, the run fails with an `UPSTREAM_FAILED` outcome rather than reporting an empty success.

### Pricing

This Actor uses Pay per event pricing. Each scraped product counts as one `Product Scraped` event, and Apify platform usage is included in the event price.

For example, a run that returns ten products creates ten billable product events. Open the live Pricing tab on the Actor page for the current event pricing and the platform usage that applies to your run.

### Use with AI agents (MCP)

This Actor is usable through Apify MCP. It accepts structured product discovery input and returns dataset records that AI agents can read directly.

Precise tool description: retrieve Amazon product intelligence from a keyword, ASIN list, or direct Amazon URL, then read the resulting dataset items for product fields such as price, BSR, ratings, seller information, Prime status, bullet points, and images.

Exact Actor identity: `khadinakbar/amazon-product-intelligence`

> Find Amazon product intelligence for the US marketplace from this ASIN list, return the dataset items, and summarize price, BSR, rating, review count, seller, Prime status, and availability for each product.

Output interpretation: each dataset row represents one scraped product. `source_url` provides provenance, `scraped_at` shows when the record was collected, and fields such as `price`, `bsr_rank`, `rating`, `review_count`, `seller_name`, `seller_id`, `prime_eligible`, and `fulfilled_by_amazon` are useful for downstream reasoning.

Scope and pagination guidance: use `searchQuery` for topic-led discovery, `asins` for exact product IDs, and `startUrls` for known Amazon pages. `maxResults` sets the product count for a run, and each product is charged as one `Product Scraped` event.

### API example

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

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

const run = await client.actor('khadinakbar/amazon-product-intelligence').call({
  searchQuery: 'wireless earbuds',
  country: 'US',
  maxResults: 3,
  includeReviews: false,
});

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

### Best results and outcome guidance

Start with a small `maxResults` value when testing a new keyword, ASIN list, or URL set. Use `asins` when you already have exact product identifiers, `searchQuery` when you want Amazon-discovered listings for a topic, and `startUrls` when the source page is already known.

If you need marketplace-specific data, match `country` to the Amazon domain you are studying. When reviews matter, enable `includeReviews` and choose a focused `maxReviews` value that matches the depth you need for downstream analysis.

### Continue the workflow

- Use [Amazon Product Details Scraper](https://apify.com/khadinakbar/amazon-product-details-scraper) when you need plain product details across 18 marketplaces without reviews.
- Then use [Amazon Product Scraper](https://apify.com/khadinakbar/amazon-product-scraper) to extend Amazon Product Research Scraper research with a complementary content contract.
- Then use [Amazon Product Search Scraper — Full Detail Data](https://apify.com/khadinakbar/amazon-product-search-scraper) to extend Amazon Product Research Scraper research with a complementary discovery contract.

### Design note

I found that the live dataset contract includes `seller_id`, `fulfilled_by_amazon`, and `source_url`, which makes each record useful for routing, fulfillment checks, and provenance tracking.

### FAQ

#### When should I use `searchQuery` instead of `asins`?

Use `searchQuery` when you are starting from a keyword or category idea. Use `asins` when you already have exact Amazon product identifiers.

#### When should I use `startUrls`?

Use `startUrls` when you already have Amazon product pages or Amazon search result pages and want those exact pages processed.

#### How do I connect this Actor to review workflows?

Use this Actor to capture the product record first, then route the returned product into a review-focused Actor when you want deeper review and sentiment analysis.

#### Which marketplace should I choose?

Pick the Amazon marketplace that matches the region you want to inspect, such as US, UK, DE, FR, CA, ES, IT, JP, AU, or IN.

#### What should I look at first in the output?

For product screening, `price`, `bsr_rank`, `rating`, `review_count`, `prime_eligible`, `seller_name`, and `fulfilled_by_amazon` are often the first fields to review.

### Responsible use

Use this Actor for publicly available Amazon product information and handle the resulting data in line with Amazon's terms, local law, and any applicable data protection requirements. Keep runs focused on the records you need, store the data responsibly, and respect platform and marketplace policies when automating collection.

# Changelog

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

# Actor input Schema

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

Use this when the user wants to search Amazon by keyword (e.g. 'wireless earbuds', 'vitamin C supplement'). Use startUrls instead when the user provides a direct Amazon product or search URL. Use asins instead when the user provides specific ASIN codes.

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

Use this when the user provides specific Amazon Standard Identification Numbers (ASINs), e.g. \['B07DF46NW9', 'B00FLYWNYQ']. Do NOT use this when the user describes a topic or category — use searchQuery for that.

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

Use this when the user provides direct Amazon product pages (e.g. amazon.com/dp/...) or Amazon search result pages (amazon.com/s?k=...). Other URLs are rejected as invalid input.

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

Which Amazon marketplace to scrape. Defaults to US (amazon.com). Options: US, UK, DE, FR, CA, ES, IT, JP, AU, IN.

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

Maximum number of products to extract. Each product counts as one billable event. Start with a small number to test. Maximum recommended: 1000 per run.

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

Set to true to include the customer review snippets Amazon shows on each product page (up to maxReviews per product). Reviews are read from the product page itself, so no extra page load is needed on the native route.

## `maxReviews` (type: `integer`):

How many customer reviews to extract per product. Only used when includeReviews is true. Higher values take longer.

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

Proxy settings for the browser fallback route. The native page route always tries the Apify datacenter pool first and Apify Residential proxies pinned to the marketplace country when a page is blocked or shown for another region (converted currency, not deliverable). Apify Residential without a country is pinned to the marketplace country. Supply your own proxy URLs to route every request through them instead.

## Actor input object example

```json
{
  "searchQuery": "",
  "asins": [
    "B07DF46NW9"
  ],
  "startUrls": [],
  "country": "US",
  "maxResults": 1,
  "includeReviews": false,
  "maxReviews": 5,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

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

Dataset of extracted Amazon product records — price, BSR, rating, review count, seller, Prime status, bullet points, images and more.

## `runOutput` (type: `string`):

Machine-readable terminal outcome, useful result count, failure details, and PPE charge counts.

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

Detailed terminal status for automation, monitoring, and AI-agent workflows.

# 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": "",
    "asins": [
        "B07DF46NW9"
    ],
    "startUrls": [],
    "country": "US",
    "maxResults": 1,
    "includeReviews": false,
    "maxReviews": 5,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("khadinakbar/amazon-product-intelligence").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": "",
    "asins": ["B07DF46NW9"],
    "startUrls": [],
    "country": "US",
    "maxResults": 1,
    "includeReviews": False,
    "maxReviews": 5,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

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

```

## MCP server setup

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

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/DVYod3BRbXcThq2DA/builds/snZypqKryasIyJeri/openapi.json