# Amazon Scraper — Product Search, Prices & Ratings (`logiover/amazon-product-scraper`) Actor

Scrape Amazon search results in bulk: ASIN, title, price, list price, star rating, review count, Prime and sponsored flags, badge and image. Works across 19 Amazon marketplaces. No API key. Export to JSON/CSV/Excel.

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

## Pricing

from $2.80 / 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 Scraper — Product Search, Prices & Ratings in Bulk

Scrape **Amazon search results** at scale and export them to CSV, JSON or Excel. Feed it keywords and get ASIN, title, price, list price, star rating, review count, Prime and sponsored flags, badge and image — across **19 Amazon marketplaces**.

No Amazon API key. No Product Advertising API approval. No login.

***

### Why scrape Amazon search results

Amazon's Product Advertising API requires an affiliate account in good standing, throttles hard, and returns a narrow slice of what the page actually shows. It will not tell you which results were **sponsored**, and that single distinction is what separates real organic rank from paid placement.

This Actor reads the page a shopper sees, so what you measure is what customers actually encounter.

***

### What this Actor extracts

| Field | Type | Description |
|---|---|---|
| `asin` | string | Amazon's product identifier |
| `title` | string | Product title as listed |
| `url` | string | Product detail page |
| `price` | number | Current price as a number |
| `priceText` | string | Price exactly as Amazon renders it |
| `listPriceText` | string | Struck-through reference price, when shown |
| `currency` | string | Currency of the marketplace |
| `rating` | number | Average star rating out of 5 |
| `reviewCount` | integer | Number of ratings |
| `isPrime` | boolean | Prime badge present |
| `isSponsored` | boolean | Paid placement rather than organic rank |
| `badge` | string | `Best Seller`, `Amazon's Choice`, `Overall Pick` … |
| `deliveryInfo` | string | Delivery promise on the card |
| `imageUrl` | string | Product thumbnail |
| `keyword`, `page`, `marketplace` | string / integer | Which query and page produced the row |
| `scrapedAt` | string | UTC timestamp of extraction |

Prices and ratings are stored as **real numbers**, so the export sorts and filters without cleaning.

***

### Supported marketplaces

United States, United Kingdom, Germany, France, Italy, Spain, Netherlands, Sweden, Poland, Canada, Mexico, Brazil, Japan, India, Australia, Turkey, United Arab Emirates, Saudi Arabia, Singapore.

The same ASIN is priced and ranked differently in each. The Actor pins its exit country to the marketplace you select, which is what keeps prices populated — scraping `amazon.com` from outside the US makes Amazon hide the buy box entirely.

***

### Input

```json
{
  "keywords": ["wireless earbuds", "mechanical keyboard", "standing desk"],
  "marketplace": "US",
  "maxPagesPerKeyword": 7,
  "maxResults": 4000
}
```

| Input | Default | Notes |
|---|---|---|
| `keywords` | one default search | One search per term, paginated. |
| `marketplace` | `US` | One of the 19 storefronts above. |
| `maxPagesPerKeyword` | 3 | Roughly 50 products per page. |
| `maxResults` | 500 | Global cap for the run. `0` = unlimited. |

**Nothing is required.** Run it with empty input (`{}`) and it runs a default search so you can see the output shape first.

#### More ways to run it

```json
{ "keywords": ["air fryer"], "marketplace": "UK" }
{ "keywords": ["kabellose kopfhörer"], "marketplace": "DE", "maxPagesPerKeyword": 10 }
{ "keywords": ["yoga mat", "resistance bands", "foam roller"], "maxResults": 0 }
```

***

### Output sample

```json
{
  "asin": "B09DT48V16",
  "title": "Wireless Earbuds Bluetooth 5.3 Headphones",
  "url": "https://www.amazon.com/dp/B09DT48V16",
  "price": 25.99,
  "priceText": "$25.99",
  "listPriceText": "$39.99",
  "currency": "USD",
  "rating": 4.4,
  "reviewCount": 18234,
  "isPrime": true,
  "isSponsored": false,
  "badge": "Amazon's Choice",
  "keyword": "wireless earbuds",
  "page": 1,
  "marketplace": "US",
  "scrapedAt": "2026-08-06T18:20:00.000Z"
}
```

***

### Use cases

#### Price monitoring and repricing

Track competitor prices per keyword on a schedule. `price` and `listPriceText` together show both the live price and the discount being advertised.

#### Share of shelf

Count how many of the first three pages a brand holds, and split it by `isSponsored`. A brand that only appears in paid slots has bought its visibility rather than earned it — and that is a different competitive picture entirely.

#### Product and niche research

Look for keywords where demand is high but ratings are weak. A category whose top results sit at 3.8 stars with thousands of reviews is a category with unhappy customers and room for a better product.

