# Amazon Product Scraper (`lowlanddata/amazon-product-scraper`) Actor

Scrape Amazon search results across 11 marketplaces - ASIN, title, price, list price and discount, rating, reviews, badges. Optional detail adds stock and Best Sellers Rank. No seller names, ever.

- **URL**: https://apify.com/lowlanddata/amazon-product-scraper.md
- **Developed by:** [Lowland Data](https://apify.com/lowlanddata) (community)
- **Categories:** E-commerce, MCP servers, Agents
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.70 / 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/actors/running/actors-in-store.md#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 — search results from 11 marketplaces as clean JSON

Extract Amazon search results — ASIN, title, current price, crossed-out list price and the discount between them, star rating, review count, delivery promise, badges and a tracking-free product link — as flat JSON rows for price monitoring, market research and catalogue work. Search any keyword on any of eleven Amazon marketplaces, with price bands, Prime filtering and sorting.

**Live health record:** [lowlanddata.com/status/amazon-product-scraper](https://lowlanddata.com/status/amazon-product-scraper/) - 30-day success rate and daily canary results, failures included. Full input/output reference: [tool page](https://lowlanddata.com/tools/amazon-product-scraper/).

**No personal data, ever.** Products are commercial objects and come back whole. Marketplace sellers do not: a third-party seller is frequently a sole trader, which makes their name personal data, so there is no seller field and there never will be. Reviews are counted, never quoted — no reviewer names, no review text.

### Quick start (30 seconds)

1. Type what you would type into Amazon's search box into **keywords**.
2. Pick a **marketplace** — prices and availability differ per country.
3. Click **Start**, then open the dataset's **Overview** tab or **Export** as CSV/Excel/JSON.

Optional: **minPrice**/**maxPrice**, **primeOnly**, **sortBy**, and **skipSponsored** to drop paid placements. Everything works on a daily Schedule.

### What you can build with it

- **Price monitoring.** Schedule daily on your own ASINs or your category, and watch `price` and `discountPercent` move. Rows are flat, so a spreadsheet or a database takes them as-is.
- **Competitor and category research.** Who ranks for your keyword, at what price, with how many reviews — the whole first page as data instead of screenshots.
- **Repricing inputs.** `price`, `listPrice` and `discountPercent` per ASIN across marketplaces, which is what a repricing rule actually needs.
- **Assortment gap analysis.** Compare the same keyword across amazon.de, .co.uk and .fr to see what sells where.

### What you get

One JSON object per product:

```json
{
  "asin": "B07QPS7L6Y",
  "title": "RAVIAD USB C Kabel [4Pack 0.5M 1M 2M 3M] Ladekabel Schnellladekabel",
  "url": "https://www.amazon.de/dp/B07QPS7L6Y",
  "marketplace": "de",
  "price": 6.79,
  "currency": "EUR",
  "listPrice": 9.99,
  "discountPercent": 32,
  "rating": 4.6,
  "reviewCount": 23993,
  "imageUrl": "https://m.media-amazon.com/images/I/81ZJli188JL._AC_UY218_.jpg",
  "deliveryText": "GRATIS Lieferung Di, 16. Sep",
  "isSponsored": false,
  "isAmazonsChoice": true,
  "isBestSeller": false
}
```

With `scrapeDetails: true`, rows additionally carry `availability`, `featureBullets`, `category`, `bestSellerRank` and `bestSellerCategory` — and the price is refreshed from the product page, which is fetched later than the search tile.

Links are canonical — `amazon.xx/dp/ASIN` — with Amazon's click-tracking blob removed, so they stay stable and shareable.

### How much does it cost?

Pay per product row plus a small start fee — no subscription. Free-plan users can try it capped at 5 products.

**`scrapeDetails` is charged separately, and only when a detail actually arrives.** That is not a pricing trick, it is the cost: one search page is 276 KB and carries sixteen products, while one product page is 443 KB and carries one — about 25x the traffic per item. Callers who do not need stock and Best Sellers Rank never pay for them, and a detail fetch that fails is not charged at all; the search row still ships.

Platform usage is billed by Apify; Amazon needs a residential route, so runs cost a little more than a plain HTML site.

### Not technical? Let your AI assistant set it up

```
I want to use the Amazon Product Scraper (lowlanddata/amazon-product-scraper) on Apify.

What I want: [E.G. "track the price of wireless keyboards under 50 EUR on amazon.de, daily"]

Guide me to:
1. Propose input values: keywords, marketplace, minPrice, maxPrice,
   primeOnly, sortBy, skipSponsored and maxItems.
2. Explain how to run it in the Apify Console and export CSV.
3. Suggest a daily Schedule so I can watch prices move over time.
```

### Input reference

| Field                | Type    | Default     | Notes                                                            |
| -------------------- | ------- | ----------- | ---------------------------------------------------------------- |
| `keywords`           | string  | `usb cable` | What you would type into Amazon's search box.                    |
| `marketplace`        | string  | `de`        | de, uk, fr, it, es, nl, se, pl, be, us, ca.                      |
| `minPrice`           | integer | —           | Lower bound in the marketplace's currency.                       |
| `maxPrice`           | integer | —           | Upper bound in the marketplace's currency.                       |
| `primeOnly`          | boolean | `false`     | Only Prime-eligible products.                                    |
| `sortBy`             | string  | relevance   | relevance, price-asc, price-desc, newest, reviews.               |
| `skipSponsored`      | boolean | `false`     | Drop paid placements and keep organic results only.              |
| `maxItems`           | integer | `200`       | Stop after this many products.                                   |
| `proxyConfiguration` | object  | residential | Amazon blocks datacenter addresses quickly — keep this as it is. |

### Scheduling and API use

```bash
curl -X POST "https://api.apify.com/v2/acts/lowlanddata~amazon-product-scraper/runs?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"keywords": "wireless keyboard", "marketplace": "de", "maxPrice": 50, "maxItems": 100}'
```

### Use it with AI agents (MCP)

Run it directly from Claude, Cursor and other MCP clients: [apify.com/lowlanddata/amazon-product-scraper/api/mcp](https://apify.com/lowlanddata/amazon-product-scraper/api/mcp).

### Is it legal to scrape Amazon product listings?

This actor reads only public search pages — the same pages any shopper sees without logging in — and takes only product facts: identifier, title, price, rating, review count, badges. No customer data, no reviewer identities, no seller names. Product prices and specifications are facts about goods on sale, not personal data. How you use them downstream is yours to assess.

### FAQ

**Why does it need a residential proxy?** Amazon rejects datacenter addresses within a page or two and answers with a robot check served as HTTP 200. The actor treats that as a block and rotates, rather than reporting an empty run as a success.

**Which currency are the prices in?** The marketplace's own — amazon.de in EUR, amazon.co.uk in GBP. That is not automatic: Amazon quotes the currency of the country a request appears to come from, so the same amazon.de search returns INR from an Indian address and KRW from a Korean one. The run pins its session to the marketplace's country to prevent that, and if any row still arrives in another currency the run says so in its status rather than shipping a number that looks like euros and is not.

**Why no seller name?** A third-party Amazon seller is often a sole trader, which makes the shop name personal data under GDPR. We do not emit it, behind a flag or otherwise.

**Why is `price` sometimes null?** Some tiles show no price at all — variation parents, out-of-stock items, "see options". The row still carries the ASIN, title and rating so you can fetch the detail yourself.

**Can I scrape specific ASINs instead of a keyword?** Not in v1 — this starts from a keyword search. `scrapeDetails` will then open each matched product's page for you.

**What does `bestSellerRank` mean?** Amazon's position for that product inside `bestSellerCategory`, e.g. 2,190th in Computer & Zubehör. It is the field sellers watch, and it only arrives with `scrapeDetails`.

**Why does `reviewCount` look like the rating?** It should not — the reviews block prints the rating first and the count last, and the extractor takes the last number, with a test that fails if they are ever confused.

### Troubleshooting

- **"robot check instead of search results"** — Amazon served its interstitial. The actor retries on a fresh route; re-run in a few minutes if a whole run fails.
- **Fewer products than you expected** — Amazon repeats the last page rather than ending cleanly, so the run stops as soon as a page adds nothing new.

If this saves you an afternoon, a **rating on this page** takes ten seconds and helps other buyers find the compliance-clean option.

# Actor input Schema

## `keywords` (type: `string`):

What to search for, exactly as you would type it into Amazon's search box.

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

Which Amazon site to search. Prices and availability differ per marketplace.

## `minPrice` (type: `integer`):

Only products at or above this price, in the marketplace's currency.

## `maxPrice` (type: `integer`):

Only products at or below this price, in the marketplace's currency.

## `primeOnly` (type: `boolean`):

Only products available with Prime delivery.

## `sortBy` (type: `string`):

How Amazon should order the results.

## `skipSponsored` (type: `boolean`):

Leave out paid placements and keep only organic results.

## `scrapeDetails` (type: `boolean`):

Open each product page for stock, feature bullets, category and Best Sellers Rank. A product page is about 25x the traffic of a search result, so this is charged as its own event and is off by default.

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

Stop after this many products.

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

Amazon quotes prices in the currency of the country the request comes from, so the run pins a residential session to the marketplace's own country - amazon.de from Germany, amazon.co.uk from the UK. Leave this as it is: a custom proxy without that country targeting can return prices converted into another currency.

## Actor input object example

```json
{
  "keywords": "usb cable",
  "marketplace": "de",
  "primeOnly": false,
  "skipSponsored": false,
  "scrapeDetails": false,
  "maxItems": 200,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

## `products` (type: `string`):

No description

# 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 = {
    "keywords": "usb cable"
};

// Run the Actor and wait for it to finish
const run = await client.actor("lowlanddata/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 = { "keywords": "usb cable" }

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

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,lowlanddata/amazon-product-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/3mCwTCjRSWF9HlpIo/builds/vhBdvc8jIi45ekTus/openapi.json