# Amazon Product Scraper (`usestring/amazon-products`) Actor

Collect Amazon product detail by ASIN or URL - price, rating, review count, availability and brand - across 7 marketplaces.

- **URL**: https://apify.com/usestring/amazon-products.md
- **Developed by:** [String](https://apify.com/usestring) (community)
- **Categories:** E-commerce, Business
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.50 / 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.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## 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 Scraper — price, rating and availability by ASIN

This Actor scrapes Amazon product detail pages by ASIN or product URL and returns one row per
product: a **numeric** `price`, plus `listPrice`, `currency`, `rating`, `reviewCount`,
`availability`, `brand` and the main image. It covers **seven Amazon marketplaces** — US, UK,
Germany, France, Spain, Japan and Australia.

No Amazon account, API key or cookies are used — the Amazon Product Scraper reads what a logged-out
visitor sees on the product page. One row per ASIN, about 2.4 seconds per page at the measured
median.

### What it returns

| Field | Type | Notes |
| --- | --- | --- |
| `asin` | string | Amazon's product ID, read back from the page itself |
| `title` | string | |
| `brand` | string | From the byline — "Visit the Apple Store" becomes `Apple` |
| `price` | number | The buy-box price as a number: `19.99`, not `"$19.99"` |
| `priceText` | string | The formatted price as shown, in the marketplace's own currency |
| `listPrice` | number | The struck-through list price, where the page shows one |
| `currency` | string | ISO code — `USD`, `GBP`, `EUR`, `JPY`, `AUD` |
| `rating` | number | Stars out of 5. Locale decimals are handled — `"4,6"` on `.fr` is `4.6` |
| `reviewCount` | number | `278974`, not `"278,974"` |
| `availability` | string | The page's own availability line, e.g. `In Stock` |
| `imageUrl` | string | The main product image |
| `marketplace` | string | `us`, `uk`, `de`, `fr`, `es`, `jp`, `au` |
| `sourceUrl`, `collectedAt` | string | Provenance for every row |

### Input

```json
{
  "asins": ["B08N5WRWNW", "https://www.amazon.de/dp/B0BDHWDR12"],
  "marketplace": "us",
  "maxItems": 1000
}
```

| Field | Description |
| --- | --- |
| `asins` | Bare ASINs or full Amazon product URLs. Required, 1–500. |
| `marketplace` | `us` (default), `uk`, `de`, `fr`, `es`, `jp` or `au`. Applies to bare ASINs. |
| `maxItems` | Cap on dataset items. Default 1000. Free plans stop at 250 requests and 250 results — see below. |
| `concurrency` | Products fetched in parallel. Default 5, maximum 10. |

**A pasted URL names its own marketplace.** `https://www.amazon.de/dp/B0BDHWDR12` is read on
amazon.de whatever `marketplace` is set to, so one run can mix storefronts. `/dp/`, `/gp/product/`
and `?asin=` URL forms are all accepted.

Each marketplace is fetched from an exit in its own country. That is what makes a price exist at
all: served from a US exit, amazon.fr, amazon.co.jp and amazon.com.au return an offer-less page with
no buy box, and amazon.co.uk and amazon.de quote a converted USD price.

### How it reads the page

An Amazon product page carries no page-wide state blob, so each field is read from the one element
that states it. The price comes from the add-to-cart form's hidden inputs, which carry the exact
decimal amount, an ISO currency code and the formatted display string together and agree by
construction. The embedded buying-options blob stands in when that form is absent, and the rendered
price string is the last resort.

### Use cases

- Price and stock monitoring across a catalogue of ASINs
- Competitor and brand tracking across the US, Europe, Japan and Australia at once
- Enriching a product feed with brand, rating and review count
- Checking the same ASIN's price in seven marketplaces on one run
- Feeding a repricing or merchandising dashboard on a schedule

### Frequently asked questions

**Do I need an Amazon account, API key or cookies to scrape Amazon product pages?** No. The Amazon
Product Scraper reads only the public product page a logged-out visitor sees.

**Which Amazon marketplaces are supported?** Seven: US (amazon.com), UK (amazon.co.uk), Germany
(amazon.de), France (amazon.fr), Spain (amazon.es), Japan (amazon.co.jp) and Australia
(amazon.com.au). Every row carries its `marketplace`.

**Can I pass Amazon product URLs instead of ASINs?** Yes. Bare ASINs and full product URLs can be
mixed in the same `asins` list, and a URL's domain decides which marketplace it is read on.

**Is the Amazon price returned as a number?** Yes. `price` is numeric (`19.99`), with the formatted
string alongside in `priceText` and the ISO code in `currency`. `rating` and `reviewCount` are
numbers too.

**How many rows does one ASIN produce?** One. The Amazon Product Scraper fetches one product page
per ASIN and emits one row from it.

**What happens if an ASIN does not exist on that marketplace?** That target is recorded under
`failures` in the run's `SUMMARY` key rather than emitted as an empty row, and the rest of the batch
still returns.

### Limitations

Product detail pages only. This Actor does not return review text, the full offer or seller list,
variant matrices, Q\&A, or bestseller rank, and it does not discover ASINs — you supply them. For
keyword discovery use the Amazon Search Scraper, and for category rankings use the Amazon
Bestsellers Scraper. Marketplaces outside the seven listed above, including amazon.in, are not
supported. Values reflect what Amazon showed at collection time, stamped in `collectedAt`.

### Free plan limit

Runs started from an Apify **free plan** stop at **250 requests and 250 results**, and the run
reports that it reached the limit. Any paid plan runs the full input and `maxItems` you set.

The limit exists because this Actor fetches through our own infrastructure, which Apify does not
cover for free-plan runs. It binds on requests as well as results so that a large input list cannot
spend those fetches for rows the run will not return.

# Actor input Schema

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

Amazon ASINs or full product URLs.

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

Amazon marketplace to read.

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

Global cap on dataset items. Runs started from an Apify free plan stop at 250 requests and 250 results; any paid plan runs the full amount.

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

Targets fetched in parallel.

## Actor input object example

```json
{
  "asins": [
    "B0CHX3QBCH"
  ],
  "marketplace": "us",
  "maxItems": 1000,
  "concurrency": 5
}
```

# Actor output Schema

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

Collect Amazon product detail by ASIN or URL - price, rating, review count, availability and brand - across 7 marketplaces.

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

Item count, failure count and every target that failed, with its error.

# 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": [
        "B0CHX3QBCH"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("usestring/amazon-products").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": ["B0CHX3QBCH"] }

# Run the Actor and wait for it to finish
run = client.actor("usestring/amazon-products").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": [
    "B0CHX3QBCH"
  ]
}' |
apify call usestring/amazon-products --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,usestring/amazon-products"
        }
    }
}

```

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/ig7mA5RuOwemsxcEW/builds/NDhyFi7azMxTywuHl/openapi.json