# Amazon Product Scraper & Price Monitor - ASIN API (`groupoject/amazon-product-intelligence`) Actor

Scrape Amazon products by keyword, ASIN, or URL across 12 marketplaces. Extract prices, discounts, ratings, reviews, stock, Prime, images, features, opportunity scores, and price-change alerts. No Amazon API key.

- **URL**: https://apify.com/groupoject/amazon-product-intelligence.md
- **Developed by:** [Group Oject](https://apify.com/groupoject) (community)
- **Categories:** E-commerce, Automation, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $6.00 / 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/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

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

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

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

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

# README

## Amazon Product Scraper & Price Monitor - ASIN API

Scrape Amazon product data by keyword, ASIN, or product URL across 12 marketplaces. Extract prices, discounts, ratings, review counts, availability, brands, Prime status, feature bullets, images, search positions, and canonical URLs without an Amazon Product Advertising API key.

Use this Amazon scraper for product research, competitor price monitoring, ASIN lookup, ecommerce intelligence, sponsored-product analysis, marketplace comparison, and automated price-drop alerts. Export structured results as JSON, CSV, Excel, XML, or RSS through Apify.

### Why use this Amazon product scraper?

- **Three input methods:** search keywords, ASINs, and `/dp/` product URLs.
- **12 Amazon marketplaces:** localized requests with matching proxy countries.
- **Full product details:** brand, stock, features, image galleries, and product-page prices.
- **Persistent price monitoring:** compare current and previously stored prices.
- **Product opportunity scoring:** rank products using rating, demand, discount, Prime, and availability signals.
- **Search intelligence:** retain keyword, page, position, and sponsored status.
- **Clean output:** results are deduplicated by ASIN.
- **Automation ready:** use the API, schedules, webhooks, Make, Zapier, n8n, or MCP clients.

### Amazon data extracted

| Field | Description |
| --- | --- |
| `asin` | Amazon Standard Identification Number |
| `title` | Full product title |
| `brand` | Product brand or Store name |
| `url` | Canonical marketplace `/dp/` URL |
| `marketplace` | Amazon domain used for the scrape |
| `price` | Current displayed price |
| `listPrice` | Reference or crossed-out list price when shown |
| `currency` | Marketplace currency such as USD, GBP, or EUR |
| `discountPercent` | Calculated discount from list price |
| `rating` | Displayed star rating |
| `reviewCount` | Displayed ratings or review count |
| `availability` | Stock message shown by Amazon |
| `inStock` | Normalized availability flag |
| `isPrime` | Whether a Prime marker was detected |
| `features` | Product feature bullets |
| `image`, `images` | Main image and image gallery URLs |
| `isSponsored` | Whether the search listing was sponsored |
| `searchQuery` | Keyword that discovered the product |
| `searchPage`, `searchPosition` | Product position in collected search results |
| `opportunityScore` | Product research score from 0 to 100 |
| `opportunityTier` | High, Medium, or Low opportunity tier |
| `previousPrice` | Price stored by an earlier monitor run |
| `priceChange` | Absolute change from the previous price |
| `priceChangePercent` | Percentage price change |
| `priceDirection` | `up`, `down`, or `unchanged` |
| `scrapedAt` | ISO collection timestamp |

Unavailable fields are returned as `null` instead of being guessed.

### Supported Amazon marketplaces

| Store | Input | Currency |
| --- | --- | --- |
| United States | `amazon.com` | USD |
| United Kingdom | `amazon.co.uk` | GBP |
| Germany | `amazon.de` | EUR |
| France | `amazon.fr` | EUR |
| Italy | `amazon.it` | EUR |
| Spain | `amazon.es` | EUR |
| Canada | `amazon.ca` | CAD |
| Australia | `amazon.com.au` | AUD |
| India | `amazon.in` | INR |
| Japan | `amazon.co.jp` | JPY |
| Mexico | `amazon.com.mx` | MXN |
| Brazil | `amazon.com.br` | BRL |

### Input examples

#### Search Amazon by keyword

```json
{
  "searchQueries": ["wireless earbuds", "noise cancelling headphones"],
  "marketplace": "amazon.com",
  "maxItems": 50,
  "maxPagesPerQuery": 2,
  "fetchProductDetails": true
}
```

#### Filter products for market research

```json
{
  "searchQueries": ["portable blender", "travel accessories"],
  "marketplace": "amazon.com",
  "maxItems": 100,
  "minRating": 4,
  "minReviews": 100,
  "minPrice": 15,
  "maxPrice": 100,
  "includeSponsored": false
}
```

#### Bulk ASIN lookup

```json
{
  "asins": ["B0FQFB8FMG", "B09FT58QQP", "B09DT48V16"],
  "marketplace": "amazon.com",
  "maxItems": 3,
  "fetchProductDetails": true
}
```

Full Amazon product URLs can be placed in `productUrls`. ASIN and URL inputs can be combined in one run.

#### Monitor competitor prices

```json
{
  "productUrls": [
    "https://www.amazon.com/dp/B0FQFB8FMG",
    "https://www.amazon.com/dp/B09FT58QQP"
  ],
  "marketplace": "amazon.com",
  "monitorPrices": true,
  "stateKey": "competitor-electronics",
  "maxItems": 50
}
```

The first run stores observed prices. Later runs using the same `stateKey` populate `previousPrice`, `priceChange`, `priceChangePercent`, and `priceDirection`.

To produce a price-change-only feed after establishing the baseline:

```json
{
  "asins": ["B0FQFB8FMG", "B09FT58QQP"],
  "marketplace": "amazon.com",
  "monitorPrices": true,
  "onlyPriceChanges": true,
  "stateKey": "competitor-electronics"
}
```

Keep a stable, unique `stateKey` for each workflow. It is automatically normalized to a valid Apify storage name.

### Example output

```json
{
  "asin": "B0FQFB8FMG",
  "title": "Apple AirPods Pro 3 Wireless Earbuds with Active Noise Cancellation",
  "brand": "Apple",
  "url": "https://www.amazon.com/dp/B0FQFB8FMG",
  "marketplace": "amazon.com",
  "price": 199,
  "listPrice": 249,
  "currency": "USD",
  "discountPercent": 20.08,
  "rating": 4.4,
  "reviewCount": 14781,
  "availability": "In Stock",
  "inStock": true,
  "previousPrice": 199,
  "priceDirection": "unchanged",
  "opportunityScore": 80,
  "opportunityTier": "High"
}
```

### Run with the Apify API

Replace `YOUR_APIFY_TOKEN` with your token.

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/groupoject~amazon-product-intelligence/runs?token=YOUR_APIFY_TOKEN&waitForFinish=120" \
  -H "Content-Type: application/json" \
  -d '{
    "searchQueries": ["gaming mouse"],
    "marketplace": "amazon.com",
    "maxItems": 50,
    "fetchProductDetails": true
  }'
