# Amazon Product Intelligence (`sincere_developer/amazon-product-intelligence`) Actor

Amazon Product Intelligence gets the job done with reliable prices, stock, ratings, rankings, variants, offers, sellers, and monitoring at a great price. Choose only the data you need so you won't pay for extra features. If anything isn’t right, the developer is ready to help immediately.

- **URL**: https://apify.com/sincere_developer/amazon-product-intelligence.md
- **Developed by:** [Skerdi Shkoza](https://apify.com/sincere_developer) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.80 / 1,000 fast product 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?

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

### Amazon product data for research, monitoring, and competitive intelligence

Turn Amazon ASINs, product URLs, keywords, categories, best-seller pages, and storefronts into structured product data you can use immediately.

Amazon Product Intelligence can collect **prices, stock, ratings, reviews, Best Sellers Rank, Buy Box data, variants, product content, images, offers, seller profiles, and location-aware changes** across seven Amazon marketplaces. Choose a lightweight mode for affordable discovery or request deeper product and competitor intelligence only when you need it.

The Actor is designed for analysts, brands, agencies, sellers, developers, and automation teams that need reliable Amazon data without building and maintaining their own scraper.

### What you can do

- Track product prices, discounts, coupons, stock, and delivery information.
- Discover products from Amazon searches, categories, best-seller pages, and storefronts.
- Filter discovery results before opening product pages and spending more.
- Analyze ratings, review counts, Best Sellers Rank, demand signals, and Buy Box ownership.
- Find product variants and optionally fetch each child variant's price and availability.
- Research competing offers, fulfillment type, sellers, and public seller information.
- Compare a new run with an earlier dataset to identify meaningful product changes.
- Export results to JSON, CSV, Excel, or another Apify integration.
- Run manually, through the API, on a schedule, or as part of an automation.

### Choose the right mode

The Actor lets you match the data depth to your budget. You do not need to pay for full competitive intelligence when a listing-level result is enough.

| Mode and profile | Best for | Included data | Relative cost |
| --- | --- | --- | --- |
| **Fast** | Low-cost discovery and exact ASIN lookups | Listing price, availability signals, rating, review count, position, Prime and sponsored status | **$0.80 / 1,000 successful results** |
| **Detail + Essential** | Price and stock collection | Product-page pricing, availability, delivery, ratings and reviews | Low detail tier |
| **Detail + Catalog** | Complete product datasets | Essential data plus BSR, demand, Buy Box, variants, content, specifications and media | Standard |
| **Intelligence + Competitive** | Competitor and seller research | Catalog data plus offers and public seller profiles | Highest depth |
| **Custom** | Precise cost control | Only the blocks you select | Depends on selection |
| **Monitor** | Recurring price and product tracking | Current detail data plus comparison with an earlier dataset | Per completed check |

If you are unsure, start with **Detail + Catalog** for a complete product record. Use **Fast** for broad discovery, then run Detail or Intelligence only on the products worth deeper analysis.

### How pricing works

Amazon Product Intelligence uses pay-per-event pricing. The exact current prices are displayed in the **Pricing** section of the Actor page before you start a run.

**Fast launches at $0.0008 per successful listing result — $0.80 per 1,000.** It is the price-leading option for product discovery, large keyword lists, and lightweight ASIN checks. Blocked, missing, and invalid inputs do not generate a successful-product charge.

- Fast discovery uses the lower-priced `product-basic` event for each successful listing result.
- Essential detail results use `product-essential`.
- Catalog and other full product results use `product-detail`.
- Monitoring uses `product-check` for each completed product check.
- Deep variant requests use `variant-detail` for each successfully fetched child.
- Competitive mode can add `offer` and `seller-detail` events for the extra results it delivers.
- A failed, blocked, invalid, or not-found product is not charged as a successful product result.

You can control spending with `maxProducts`, `maxSearchPages`, `maxVariants`, and `maxOffersPerProduct`. Apify also lets you set a **maximum charge per run**, so the Actor stops adding paid work when your chosen limit is reached.

#### How the modes reduce cost

Fast mode returns product discovery data directly from Amazon listing pages without opening detail pages. One keyword page can produce many billable results, which is what makes the $0.80-per-1,000 tier sustainable. It uses 512 MB by default, caps retries, and stays on the economical automatic proxy tier unless you explicitly enable `fastResidentialFallback`.

Essential retrieves only the most frequently needed detail blocks. Catalog adds complete merchandising data. Competitive makes additional requests for offers and sellers, so it should be enabled only when those insights are valuable to you. Custom mode gives you the most precise control.

For direct ASINs and product URLs, Fast mode searches Amazon for the exact ASIN and returns only the matching listing card. It still uses the `product-basic` event and never silently upgrades the request to a more expensive detail event. Choose Essential or Catalog when you need product-page fields.

### Quick start

1. Select the Amazon marketplace.
2. Add ASINs, Amazon URLs, keywords, or an existing Apify dataset.
3. Choose a mode and data profile.
4. Set `maxProducts` and any filters or optional limits.
5. Click **Start** and open the dataset when the run finishes.

#### Complete product example

```json
{
  "marketplace": "US",
  "asins": ["B0CX23V2ZK"],
  "mode": "detail",
  "dataProfile": "catalog",
  "variantMode": "discover",
  "postalCode": "10001",
  "requireLocation": true
}
```

#### Affordable filtered discovery

This example searches Amazon first, removes products that do not match, and fetches Essential data only for the remaining products.

```json
{
  "marketplace": "US",
  "keywords": ["electric kettle"],
  "mode": "detail",
  "dataProfile": "essential",
  "discoveryFilters": {
    "minPrice": 20,
    "maxPrice": 80,
    "minRating": 4.3,
    "minReviewCount": 100,
    "primeOnly": true,
    "sponsoredPolicy": "exclude",
    "minBoughtInPastMonth": 500,
    "minDiscountPercent": 10
  },
  "maxProducts": 100
}
```

#### Competitive intelligence example

```json
{
  "marketplace": "DE",
  "keywords": ["wasserkocher edelstahl"],
  "mode": "intelligence",
  "dataProfile": "competitive",
  "maxOffersPerProduct": 10,
  "maxProducts": 100
}
```

#### Price monitoring example

Run a Catalog dataset first, then use its dataset ID as the comparison baseline.

```json
{
  "marketplace": "US",
  "asins": ["B0CX23V2ZK"],
  "mode": "monitor",
  "dataProfile": "catalog",
  "compareWithDatasetId": "PREVIOUS_DATASET_ID"
}
```

### Filter products before detail collection

Discovery filters work with keywords, category URLs, best-seller pages, and storefronts. You can combine:

- Minimum and maximum price
- Minimum rating
- Minimum review count
- Prime-only products
- Include, exclude, or keep only sponsored results
- Minimum bought-in-past-month signal
- Minimum discount percentage

When a requested signal is missing from a listing card, the product is excluded rather than guessed. The run summary reports how many products were filtered and why. Direct ASINs and direct product URLs bypass discovery filters.

### Product variants

Choose the variant depth that matches your use case:

- `none`: Skip variants.
- `discover`: Return child ASINs and option combinations from the parent page without extra child requests.
- `price`: Fetch current price and availability for each selected child.
- `full`: Produce full product records for selected child variants.

Use `maxVariants` to place a hard limit on deep child requests. Variant discovery is the best starting point because it does not need separate child-page requests.

### Supported Amazon marketplaces

| Marketplace | Domain | 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 |

Reliable modes use marketplace-matched proxy locations so Amazon can return the appropriate catalog and currency. Product URLs from another supported marketplace are detected and reported correctly.

### What the output contains

Every successful product record includes identity, source, retrieval, location, and quality information. Depending on the selected profile, it can also contain:

- Current, list, unit, deal, coupon, and Subscribe & Save pricing
- Stock state, delivery message, shipping information, and seller
- Rating, review count, and rating histogram
- Best Sellers Rank and bought-in-past-month lower bound
- Buy Box seller, seller ID, and AMZ/FBA/FBM classification
- Variant dimensions, child ASINs, prices, and availability
- Bullets, specifications, breadcrumb, and product description
- Full-resolution product images and video references
- Offer condition, item price, shipping, landed price, Prime, and fulfillment
- Public seller rating, feedback windows, business fields, and source URL
- Monitoring changes such as price, discount, stock, rating, review count, Buy Box, and seller count

The output schema stays stable across profiles. Blocks you did not request use `NOT_APPLICABLE`, which means they were intentionally skipped to match your selected data depth. It does not mean the Actor failed.

### Data quality you can understand

Missing values are not all the same. Each data block reports a clear status:

- `EXTRACTED`: The value was successfully collected.
- `NOT_PRESENT`: The Amazon page loaded, but Amazon did not display the value.
- `PARSER_MISS`: The page loaded, but the value could not be read reliably.
- `NOT_APPLICABLE`: The block was not included in your selected profile.
- `REQUIRES_LOCATION`: A required delivery location could not be verified.

This distinction prevents a missing Amazon value from being confused with a scraping problem. Each row also contains quality warnings and a completeness score.

### Location-aware prices and monitoring

Amazon prices, availability, and delivery promises can change by destination. Add `postalCode` and `deliveryCountry` to request a location, and enable `requireLocation` when an unverified location should not count as a successful price observation.

Monitoring baselines are separated by marketplace, ASIN, and resolved postal code. This prevents observations from different locations from being compared as if they represented the same buyer experience.

### Reliability and large runs

The Actor uses compressed requests, reusable sessions, bounded retries, proxy rotation, marketplace-specific residential routing for full product modes, and a circuit breaker that reduces work during a block storm. Fast mode has a separate cost-protected network path; enable its optional residential fallback only when the cheaper path is being blocked. Every input is accounted for as either a successful product or a structured failure row, so inputs do not silently disappear.

The pipeline is tested with 1,000-product batches and supports larger bounded input lists. For large ASIN lists, you can paste raw JSON items or select an existing Apify dataset. The Actor uses controlled concurrency, selects 512 MB for Fast runs and 1 GB for full product runs by default, and applies your product and spending limits before scheduling more work.

Amazon can still change pages, remove products, display CAPTCHAs, or temporarily restrict access. When that happens, the Actor reports the reason instead of returning an apparently successful row full of empty values.

### Common use cases

- Amazon price and availability monitoring
- Competitor catalog and assortment research
- Buy Box and fulfillment analysis
- Product, brand, and seller research
- SEO rank and sponsored-position tracking
- Discount and deal discovery
- Variant and assortment mapping
- Product content audits
- Review and demand-signal analysis
- Scheduled datasets for dashboards, alerts, and internal tools

### FAQ

#### Can I use ASINs and URLs together?

Yes. You can mix ASINs, product URLs, discovery URLs, keywords, and raw JSON items. Duplicate marketplace-ASIN-location combinations are merged by default.

#### Can I scrape more than 1,000 products?

Yes. `maxProducts` defaults to 1,000 and can be increased. Large jobs take longer, so use reasonable page and variant limits and choose Fast or Essential when full Catalog data is unnecessary.

#### Why are some fields marked NOT_APPLICABLE?

The field was intentionally excluded by your selected data profile. Choose Catalog, Competitive, or a Custom profile containing that block if you need it.

#### Does the Actor calculate estimated sales?

The Actor returns Amazon's displayed bought-in-past-month signal as a lower bound when available. It does not invent sales estimates from unsupported assumptions.

#### Can I use my own proxies?

Yes. Advanced users can provide external proxy URLs through `proxyConfiguration`. Otherwise, leave Apify Proxy enabled and the Actor manages the reliable defaults.

#### Can I automate recurring checks?

Yes. Use Apify schedules, the API, webhooks, Make, Zapier, or another integration. Monitor mode can compare the current run with a previous dataset.

### Support

This Actor is actively maintained. If a result does not look right, open an issue from the Actor page and include the run ID, marketplace, and affected ASIN when possible. The developer will review it quickly and help you resolve the problem.

Feature requests and custom Amazon data workflows are also welcome.

# Changelog

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

# Actor input Schema

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

fast = economical listing-card data; direct ASINs and product URLs are resolved through an exact-ASIN Amazon search without opening the product page. detail = product page. intelligence = detail plus selected competitive blocks. monitor = compare current product state with a previous dataset.

## `dataProfile` (type: `string`):

Choose the result depth and base billing event. Essential returns price, availability and ratings with product-essential billing. Catalog adds BSR, Buy Box, variants, content and media with product-detail billing. Competitive also enables offers and seller profiles, which use their own events. Custom lets you choose individual blocks.

## `dataBlocks` (type: `array`):

Used when Data profile is Custom. Identity, source, location and quality metadata are always returned. Offers and seller profiles have separate per-result billing events.

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

Which Amazon marketplace to use. Product URLs from a different marketplace are respected and reported per record.

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

One or more 10-character ASINs, e.g. B0CX23V2ZK. Invalid entries are returned as INVALID_INPUT rows rather than dropped.

## `urls` (type: `array`):

Product, search, category, best-seller, storefront or seller URLs.

## `keywords` (type: `array`):

Search keywords. Each keyword is crawled up to 'Max search pages'.

## `discoveryFilters` (type: `object`):

Filter keyword, category, best-seller and storefront cards before detail pages are queued or billed. Direct ASIN and product URL inputs bypass these filters. When a requested signal is missing from a card, the card is excluded rather than guessed.

## `items` (type: `array`):

Advanced bulk input. Each object contains exactly one of asin, url or keyword. Optional per-row marketplace is supported for ASINs and keywords.

## `datasetId` (type: `string`):

Read inputs from an existing Apify dataset instead of pasting them.

## `datasetField` (type: `string`):

Which field of the input dataset holds the ASIN or URL.

## `deliveryCountry` (type: `string`):

Optional delivery context. Amazon shows different prices and delivery promises by location.

## `postalCode` (type: `string`):

Optional postal code, e.g. 10001. Applied once per session and verified from the page. Every record reports whether it was applied.

## `requireLocation` (type: `boolean`):

When on, a product whose delivery location could not be applied is returned as REQUIRES_LOCATION instead of a success with an unlocalized price. Recommended for price tracking.

## `variantMode` (type: `string`):

none = skip. discover = child ASINs and option matrix at no extra request cost (default). price = also fetch each child's current price and stock. full = full detail per child.

## `includeOffers` (type: `boolean`):

Fetch the bounded All Offers surface for each product. Adds requests and offer billing events.

## `maxOffersPerProduct` (type: `integer`):

Hard limit on offers retained and billed for each product.

## `includeSellerDetails` (type: `boolean`):

Fetch public seller profile, feedback and business fields for discovered sellers. No private identity inference.

## `maxProducts` (type: `integer`):

Hard ceiling on products processed in this run.

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

Hard pagination limit for each keyword, category, best-seller or storefront discovery input.

## `maxVariants` (type: `integer`):

Ceiling on deep child fetches. Discovery is unaffected.

## `maxRetries` (type: `integer`):

Maximum bounded retry count before a fetch is reported as failed or blocked.

## `deduplicate` (type: `boolean`):

Deduplicate on marketplace + ASIN + resolved delivery location. Discovery sources are merged into discoveredFrom rather than emitted twice.

## `allowResidentialFallback` (type: `boolean`):

Detail, Intelligence and Monitor modes use marketplace-pinned residential proxies by default for reliable localized results. Turn this off to try the cheaper automatic tier and accept a higher block rate.

## `fastResidentialFallback` (type: `boolean`):

Off by default to protect the economy price. When enabled, a blocked Fast request may use a residential proxy on its single retry, improving recovery while increasing platform cost.

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

Amazon requires proxies. High-volume users can supply their own external proxy URLs here, which keeps that traffic off the platform bill entirely.

## `schemaVersion` (type: `string`):

Echo of the output schema your integration expects. A mismatch produces a run warning, never a failure.

## `compareWithDatasetId` (type: `string`):

Prior Amazon Product Intelligence dataset used for field-level monitoring changes. Required in monitor mode.

## Actor input object example

```json
{
  "mode": "detail",
  "dataBlocks": [],
  "marketplace": "US",
  "asins": [
    "B0CX23V2ZK"
  ],
  "urls": [],
  "keywords": [],
  "discoveryFilters": {},
  "items": [],
  "datasetField": "asin",
  "requireLocation": false,
  "variantMode": "discover",
  "includeOffers": false,
  "maxOffersPerProduct": 10,
  "includeSellerDetails": false,
  "maxProducts": 1000,
  "maxSearchPages": 5,
  "maxVariants": 50,
  "maxRetries": 3,
  "deduplicate": true,
  "allowResidentialFallback": true,
  "fastResidentialFallback": false,
  "proxyConfiguration": {
    "useApifyProxy": true
  },
  "schemaVersion": "1.5"
}
```

# Actor output Schema

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

Schema-versioned product intelligence rows and explicit failure rows.

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

Accounting, monitoring, proxy health, billing and truncation metrics for the run.

# 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 = {
    "asins": [
        "B0CX23V2ZK"
    ]
};

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

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

```

## MCP server setup

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