#### Cross-market arbitrage

Run the same keyword across `US`, `UK`, `DE` and `JP`. Because prices come back as numbers in a labelled currency, the comparison is a single pivot table.

#### Keyword and PPC research

`isSponsored` plus `badge` tells you which terms competitors are paying for and which they own organically — useful before you commit an advertising budget.

***

### Integrating the results

**HTTP**

```bash
curl "https://api.apify.com/v2/acts/logiover~amazon-product-scraper/run-sync-get-dataset-items?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"keywords":["wireless earbuds"],"marketplace":"US","maxResults":500}'
```

**Python**

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_TOKEN")
run = client.actor("logiover/amazon-product-scraper").call(
    run_input={"keywords": ["air fryer", "toaster oven"], "marketplace": "UK", "maxResults": 2000}
)
for p in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(p["asin"], p["price"], p["rating"], p["isSponsored"])
```

**JavaScript**

```js
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: 'YOUR_TOKEN' });
const run = await client.actor('logiover/amazon-product-scraper').call({
  keywords: ['standing desk'],
  marketplace: 'DE',
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
```

Results can also be pushed to Google Sheets, Airtable, Slack, Zapier or Make through Apify integrations, or read by an AI agent over MCP.

***

### Frequently asked questions

#### Can I use the official Amazon API instead?

The Product Advertising API needs an approved affiliate account, enforces strict rate limits, and does not expose whether a result is sponsored. For competitive research this Actor gives you both more coverage and the one field the API withholds.

#### How many products can I scrape in one run?

A single test run returned **2,123 products across ten keywords**, with prices on 98% of rows and ratings on 97%. Raise `maxPagesPerKeyword` and `maxResults`, or set `maxResults` to `0`, to go further.

#### Why is `reviewCount` empty on some rows?

Amazon serves several card layouts on the same result page, and only some of them carry the accessibility label that holds the review count — the rest publish the star rating alone. `rating` is present on nearly every row. When you need a guaranteed review count, feed those ASINs into the **Amazon Product Detail Scraper**, which reads it from the product page itself.

#### Why do prices come back empty if I change the marketplace manually?

They should not — the Actor pins its exit country to whichever marketplace you choose, precisely because Amazon hides the buy box from addresses it cannot ship to. That is the usual cause of null prices in home-grown Amazon scrapers.

#### Is scraping Amazon legal?

This Actor reads publicly available search pages, does not log in, and collects no personal data. How you use the output is your responsibility; review Amazon's terms and your local rules before redistributing data commercially.

#### Why did a run return fewer rows than requested?

Amazon refuses requests in bursts lasting minutes rather than per request. The Actor spreads retries out to cross those windows and takes a fresh exit IP each time, but a long run can still meet one. Re-run, or split the job.

***

### Related Actors

- **Amazon Product Detail Scraper** — feed the ASINs from this run to get specs, description, seller, Best Sellers Rank and full-size images.
- **Amazon Best Sellers Scraper** — category charts rather than keyword search: what actually sells, ranked.

A natural pipeline: **search keywords here → take the ASINs → enrich with the detail Actor → cross-check against the Best Sellers charts.**

***

### Pricing

Pay per result. You are charged for the rows you receive, plus a negligible flat fee when a run starts. No subscription and no minimum commitment.

***

*This Actor uses publicly available data. Amazon is a trademark of Amazon.com, Inc. This is an independent tool and is not affiliated with, endorsed by, or sponsored by Amazon.*

# Actor input Schema

## `keywords` (type: `array`):

Search terms to scrape, one search per term. Leave EMPTY to run a default search so the Actor still returns data.

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

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

## `maxPagesPerKeyword` (type: `integer`):

Amazon returns roughly 50 products per page. Three pages is about 150 products per keyword.

## `maxResults` (type: `integer`):

Global cap for the run so an empty-input run stays fast and cheap. 0 = unlimited.

## Actor input object example

```json
{
  "keywords": [
    "wireless earbuds"
  ],
  "marketplace": "US",
  "maxPagesPerKeyword": 3,
  "maxResults": 500
}
```

# Actor output Schema

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

All records extracted by this run. Open the Dataset tab to browse, filter, and export as CSV, JSON, or Excel.

# 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": [
        "wireless earbuds"
    ],
    "marketplace": "US"
};

// Run the Actor and wait for it to finish
const run = await client.actor("logiover/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": ["wireless earbuds"],
    "marketplace": "US",
}

# Run the Actor and wait for it to finish
run = client.actor("logiover/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": [
    "wireless earbuds"
  ],
  "marketplace": "US"
}' |
apify call logiover/amazon-product-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,logiover/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/vZgRy8rgIGGuaT1nF/builds/cwFKXmlvy1RUzyaot/openapi.json