```

Return dataset results directly:

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/groupoject~amazon-product-intelligence/run-sync-get-dataset-items?token=YOUR_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"asins":["B0FQFB8FMG"],"marketplace":"amazon.com","maxItems":1}'
```

### JavaScript example

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('groupoject/amazon-product-intelligence').call({
  searchQueries: ['robot vacuum'],
  marketplace: 'amazon.com',
  maxItems: 50,
  minRating: 4,
  fetchProductDetails: true,
});

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

### Python example

```python
import os
from apify_client import ApifyClient

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('groupoject/amazon-product-intelligence').call(run_input={
    'searchQueries': ['standing desk'],
    'marketplace': 'amazon.com',
    'maxItems': 50,
    'fetchProductDetails': True,
})

for product in client.dataset(run['defaultDatasetId']).iterate_items():
    print(product['asin'], product['title'], product['price'])
```

### Use cases

#### Amazon competitor price monitoring

Track competitor ASINs on a schedule. Reuse one `stateKey`, then send detected changes to a webhook, database, spreadsheet, or notification workflow.

#### Product and niche research

Search related keywords and filter by price, rating, or review count. Sort results by opportunity score, discount, demand, or search position.

#### Catalog enrichment

Turn ASINs into structured records with titles, brands, prices, availability, features, images, ratings, and canonical URLs.

#### Sponsored product tracking

Keep `includeSponsored` enabled and analyze `isSponsored`, `searchQuery`, and `searchPosition` for advertised products found in Amazon search.

#### Automated price-drop alerts

Schedule recurring runs with `onlyPriceChanges` after the baseline. Connect runs to Slack, email, Discord, Make, Zapier, n8n, or your own webhook.

### Accuracy and performance tips

