# Amazon ASINs Scraper (`w3crawler/amazon-asins-scraper`) Actor

Scrape Amazon product details by ASIN code or direct product URL across supported Amazon marketplaces. Extracts title, price, ratings, review count, availability, images, and optionally customer reviews. Ideal for product research, price tracking, and competitive marketplace analysis.

- **URL**: https://apify.com/w3crawler/amazon-asins-scraper.md
- **Developed by:** [w3crawler](https://apify.com/w3crawler) (community)
- **Stats:** 2 total users, 1 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.99 / 1,000 asin records

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

## Amazon ASINs Scraper

Amazon ASINs Scraper extracts rich, publicly visible Amazon product observations from ASINs or product URLs. It supports the India, US, UK, Germany, Japan, Canada, Australia, and Brazil marketplaces.

The dataset contains product data only. Run metrics and counts are kept in the key-value store; failure details stay in the run logs, so fields such as `fieldCoverage`, `dataQuality`, `recordId`, `status`, `success`, request counters, actor metadata, and proxy metadata are not mixed into product rows.

### Dataset fields

| Field | Description |
| --- | --- |
| `asin`, `title`, `url`, `canonicalUrl`, `sourceUrl` | Product identity and reproducible public source URLs |
| `marketplace`, `country`, `userLocale` | Marketplace context |
| `price`, `listPrice`, `offerUrl`, `seller` | Public offer and seller information; prices contain `value` and ISO `currency` |
| `inStock`, `inStockText` | Availability signal and visible availability text |
| `brand`, `manufacturer`, `author`, `description` | Public product identity and description fields |
| `stars`, `reviewsCount`, `hasReviews`, `reviewsLink` | Rating and review signals |
| `breadCrumbs`, `features`, `attributes`, `productOverview` | Public navigation, bullet, and specification data |
| `thumbnailImage`, `galleryThumbnails`, `highResolutionImages`, `videosCount` | Product-scoped public media |
| `reviews` | Bounded public JSON-LD review summaries when `extractReviews` is enabled |
| `sourceStructuredData`, `structuredDataTypes` | Parsed public JSON-LD evidence |
| `pageText`, `wordCount`, `htmlLength` | Bounded page text and response size context |
| `scrapedAt` | ISO timestamp for the observation |

The dataset contains only source-backed product observations. A readable product page that exposes no usable product data completes with `status: SUCCEEDED` and `dataStatus: NO_RESULTS`; request or input failures with no saved product fail the run, and access boundaries with no saved product use `FAILED`. If some products were saved before another target failed or was blocked, the run succeeds as `SUCCEEDED` with `dataStatus: PARTIAL` and keeps those products. Failure details stay in the run logs; `OUTPUT_SUMMARY` contains numeric counts only.

### Input examples

#### 1. Multiple ASINs with product details

```json
{
  "mode": "asin",
  "country": "in",
  "locale": "en-IN",
  "asins": ["B0EXAMPLE1", "B0EXAMPLE2"],
  "maxItems": 2,
  "includeMedia": true,
  "extractReviews": true,
  "maxReviews": 5,
  "dedupe": true
}
```

#### 2. Direct product URLs

```json
{
  "mode": "productUrl",
  "country": "com",
  "productUrls": [
    "https://www.amazon.com/dp/B0EXAMPLE1",
    "https://www.amazon.com/dp/B0EXAMPLE2"
  ],
  "includeMedia": false,
  "maxItems": 2
}
```

#### 3. Developer options and ordinary Apify Proxy

```json
{
  "mode": "asin",
  "country": "in",
  "asins": ["B0EXAMPLE1", "B0EXAMPLE2"],
  "requestDelayMs": 800,
  "maxConcurrency": 2,
  "maxRequestRetries": 3,
  "requestTimeoutSecs": 45,
  "maxResponseBytes": 20000000,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyCountry": "IN"
  }
}
```

`requestTimeoutMs`, `timeoutSecs`, `timeoutMs`, `minDelayMs`, `pageDelayMs`, `concurrency`, `maxRetries`, `maxBytes`, and `maxResults` are accepted compatibility aliases. Inputs are bounded and unsupported keys are rejected.

Proxy routing is ordinary network routing for reliability or geographic availability. The Actor does not log in, solve CAPTCHAs, spoof fingerprints, rotate stealth identities, bypass access controls, or access private APIs. Amazon challenge pages, explicit HTTP access controls, marketplace redirects, and timeouts are logged and summarized as operational failures; they never create placeholder products or diagnostic dataset rows.

#### 4. Deterministic offline QA

```json
{
  "mode": "asin",
  "country": "in",
  "asins": [
    "B0TEST0001"
  ],
  "maxItems": 1,
  "includeMedia": true,
  "extractReviews": true,
  "maxReviews": 5
}
```

When `fixtureFile` or `fixtureFiles` is provided, the Actor parses the bundled HTML fixtures instead of making live requests. This supports deterministic QA runs; standard calls without fixture inputs use live public pages.

### Example product output

```json
{
  "asin": "B0TEST0001",
  "title": "Northstar Stainless Steel Bottle 750ml",
  "url": "https://www.amazon.in/dp/B0TEST0001",
  "canonicalUrl": "https://www.amazon.in/dp/B0TEST0001",
  "sourceUrl": "https://www.amazon.in/dp/B0TEST0001",
  "marketplace": "amazon.in",
  "country": "in",
  "price": { "value": 899, "currency": "INR" },
  "listPrice": { "value": 1099, "currency": "INR" },
  "inStock": true,
  "brand": "Northstar",
  "manufacturer": "Northstar Home",
  "stars": 4.6,
  "reviewsCount": 128,
  "hasReviews": true,
  "features": ["Food-grade stainless steel", "Leak-resistant lid"],
  "thumbnailImage": "https://images.example.com/northstar-bottle-main.jpg",
  "galleryThumbnails": ["https://images.example.com/northstar-bottle-main.jpg"],
  "highResolutionImages": ["https://images.example.com/northstar-bottle-main.jpg"],
  "reviews": [
    {
      "position": 1,
      "reviewer": "Asha",
      "rating": 5,
      "title": "Keeps water cold",
      "body": "The bottle is sturdy and easy to carry."
    }
  ],
  "productDataAvailable": true,
  "structuredDataTypes": ["Product", "Review"],
  "scrapedAt": "2026-09-07T00:00:00.000Z"
}
```

### Local development and validation

```bash
npm install
apify validate-schema
apify run --purge --input-file .actor/input.json
npm run validate
```

The local dataset is written under `storage/datasets/default/`. `OUTPUT_SUMMARY` contains run status, numeric counts, and bounded request metrics; failure details stay in the run logs. `diagnosticItems` is always zero, while `diagnosticCount` counts operational failures. The Actor preserves input order while processing targets with bounded concurrency.

Use only public pages and comply with Amazon's terms, robots guidance, rate limits, and applicable law.

Run summaries include the required `status`, `runStatus`, and `dataStatus` fields. `status` and `runStatus` are `SUCCEEDED` when source-backed rows were saved or a run completed cleanly with no matches; they are `FAILED` only when a real failure occurs before any rows are saved. `dataStatus` is `COMPLETE`, `PARTIAL`, `NO_RESULTS`, or `FAILED`. Failure details stay in the run logs; key-value summaries retain counts only.

# Changelog

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

# Actor input Schema

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

Choose whether the input list contains ASINs or full public Amazon product URLs.

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

Amazon Standard Identification Numbers to process when mode is asin.

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

Public Amazon product URLs to process when mode is productUrl.

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

Marketplace used for ASIN URLs and locale defaults.

## `locale` (type: `string`):

Accept-Language value sent to public Amazon pages.

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

Maximum deduplicated input targets and dataset rows emitted.

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

Compatibility alias for maxItems.

## `dedupe` (type: `boolean`):

Skip duplicate marketplace/ASIN pairs before requests.

## `includeMedia` (type: `boolean`):

Include public product images when exposed by JSON-LD or the product image gallery.

## `extractReviews` (type: `boolean`):

Include bounded review summaries found in public Product JSON-LD.

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

Maximum reviews retained when extractReviews is enabled.

## `requestTimeoutSecs` (type: `integer`):

Maximum duration for each public Amazon request.

## `timeoutSecs` (type: `integer`):

Compatibility alias for requestTimeoutSecs.

## `requestTimeoutMs` (type: `integer`):

Compatibility alias converted to seconds.

## `timeoutMs` (type: `integer`):

Compatibility alias converted to seconds.

## `requestDelayMs` (type: `integer`):

Delay before each live public request.

## `minDelayMs` (type: `integer`):

Compatibility alias for requestDelayMs.

## `pageDelayMs` (type: `integer`):

Compatibility alias for requestDelayMs.

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

Maximum simultaneous target requests.

## `concurrency` (type: `integer`):

Compatibility alias for maxConcurrency.

## `maxRequestRetries` (type: `integer`):

Retries for timeouts, transient HTTP failures, and rate limits. Access challenges are not bypassed.

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

Compatibility alias for maxRequestRetries.

## `maxResponseBytes` (type: `integer`):

Reject unusually large public responses before parsing.

## `maxBytes` (type: `integer`):

Compatibility alias for maxResponseBytes.

## `userAgent` (type: `string`):

Optional transparent identifying user-agent string.

## `fixtureFile` (type: `string`):

Optional relative path to an HTML fixture bundled with the Actor. When set, the fixture page is parsed instead of requesting a live public Amazon page. Used for deterministic QA runs of the Actor's own fixtures.

## `fixtureFiles` (type: `array`):

Optional relative paths to HTML fixtures bundled with the Actor, used in request order when no live public page is requested.

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

Optional ordinary Apify Proxy or public HTTP(S) routing. No stealth, CAPTCHA solving, or access-control bypass is attempted.

## Actor input object example

```json
{
  "mode": "asin",
  "country": "in",
  "locale": "en-IN",
  "maxItems": 50,
  "dedupe": true,
  "includeMedia": true,
  "extractReviews": false,
  "maxReviews": 10,
  "requestTimeoutSecs": 120,
  "requestDelayMs": 500,
  "maxConcurrency": 3,
  "maxRequestRetries": 2,
  "maxResponseBytes": 15000000
}
```

# Actor output Schema

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

Only source-backed Amazon product observations. Failed, blocked, or empty requests do not add dataset rows.

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

Counts, bounded request metrics, and options used by 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 = {};

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

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

```

## MCP server setup

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