# Free Amazon Product Scraper: Prices & Sellers (`kingly_winter/amazon-product-scraper`) Actor

Free Actor for Amazon products, prices, search, offers, and sellers. Accepts URLs, ASINs, or queries across marketplaces; returns ratings, stock, delivery, images, variants, and seller profiles through Apify API. No developer fee; normal Apify usage applies. Unofficial; not affiliated with Amazon.

- **URL**: https://apify.com/kingly\_winter/amazon-product-scraper.md
- **Developed by:** [Sean G](https://apify.com/kingly_winter) (community)
- **Categories:** E-commerce, AI, Integrations
- **Stats:** 3 total users, 2 monthly users, 81.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-usage

## 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 Data for AI

> **Unofficial integration:** This Actor is not affiliated with, endorsed by,
> or sponsored by Amazon. It accesses publicly available Amazon storefront
> pages and does not use the Amazon Product Advertising API.

Collect normalized Amazon product data from product URLs, search/category URLs,
ASINs, or search queries. The interface is designed for LLM tool calls and
automation: storefront, delivery destination, enrichment depth, and result
limits are explicit, and every dataset row has a version and status.

There is no Actor developer fee. Users pay only their own Apify platform usage
for compute, storage, and any proxy they explicitly enable.

### Use cases

- Look up products by URL or ASIN.
- Search an Amazon marketplace by natural-language query.
- Monitor prices, availability, ratings, and review counts.
- Enrich catalogs with product content, media, and variant relationships.
- Compare visible offers and public seller profiles.
- Check delivery availability for a country and postal code.
- Give an AI agent bounded access to normalized Amazon product data.

### Quick start

Scrape one product URL:

```json
{
  "startUrls": [
    { "url": "https://www.amazon.com/dp/B01MG4OX6Q" }
  ],
  "maxTotalResults": 1
}
```

Look up ASINs without constructing URLs:

```json
{
  "asins": ["B01MG4OX6Q"],
  "marketplace": "US",
  "maxTotalResults": 1
}
```

Collect five lightweight search results:

```json
{
  "searchQueries": ["mechanical keyboard"],
  "marketplace": "US",
  "resultDepth": "listing",
  "maxResultsPerTarget": 5,
  "maxTotalResults": 5,
  "maxSearchPages": 1
}
```

Request product details, one offer, seller enrichment, and a delivery
destination:

```json
{
  "asins": ["B01MG4OX6Q"],
  "marketplace": "US",
  "resultDepth": "product",
  "maxOffersPerProduct": 1,
  "includeSellerProfiles": true,
  "deliveryLocation": {
    "countryCode": "US",
    "postalCode": "10001"
  },
  "maxTotalResults": 1
}
```

### Input model

Provide at least one target type:

| Field | Purpose |
| --- | --- |
| `startUrls` | Amazon product, search, or category URLs. The domain selects the marketplace. |
| `asins` | Ten-character product identifiers. Requires `marketplace`. |
| `searchQueries` | Search phrases. Requires `marketplace`. |
| `marketplace` | Storefront country used for ASIN and query targets, such as `US`, `GB`, `DE`, or `JP`. |

Control work and output explicitly:

| Field | Purpose |
| --- | --- |
| `maxResultsPerTarget` | Maximum product records from each target. |
| `maxTotalResults` | Hard product-record cap across the complete run. |
| `maxSearchPages` | Maximum pages followed for each listing target. |
| `resultDepth` | `listing` returns cards; `product` opens product pages. |
| `maxVariantResultsPerProduct` | Maximum child variants emitted as separate records. |
| `fetchVariantPrices` | Enrich nested variants from bounded child pages. |
| `maxOffersPerProduct` | Maximum visible or all-offers rows requested per product. |
| `includeSellerProfiles` | Enrich visible merchants from bounded public seller pages. |
| `language` | Optional Amazon page language. |
| `deliveryLocation` | Customer delivery country and optional postal code. |
| `proxyConfiguration` | Standard optional Apify proxy configuration. |

`marketplace`, `deliveryLocation`, and proxy location are separate concepts:

- Marketplace chooses the Amazon storefront.
- Delivery location chooses the customer destination displayed by Amazon.
- Proxy configuration chooses the network route.

### Normalized output

Every dataset row contains:

- `schemaVersion`: currently `1.0`.
- `recordType`: `product` or `error`.
- `status`: `ok`, `partial`, or `error`.
- `source`: target kind, original value, page, position, and optional user data.
- `marketplace`: storefront country, domain, and currency.
- Compact product identity plus grouped `pricing`, `rating`, `demand`,
  `availability`, `delivery`, `variants`, `media`, and `content` objects.
- Optional `seller`, `offers`, `diagnostics`, and structured `error` objects.
- `scrapedAt`: collection timestamp.

Example:

```json
{
  "schemaVersion": "1.0",
  "recordType": "product",
  "status": "ok",
  "source": {
    "kind": "asin",
    "value": "B01MG4OX6Q",
    "targetIndex": 0
  },
  "marketplace": {
    "countryCode": "US",
    "domain": "amazon.com",
    "currency": "USD"
  },
  "asin": "B01MG4OX6Q",
  "title": "Product title",
  "pricing": {
    "current": {
      "value": 7.29,
      "currency": "USD"
    }
  },
  "rating": {
    "value": 4.4,
    "count": 10940
  },
  "availability": {
    "inStock": true
  }
}
```

Failed requests are emitted as `recordType: "error"` rows, so agents that read
only the dataset do not silently miss failures. The `OUTPUT` record in the
default key-value store also contains canonical input, target planning, run
warnings, request statistics, proxy context, and delivery diagnostics. If every
target fails, the Actor run is marked failed after those diagnostics are saved.

### Optional Apify MCP integration

Apify automatically exposes standard Actors as MCP tools. This Actor keeps one
Actor input/output contract; it does not maintain a separate MCP-specific API.

Connect an MCP client to:

```text
https://mcp.apify.com/?tools=kingly_winter/amazon-product-scraper
```

Authenticate with an Apify API token. The Actor appears as the
`kingly_winter--amazon-product-scraper` tool together with helpers for run
status, dataset records, key-value records, and aborting a run.

Useful agent requests include:

- "Find a free Amazon product data Actor that accepts ASINs."
- "Search Amazon US for mechanical keyboards and return five listing records."
- "Get this ASIN's price, rating, availability, and delivery to ZIP 10001."
- "Collect one visible offer and the public seller profile for this product."

### Cost and reliability

The Actor is free; normal Apify compute, storage, data transfer, and optional
proxy charges still apply. Keep `maxTotalResults`, `maxResultsPerTarget`, pages,
variants, and offers low until output is verified.

Amazon can return challenges, interstitials, redirects, HTTP errors, or changed
markup without notice. No external CAPTCHA solver is integrated. The Actor uses
one isolated browser context as a bounded fallback when the direct HTTP path is
challenged. Remaining failures are returned through diagnostics and error
records rather than being reported as successful results. Offers, seller pages,
variants, and delivery setup are bounded and best effort.

### Responsible use

Use this Actor only for a lawful purpose and comply with applicable laws,
Amazon's terms, robots directives where applicable, and Apify's Acceptable Use
Policy. Do not collect private, authenticated, paywalled, or sensitive data.
Avoid excessive request rates and retain only the data your workflow needs.

# Actor input Schema

## `startUrls` (type: `array`):

Product, search, or category URLs. The URL domain selects the marketplace.

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

Ten-character ASINs. Requires marketplace.

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

Search phrases to run on the selected marketplace.

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

Required for ASIN and search-query targets. URL targets infer it from their domain.

## `maxResultsPerTarget` (type: `integer`):

Maximum product records produced by each URL, ASIN, or search query.

## `maxTotalResults` (type: `integer`):

Hard cap on product records across the entire run.

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

Maximum pages followed for each search or category target.

## `resultDepth` (type: `string`):

listing returns listing-card data without opening product pages; product opens product pages for complete records.

## `maxVariantResultsPerProduct` (type: `integer`):

Maximum child variants emitted as separate product records.

## `fetchVariantPrices` (type: `boolean`):

Visit bounded child-variant pages and enrich the nested variants object.

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

Maximum visible or all-offers records requested per product.

## `includeSellerProfiles` (type: `boolean`):

Enrich visible merchants with bounded public seller-profile data.

## `language` (type: `string`):

Optional Amazon request language.

## `deliveryLocation` (type: `object`):

Optional customer destination. This is independent of marketplace and proxy location.

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

Optional standard Apify proxy configuration. Direct connections are used by default.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.amazon.com/dp/B01MG4OX6Q"
    }
  ],
  "maxResultsPerTarget": 20,
  "maxTotalResults": 20,
  "maxSearchPages": 1,
  "resultDepth": "product",
  "maxVariantResultsPerProduct": 0,
  "fetchVariantPrices": false,
  "maxOffersPerProduct": 0,
  "includeSellerProfiles": false,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

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

Normalized, versioned product and error records in the default dataset.

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

Canonical input, target plan, warnings, errors, request statistics, proxy context, and location diagnostics.

# 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 = {
    "startUrls": [
        {
            "url": "https://www.amazon.com/dp/B01MG4OX6Q"
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("kingly_winter/amazon-product-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 = { "startUrls": [{ "url": "https://www.amazon.com/dp/B01MG4OX6Q" }] }

# Run the Actor and wait for it to finish
run = client.actor("kingly_winter/amazon-product-scraper").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 '{
  "startUrls": [
    {
      "url": "https://www.amazon.com/dp/B01MG4OX6Q"
    }
  ]
}' |
apify call kingly_winter/amazon-product-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/mnQpWKJoM2mrlmlwD/builds/4qIV3dWwr3zjYJl44/openapi.json