# Amazon Product Price & Availability Tracker (`techionik9993/amazon-product-price-availability-tracker`) Actor

Extract Amazon product prices, availability, ratings, reviews, seller, brand, images, and buy box metadata from product URLs or ASINs.

- **URL**: https://apify.com/techionik9993/amazon-product-price-availability-tracker.md
- **Developed by:** [Techionik](https://apify.com/techionik9993) (community)
- **Categories:** E-commerce
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

from $6.00 / 1,000 product results

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/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use 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 Price & Availability Tracker

Extract Amazon product metadata, visible prices, availability, ratings, review counts, seller names, brand names, images, and product bullet points from Amazon product URLs or ASINs.

This Actor is designed for e-commerce monitoring, competitor research, affiliate catalog checks, and price intelligence workflows. It accepts product detail page URLs and/or ASINs, visits the public product pages, parses visible product data, and saves structured results to the default Apify dataset.

### Features

- Extract product data from Amazon product URLs or ASINs
- Supports Amazon US, UK, CA, DE, FR, IT, ES, IN, AU, and JP marketplaces for ASIN inputs
- Captures visible price, currency, availability, rating, reviews, seller, brand, image, and bullet points
- Detects captcha, robot checks, unavailable pages, and empty results
- Retries blocked pages with a fresh crawler session before saving a blocked result
- Supports Apify Proxy and custom proxy configuration
- Conservative defaults for lower block risk
- Saves debug HTML to the key-value store when enabled
- Produces clean dataset output for exports and integrations

### Use Cases

- Monitor competitor product prices
- Track product availability and stock status
- Build affiliate product feeds
- Audit Amazon listings
- Watch rating and review count changes
- Enrich e-commerce dashboards with public product metadata

### Input

Paste Amazon product URLs or ASINs into the `products` field. You can mix both in one run.

```json
{
  "products": [
    "B08PVPTNZL",
    "https://www.amazon.com/dp/B08KTZ8249"
  ],
  "marketplace": "US",
  "maxConcurrency": 3,
  "maxRequestRetries": 3,
  "requestTimeoutSecs": 45,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  },
  "saveHtmlToKeyValueStore": false,
  "retryBlockedPages": true
}
````

#### Input Fields

- `products`: Amazon product detail page URLs or 10-character ASINs.
- `marketplace`: Marketplace used for ASIN inputs.
- `proxyConfiguration`: Apify Proxy or custom proxy settings. Residential proxies are recommended.
- `maxConcurrency`: Number of product pages processed at the same time. Default `3` is the recommended balance of speed and reliability.
- `maxRequestRetries`: Number of retries for failed requests.
- `requestTimeoutSecs`: Timeout for each product page.
- `retryBlockedPages`: Retries captcha, robot check, and automated access pages with a fresh crawler session before returning a blocked result.
- `saveHtmlToKeyValueStore`: Saves blocked or empty HTML pages for debugging.
- `productUrls` and `asins`: Legacy optional fields still supported for API users who prefer separate lists.

### Output

Each dataset item represents one requested product page.

```json
{
  "asin": "B09B8V1LZ3",
  "title": "Echo Dot (5th Gen, 2022 release) | Smart speaker",
  "price": 49.99,
  "currency": "USD",
  "priceText": "$49.99",
  "availability": "In Stock",
  "inStock": true,
  "rating": 4.7,
  "reviewCount": 128456,
  "sellerName": "Amazon.com",
  "brand": "Amazon",
  "imageUrl": "https://example.com/echo-main.jpg",
  "bulletPoints": [
    "Improved audio experience",
    "Alexa voice assistant"
  ],
  "url": "https://www.amazon.com/dp/B09B8V1LZ3",
  "status": "ok",
  "blockedReason": null,
  "scrapedAt": "2026-06-10T16:00:00.000Z"
}
```

#### Status Values

- `ok`: Product data was extracted.
- `blocked`: Amazon returned a captcha, robot check, or automated access page.
- `empty`: The request succeeded but no product data was found.
- `failed`: The request failed after all retries.

### Limitations

Amazon actively limits automated access and may show captcha, robot checks, unavailable pages, or different layouts by region. This Actor detects those pages, rotates sessions, and retries blocked requests before returning a final `blocked` result. For best reliability, use Apify Proxy with residential proxies, keep concurrency between `2` and `4`, and split very large jobs into smaller batches. This Actor only extracts publicly visible product page data and does not log in, bypass paywalls, solve captchas, or access private account data.

No Amazon scraper can guarantee 100% successful extraction for every product because blocking, delivery-location restrictions, unavailable listings, and layout changes are controlled by Amazon. The Actor is designed to return the cleanest possible result status for every input instead of silently mixing blocked pages with valid product data.

Always make sure your use of scraped data follows Amazon's terms, applicable laws, and your own compliance requirements.

### Pricing Recommendation

Recommended model: **Pay per event (PPE) / pay per result**.

Reason: users receive direct value per product record, and Amazon scraping can require proxy and retry costs. A per-result model keeps pricing aligned with output and scales better than a flat monthly rental model.

Recommended Store pricing setup:

- Pricing model: **Pay per event**
- Primary event: **Default dataset item** / `apify-default-dataset-item`
- Price: **$0.006 per dataset item** (**$6.00 per 1,000 product records**)
- Start event: keep Apify's synthetic `apify-actor-start` at the default low price
- Platform usage: start with usage costs passed to users while collecting cost data, then turn it off only if profit remains healthy

Why this is profitable: Amazon product scraping has higher proxy and retry cost than simple websites. At $6 per 1,000 dataset items, the Actor has room for residential proxy usage, retries, Apify commission, and normal failed/empty product rows while staying easy for buyers to understand.

### Marketplace Text

#### Short Description

Extract Amazon product metadata, visible prices, availability, ratings, reviews, seller, brand, image, and stock status from product URLs or ASINs.

#### Long Description

Amazon Product Price & Availability Tracker helps e-commerce teams, sellers, affiliates, and analysts monitor public Amazon product pages at scale. Add product URLs or ASINs, choose the marketplace, and get structured product records in an Apify dataset ready for export to JSON, CSV, Excel, Google Sheets, or API integrations.

The Actor includes retries, proxy support, timeout handling, captcha/block detection, empty result handling, and clean status fields so you can separate successful records from blocked or unavailable pages.

#### Search Keywords / Tags

amazon scraper, amazon price scraper, amazon product scraper, amazon availability tracker, amazon asin scraper, ecommerce scraper, price monitoring, product data, competitor research, apify amazon actor

### Local Development

```bash
npm install
npm test
npm start
```

For local Actor runs, create `storage/key_value_stores/default/INPUT.json` with your sample input. Do not store secrets in the project.

# Actor input Schema

## `products` (type: `array`):

Paste Amazon product URLs or 10-character ASINs. You can mix both.

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

Used when an input item is an ASIN instead of a full URL.

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

Residential proxies are strongly recommended for Amazon.

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

How many products to process at once. Higher is faster but may increase proxy retries and block risk.

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

Optional legacy field. Prefer the main Amazon product URLs or ASINs field above.

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

Optional legacy field. Prefer the main Amazon product URLs or ASINs field above.

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

How many times to retry failed or blocked requests.

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

Maximum time allowed for one product page request.

## `retryBlockedPages` (type: `boolean`):

Retries captcha and robot-check pages with a fresh session before returning a blocked result.

## `saveHtmlToKeyValueStore` (type: `boolean`):

Saves blocked or empty HTML pages to the key-value store for debugging.

## Actor input object example

```json
{
  "products": [
    "B08PVPTNZL",
    "https://www.amazon.com/dp/B08KTZ8249"
  ],
  "marketplace": "US",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  },
  "maxConcurrency": 3,
  "maxRequestRetries": 3,
  "requestTimeoutSecs": 45,
  "retryBlockedPages": true,
  "saveHtmlToKeyValueStore": false
}
```

# Actor output Schema

## `summary` (type: `string`):

High-level extraction summary.

## `datasetUrl` (type: `string`):

Open the default dataset to view and export all product records.

## `finishedAt` (type: `string`):

Timestamp when the Actor finished.

# 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 = {
    "products": [
        "B08PVPTNZL",
        "https://www.amazon.com/dp/B08KTZ8249"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("techionik9993/amazon-product-price-availability-tracker").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 = { "products": [
        "B08PVPTNZL",
        "https://www.amazon.com/dp/B08KTZ8249",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("techionik9993/amazon-product-price-availability-tracker").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "products": [
    "B08PVPTNZL",
    "https://www.amazon.com/dp/B08KTZ8249"
  ]
}' |
apify call techionik9993/amazon-product-price-availability-tracker --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=techionik9993/amazon-product-price-availability-tracker",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Amazon Product Price & Availability Tracker",
        "description": "Extract Amazon product prices, availability, ratings, reviews, seller, brand, images, and buy box metadata from product URLs or ASINs.",
        "version": "1.0",
        "x-build-id": "b4tYzx6E2TwIwTHyI"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/techionik9993~amazon-product-price-availability-tracker/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-techionik9993-amazon-product-price-availability-tracker",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/techionik9993~amazon-product-price-availability-tracker/runs": {
            "post": {
                "operationId": "runs-sync-techionik9993-amazon-product-price-availability-tracker",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/techionik9993~amazon-product-price-availability-tracker/run-sync": {
            "post": {
                "operationId": "run-sync-techionik9993-amazon-product-price-availability-tracker",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "products": {
                        "title": "Amazon product URLs or ASINs",
                        "type": "array",
                        "description": "Paste Amazon product URLs or 10-character ASINs. You can mix both.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "marketplace": {
                        "title": "Marketplace for ASINs",
                        "enum": [
                            "US",
                            "UK",
                            "CA",
                            "DE",
                            "FR",
                            "IT",
                            "ES",
                            "IN",
                            "AU",
                            "JP"
                        ],
                        "type": "string",
                        "description": "Used when an input item is an ASIN instead of a full URL.",
                        "default": "US"
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Residential proxies are strongly recommended for Amazon.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ]
                        }
                    },
                    "maxConcurrency": {
                        "title": "Speed",
                        "minimum": 1,
                        "maximum": 8,
                        "type": "integer",
                        "description": "How many products to process at once. Higher is faster but may increase proxy retries and block risk.",
                        "default": 3
                    },
                    "productUrls": {
                        "title": "Separate product URLs",
                        "type": "array",
                        "description": "Optional legacy field. Prefer the main Amazon product URLs or ASINs field above.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "asins": {
                        "title": "Separate ASINs",
                        "type": "array",
                        "description": "Optional legacy field. Prefer the main Amazon product URLs or ASINs field above.",
                        "items": {
                            "type": "string",
                            "pattern": "^[A-Z0-9]{10}$"
                        }
                    },
                    "maxRequestRetries": {
                        "title": "Retries",
                        "minimum": 0,
                        "maximum": 10,
                        "type": "integer",
                        "description": "How many times to retry failed or blocked requests.",
                        "default": 3
                    },
                    "requestTimeoutSecs": {
                        "title": "Request timeout seconds",
                        "minimum": 10,
                        "maximum": 180,
                        "type": "integer",
                        "description": "Maximum time allowed for one product page request.",
                        "default": 45
                    },
                    "retryBlockedPages": {
                        "title": "Retry blocked pages",
                        "type": "boolean",
                        "description": "Retries captcha and robot-check pages with a fresh session before returning a blocked result.",
                        "default": true
                    },
                    "saveHtmlToKeyValueStore": {
                        "title": "Save debug HTML",
                        "type": "boolean",
                        "description": "Saves blocked or empty HTML pages to the key-value store for debugging.",
                        "default": false
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