- Use ASINs or URLs when products are already known. Direct lookup is faster and cheaper than keyword discovery.
- Disable `fetchProductDetails` when lightweight search-result data is sufficient.
- Start with 10 or 50 products, inspect the output, then scale the run.
- Keep concurrency conservative for reliable Amazon requests.
- Match `marketplace` to the product URLs and pricing region needed.
- Prices, stock, delivery messages, and Prime status can vary by session and delivery location.

### Pricing

- **Actor start:** $0.02 per run.
- **Product result:** $6.00 per 1,000 dataset items.
- **Platform usage:** included for Actor users.

Users can set a maximum charge for each run in Apify Console or through the API.

### FAQ

#### Does it require an Amazon API key?

No. The Actor collects publicly displayed data without the Amazon Product Advertising API.

#### Can it scrape multiple Amazon countries?

Yes. Select one of 12 marketplace domains per run. Use separate tasks to compare one ASIN across countries.

#### Can it monitor Amazon prices?

Yes. Enable `monitorPrices` and reuse the same `stateKey` to compare each current price with the previous run.

#### Does it scrape individual Amazon reviews?

It extracts the displayed rating and review count. It does not currently return individual review text or reviewer profiles.

#### Can it find sponsored products?

Yes. Search results include `isSponsored` when a Sponsored label is detected. Set `includeSponsored` to `false` to exclude those listings.

#### Why are some fields null?

Amazon pages vary by product, marketplace, stock, session, and layout. A field remains `null` when no reliable value is displayed.

#### Is output deduplicated?

Yes. Results are deduplicated by ASIN within each run.

### Responsible use

Scrape only publicly available data and comply with applicable laws, Amazon's terms, and privacy requirements. This Actor is an independent tool and is not affiliated with, endorsed by, or sponsored by Amazon.

# Actor input Schema

## `searchQueries` (type: `array`):

Search Amazon by one or more product keywords.

## `productUrls` (type: `array`):

Amazon /dp/ product URLs.

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

Amazon ASINs to fetch directly.

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

Select the Amazon country storefront and matching proxy location.

## `maxItems` (type: `integer`):

Hard cap on unique output products.

## `maxPagesPerQuery` (type: `integer`):

Maximum Amazon search-result pages to visit for each keyword.

## `fetchProductDetails` (type: `boolean`):

Visit product pages for stock, features, brand, and image gallery.

## `includeSponsored` (type: `boolean`):

Keep paid placements found in Amazon search results.

## `minRating` (type: `number`):

Only save products at or above this star rating.

## `minReviews` (type: `integer`):

Only save products with at least this many ratings or reviews.

## `minPrice` (type: `number`):

Optional minimum current price in the marketplace currency.

## `maxPrice` (type: `number`):

Optional maximum current price in the marketplace currency.

## `monitorPrices` (type: `boolean`):

Remember prices across runs and calculate changes.

## `onlyPriceChanges` (type: `boolean`):

Output only products whose price changed since the previous monitor run.

## `stateKey` (type: `string`):

Use a stable unique key for each recurring price-monitor task.

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

Number of product detail pages fetched in parallel.

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

Marketplace-matched residential proxy is used by default.

## `debugMode` (type: `boolean`):

Enable additional diagnostic logging.

## Actor input object example

```json
{
  "searchQueries": [
    "wireless earbuds"
  ],
  "marketplace": "amazon.com",
  "maxItems": 50,
  "maxPagesPerQuery": 3,
  "fetchProductDetails": true,
  "includeSponsored": true,
  "minRating": 0,
  "minReviews": 0,
  "monitorPrices": false,
  "onlyPriceChanges": false,
  "stateKey": "default",
  "maxConcurrency": 3,
  "debugMode": false
}
```

# Actor output Schema

## `products` (type: `string`):

Unique Amazon product records with pricing, demand, stock, media, and monitoring fields.

## `summary` (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 = {
    "searchQueries": [
        "wireless earbuds"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("groupoject/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 = { "searchQueries": ["wireless earbuds"] }

# Run the Actor and wait for it to finish
run = client.actor("groupoject/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 '{
  "searchQueries": [
    "wireless earbuds"
  ]
}' |
apify call groupoject/amazon-product-intelligence --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,groupoject/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/qjFUAnanTpm7KcTWd/builds/3ufYSLzPc4Jd6sEIe/openapi.json