# Amazon Product Price & Stock Data Scraper (`shaggydev/amazon-price-stock-metadata-scraper`) Actor

Amazon product scraper for keyword search, bulk product discovery, and URL/ASIN tracking. Extract product price, stock, availability, ASIN, title, ratings, Prime status, marketplace, and confidence fields. Built for price monitoring, inventory alerts, and competitor research.

- **URL**: https://apify.com/shaggydev/amazon-price-stock-metadata-scraper.md
- **Developed by:** [Michael](https://apify.com/shaggydev) (community)
- **Categories:** E-commerce, Automation, Developer tools
- **Stats:** 3 total users, 0 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.01 / 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?

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 does Amazon Product Price & Stock Data Scraper do?

Amazon Product Price & Stock Data Scraper is an **Amazon product scraper** for keyword search, bulk product discovery, and exact product tracking by URL or ASIN. Use it to scrape public Amazon product metadata from [Amazon](https://www.amazon.com): price, stock, availability, ASIN, title, rating, Prime signal, marketplace, search rank, and scrape confidence.

This Amazon scraper is built for price monitoring, inventory alerts, competitor research, catalog intelligence, repricing workflows, product discovery, and marketplace analysis. It collects metadata only. It does not scrape full product descriptions, customer reviews, review bodies, or other long copyrighted page text.

### Why use this Amazon product scraper?

- Search Amazon by keyword and extract product results at scale.
- Scrape exact Amazon product URLs or bulk ASIN lists.
- Track price, stock, availability, ratings, Prime status, and marketplace.
- Support major Amazon marketplaces including US, UK, CA, DE, FR, IT, ES, AU, JP, and IN.
- Use fast HTTP extraction first, with Playwright browser fallback for blocked or incomplete product pages.
- Match residential proxy country to the selected Amazon marketplace with `autoProxyCountry`.
- Export results from Apify datasets as JSON, CSV, Excel, XML, RSS, or HTML.
- Run manually, schedule recurring price checks, or call the scraper through the Apify API.

### What Amazon data can you extract?

| Field | Description |
| --- | --- |
| `asin` | Amazon Standard Identification Number |
| `title` | Clean product title metadata |
| `price` | Current visible product price |
| `currency` | USD, GBP, EUR, CAD, AUD, JPY, INR, and other marketplace currencies |
| `availability` | Raw availability text such as in stock or unavailable |
| `inStock` | Parsed stock boolean |
| `stockStatus` | Normalized stock status |
| `rating` | Visible star rating metadata |
| `isPrime` | Prime eligibility signal when visible |
| `marketplace` | Amazon marketplace such as `com`, `co.uk`, or `de` |
| `searchQuery` | Keyword query that discovered the product |
| `searchRank` | Product rank within the scraped search results |
| `scrapeStatus` | `ok`, `partial`, or `failed` |
| `metadataConfidence` | `high`, `medium`, or `low` extraction confidence |

### How to scrape Amazon prices, stock, and ASIN data

1. Open the Actor input tab.
2. Add one or more Amazon keyword searches in `searchQueries`, such as `wireless earbuds`, `coffee maker`, or `dog food`.
3. Set `maxSearchResultsPerQuery` to control how many products to scrape from each keyword search.
4. Optionally add exact Amazon `productUrls` or `asins` for product tracking.
5. Choose the target `marketplace`.
6. Keep `browserFallback` and `autoProxyCountry` enabled for the best reliability.
7. Run the Actor and export the dataset.

### Example input

```json
{
  "searchQueries": ["wireless earbuds", "coffee maker"],
  "maxSearchResultsPerQuery": 10,
  "productUrls": [],
  "asins": [],
  "marketplace": "com",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": ["RESIDENTIAL"],
    "apifyProxyCountry": "US"
  },
  "browserFallback": true,
  "autoProxyCountry": true,
  "maxConcurrency": 3
}
```

### Example output

```json
{
  "url": "https://www.amazon.com/dp/B000000000",
  "asin": "B000000000",
  "title": "Example Amazon Product",
  "price": "$49.99",
  "currency": "USD",
  "availability": "In Stock",
  "inStock": true,
  "stockStatus": "in_stock",
  "rating": 4.6,
  "isPrime": true,
  "marketplace": "com",
  "sourceType": "search",
  "searchQuery": "wireless earbuds",
  "searchRank": 1,
  "scrapeStatus": "ok",
  "extractionMethod": "browser",
  "metadataConfidence": "high",
  "timestamp": "2026-06-03T00:00:00.000Z"
}
```

### Amazon keyword search and bulk ASIN tracking

Use `searchQueries` when you need product discovery from Amazon search results. The Actor first discovers product ASINs from search pages, then scrapes each product detail page for price, stock, availability, and metadata.

Use `asins` or `productUrls` when you already know the products you want to monitor. Exact URL and ASIN inputs skip the search-discovery step and go straight to product-detail scraping.

### Supported Amazon marketplaces

The scraper supports these marketplaces:

`amazon.com`, `amazon.co.uk`, `amazon.ca`, `amazon.de`, `amazon.fr`, `amazon.it`, `amazon.es`, `amazon.com.au`, `amazon.co.jp`, and `amazon.in`.

For mixed-marketplace jobs, keep `autoProxyCountry` enabled so Apify Residential proxy country is matched to each Amazon marketplace where possible.

### How much does it cost to scrape Amazon product data?

This Actor uses Apify pay-per-event pricing. You are charged for dataset results according to the pricing section on the Actor page, plus any platform usage that Apify shows for the run.

For predictable cost, start with a small job such as one keyword and 5-10 results. Scale after checking output quality, proxy behavior, and total run cost.

### Reliability notes for Amazon scraping

Amazon can change layouts, suppress offers, show different prices by region, or present anti-bot checks. This Actor handles those cases with proxy support, browser fallback, fail-loud behavior, and per-row status fields.

Use `scrapeStatus` and `metadataConfidence` in downstream automation. Treat `ok` rows with `high` confidence as production-ready records, and review `partial` or `failed` rows before using them in pricing bots or inventory alerts.

### FAQ

#### Is this an Amazon API?

No. This is an Amazon scraper for public product metadata. It does not use Amazon SP-API, Product Advertising API, account login, or private seller data.

#### Can this scraper monitor Amazon prices on a schedule?

Yes. Create an Apify task with your product URLs, ASINs, or keyword searches, then schedule it to run daily, hourly, or on any cadence supported by Apify.

#### Can I scrape Amazon product reviews?

No. This Actor is intentionally metadata-only. It does not scrape full reviews, review bodies, or long copyrighted text.

#### What should I do if Amazon blocks a run?

Keep Apify Residential proxy enabled, use `autoProxyCountry`, lower `maxConcurrency`, and keep `browserFallback` enabled. Review `error`, `scrapeStatus`, and `metadataConfidence` fields for diagnostics.

#### Can I use this Amazon scraper through an API?

Yes. Every Apify Actor can be run through the Apify API, CLI, scheduler, webhooks, and integrations. Results are stored in the default dataset and can be exported in multiple formats.

# Actor input Schema

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

Amazon keyword searches, one per line. Use this for product discovery and bulk searches, for example: echo dot, wireless earbuds, dog food. Results are discovered from Amazon search pages and then scraped as product pages.

## `maxSearchResultsPerQuery` (type: `integer`):

How many product result pages to scrape from each search query. Higher values cost more and are more likely to hit blocking.

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

Optional exact Amazon product page URLs, for example https://www.amazon.com/dp/B0ABC12345 or https://www.amazon.co.uk/dp/B0XYZ12345.

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

Optional list of 10-character Amazon ASINs. The scraper converts them to product URLs using the selected marketplace.

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

Default marketplace/domain for ASIN conversion and URL normalization.

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

Recommended: use Apify Proxy. Amazon can block requests without reliable proxy infrastructure.

## `browserFallback` (type: `boolean`):

Use Playwright browser fallback when fast HTTP scraping is blocked, fails, or returns partial metadata. More reliable but slower and more expensive.

## `autoProxyCountry` (type: `boolean`):

Automatically match Apify Proxy country to each Amazon marketplace, for example US for amazon.com, GB for amazon.co.uk, DE for amazon.de, and CA for amazon.ca. Recommended for mixed-marketplace runs.

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

How many products to scrape in parallel.

## Actor input object example

```json
{
  "searchQueries": [
    "echo dot"
  ],
  "maxSearchResultsPerQuery": 10,
  "marketplace": "com",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  },
  "browserFallback": true,
  "autoProxyCountry": true,
  "maxConcurrency": 8
}
```

# Actor output Schema

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

URL to the default dataset items.

# 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": [
        "echo dot"
    ],
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "apifyProxyCountry": "US"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("shaggydev/amazon-price-stock-metadata-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 = {
    "searchQueries": ["echo dot"],
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "US",
    },
}

# Run the Actor and wait for it to finish
run = client.actor("shaggydev/amazon-price-stock-metadata-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 '{
  "searchQueries": [
    "echo dot"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  }
}' |
apify call shaggydev/amazon-price-stock-metadata-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,shaggydev/amazon-price-stock-metadata-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/Ywe6FpWnlA7ofLCbT/builds/9aGw1falvuZZjoQSf/openapi.json