# Amazon Product Scraper - Search, Best Sellers (`automation_craft/amazon-data-scraper`) Actor

One Amazon scraper for six jobs: search, product detail, best sellers, new releases, seller storefronts and keyword ideas. Across 20 marketplaces: title, brand, price, rating, review count, availability, Best Sellers Rank, images and specs. No browser. Export JSON, CSV or Excel. Pay per result.

- **URL**: https://apify.com/automation_craft/amazon-data-scraper.md
- **Developed by:** [Automation Craft](https://apify.com/automation_craft) (community)
- **Categories:** E-commerce, Marketing, Developer tools
- **Features:** Limited permissions
- **Stats:** 13 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

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

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

### Amazon Product Scraper - Search, Best Sellers

This Amazon product scraper returns Amazon data as a clean spreadsheet or JSON file, with **no coding needed**. Pick what you want (a **mode**), enter a keyword, product or category, and press Start. It works on **20 Amazon country sites**, and you **only pay for results you actually get**: if Amazon blocks a page, it costs you nothing.

Other tools make you rent a separate scraper for search, another for products, another for best sellers. **This is one tool that does all six.**

### Quick start

1. Choose a **mode**: `search`, `product`, `bestsellers`, `newreleases`, `seller` or `suggestions`.
2. Fill the one input that mode uses: `search` terms, `asins`, `category` or `sellerIds`.
3. Pick the **marketplace** and set `maxItems` as a hard cap on cost.
4. Click **Start**, then export the dataset as JSON, CSV or Excel, or read it through the API.

**Search amazon.com for "wireless headphones", first 2 pages:**

```json
{ "mode": "search", "search": ["wireless headphones"], "marketplace": "com", "maxPagesPerQuery": 2 }
```

**Full detail for two products:**

```json
{ "mode": "product", "asins": ["B09XS7JWHH", "https://www.amazon.co.uk/dp/B08N5WRWNW"] }
```

**Top 100 best-selling electronics in India:**

```json
{ "mode": "bestsellers", "category": ["electronics"], "marketplace": "in", "maxItems": 100, "maxPagesPerQuery": 4 }
```

**Every product from a seller's storefront:**

```json
{ "mode": "seller", "sellerIds": ["A2L77EE7U53NWQ"], "marketplace": "com", "maxPagesPerQuery": 5 }
```

**Keyword ideas for PPC:**

```json
{ "mode": "suggestions", "search": ["wireless head", "yoga"], "marketplace": "com" }
```

#### Modes (pick one per run)

| Mode | What you get | Give it |
|---|---|---|
| **Search** | Product cards for a keyword: title, price, list price, rating, review count, image, Prime, sponsored flag, ASIN | **Search terms** |
| **Product detail** | Everything for specific products: title, brand, price, rating, review count, availability, Best Sellers Rank, feature bullets, all images, full spec table | **ASINs or product URLs** |
| **Best sellers** | A category's Best Sellers ranking (rank, ASIN, title, price, rating, review count) | **Category** |
| **New releases** | A category's newest products | **Category** |
| **Seller storefront** | Every product a seller lists | **Seller IDs** |
| **Keyword suggestions** | Amazon's autocomplete completions for a prefix, for keyword research and PPC | **Search terms** |

### What you get

One row per result in the dataset, tagged with `type` (`search`, `product`, `bestsellers`, `new-release`, `seller` or `suggestion`) so you can filter mixed exports. Prices come back both as a number (`price`) and with the `currency` symbol, ratings as a 0 to 5 number, and review counts as integers.

Filter the dataset view by `type` for a clean per-mode table, or export the whole run as JSON, CSV or Excel.

#### What this can do

Pull Amazon's **public catalogue data**, the things you can see on Amazon without logging in: product listings and prices, ratings and review **counts**, images, brand, best-seller rank, availability, seller info, keyword ideas and more.

#### What this cannot do

- **It does not download the text of customer reviews.** Amazon hides full reviews behind a login, so no tool can reliably scrape review text. You do get each product's **star rating** and **number of reviews**, just not the written paragraphs.
- It does not access anything private such as orders, seller dashboards or buyer information. Public pages only.

#### Reliability

- **HTTP-based**, with no browser, so it is fast and cheap.
- Every request is **isolated**, so one product failing never corrupts another's result, which is a common bug in other Amazon actors.
- Amazon occasionally rate-limits or serves a bot check, and the Actor **retries on a fresh proxy session** automatically. If a page stays blocked after retries it is reported as an `error` row and, because billing is pay per result, it costs you nothing.
- Residential proxies are the default and give the best success rate. Datacenter IPs get blocked quickly and are not recommended.
- The proxy exit is pinned to the marketplace's country automatically (UK IPs for amazon.co.uk, German IPs for amazon.de, and so on). Amazon serves a JavaScript bot challenge instead of results to out-of-country IPs on some marketplaces, amazon.co.uk in particular, and the Actor detects and retries those pages on a fresh session.

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

Pay per event. Current prices:

| Event | Free and Bronze | Silver (10% off) | Gold and above (20% off) |
|---|---|---|---|
| **Result** (`result-item`), from Search, Best sellers, New releases, Seller or Suggestions | $0.002 | $0.0018 | $0.0016 |
| **Product** (`product-detail`), one full product record | $0.0075 | $0.00675 | $0.006 |
| **Actor Start** (`apify-actor-start`) | $0.01 | $0.01 | $0.01 |

The Actor Start event is charged once per run, one event per GB of memory, minimum one event, and carries no Store discount. So 1,000 search rows cost about $2 on Free and Bronze, $1.80 on Silver and $1.60 on Gold and above, and 1,000 full product records cost $7.50, $6.75 and $6.

You are charged only for results actually returned. A run that gets blocked and returns nothing costs only the Actor Start fee, and `maxItems` is a hard cap on the rest.

### Input

- **`mode`**: which data type to scrape (see the table). Each mode uses one input field:
  - Search and Keyword suggestions use **`search`** (a list of keywords)
  - Product detail uses **`asins`** (ASINs or full product URLs, where a URL's marketplace wins)
  - Best sellers and New releases use **`category`** (a slug such as `electronics`, `books` or `toys-and-games`, or a full best-sellers URL)
  - Seller storefront uses **`sellerIds`** (the value after `seller=` or `me=` in a storefront URL)
- **`marketplace`**: which Amazon site, 20 in total from `com` and `co.uk` to `in`, `co.jp` and `com.br`. A full product URL overrides it.
- **`maxItems`**: hard cap on total result rows, for cost control.
- **`maxPagesPerQuery`**: how many pages to follow for Search, Seller, Best sellers and New releases. Each page holds roughly 16 to 60 items. Ignored by Product detail and Keyword suggestions.
- **`maxConcurrency`**: parallel requests.
- **`proxyConfiguration`**: residential proxy by default, strongly recommended because Amazon blocks datacenter IPs. The Actor adds the marketplace's country to a residential Apify proxy configuration unless you set one yourself.

### FAQ

#### Can it scrape Amazon review text?

No, and no tool can do it reliably, because Amazon puts full review bodies behind a login. You do get each product's average star rating and its total review count in every mode that returns products, which covers most rating and reputation analysis.

#### Which Amazon marketplaces are supported?

Twenty: amazon.com, co.uk, de, fr, it, es, in, ca, com.au, com.br, com.mx, co.jp, nl, se, ae, sg, pl, com.tr, sa and eg. Set `marketplace`, or paste a full product URL and its marketplace wins.

#### Do I need an Amazon API key or a seller account?

No. The Actor reads public Amazon pages over plain HTTP, so there is no API key, no login and no seller account. It never touches orders, seller dashboards or buyer information.

#### How do I find the category slug for best sellers?

Open the Best Sellers page on the marketplace you are targeting and copy the slug out of the URL, for example `electronics` or `toys-and-games`. Slugs differ between marketplaces, and you can also paste the full best-sellers URL into `category` instead.

#### What happens when Amazon blocks a page?

The Actor retries it on a fresh residential proxy session. If it stays blocked, the run emits an `error` row instead of a result, and because billing is pay per result that page costs you nothing.

#### Can I use it for PPC keyword research?

Yes. Run `mode: "suggestions"` with prefixes in `search`, for example `wireless head`, and you get Amazon's own autocomplete completions for that marketplace, which are the phrases shoppers are actually typing.

#### Why does this Actor run with limited permissions?

Least privilege. It only reads and writes its own run storages, the dataset and key-value store Apify creates for each run, so it never needs access to the rest of your account. It reads only public Amazon catalogue pages.

### Notes and limits

- This scrapes **public** Amazon listing and catalogue data. It does not scrape individual review text, because Amazon login-walls full reviews. Average rating and review count are included, the review bodies are not.
- **Price** is returned for the vast majority of products. A small number legitimately have no price (pre-orders, "see buying options", currently unavailable items), and Amazon occasionally serves a page variant where the price loads dynamically. Product mode automatically re-fetches to recover it, but `price` can still be `null` in those cases. All other fields are unaffected.
- Category slugs vary by marketplace, so copy them from the Best Sellers URL on the marketplace you are targeting.
- Respect Amazon's Terms of Service and applicable laws. You are responsible for how you use scraped data.

### More data tools by Automation Craft

- [ShopBack Scraper - Cashback Rates, Affiliates](https://apify.com/automation_craft/affiliate-network-detector)
- [Google Trends Scraper - Compare and Trending Now](https://apify.com/automation_craft/google-trends-scraper)
- [G2 Reviews Scraper: Ratings, Pros and Cons](https://apify.com/automation_craft/g2-reviews-scraper)
- [Meta Ad Library Scraper - All Placements, Filters](https://apify.com/automation_craft/meta-ads-library-scraper)
- [Facebook Ads Library Scraper - Page Ads, No Login](https://apify.com/automation_craft/facebook-ads-library-scraper)
- [Airbnb Scraper: Prices, Calendar, Reviews](https://apify.com/automation_craft/airbnb-scraper)
- [Website Screenshot Scraper: Full Page, Bulk](https://apify.com/automation_craft/website-screenshot-scraper)
- [Substack Scraper: Posts, Notes and Profiles](https://apify.com/automation_craft/substack-scraper)

# Actor input Schema

## `mode` (type: `string`):

Pick one data type. Each mode uses a different input field below (the field it needs is named in its description):

• <b>Search</b> - products for a keyword (uses <b>Search terms</b>)
• <b>Product detail</b> - full data for specific products (uses <b>ASINs or product URLs</b>)
• <b>Best sellers</b> - a category's best-seller ranking (uses <b>Category</b>)
• <b>New releases</b> - a category's newest products (uses <b>Category</b>)
• <b>Seller storefront</b> - all products from a seller (uses <b>Seller IDs</b>)
• <b>Keyword suggestions</b> - Amazon autocomplete for a prefix (uses <b>Search terms</b>)

## `search` (type: `array`):

Used by <b>Search</b> and <b>Keyword suggestions</b> modes. One or more keywords, e.g. <code>wireless headphones</code>. In Search mode each term returns product cards; in Keyword suggestions mode each term returns Amazon's autocomplete completions.

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

Used by <b>Product detail</b> mode. One entry per product - either a 10-character ASIN (e.g. <code>B09XS7JWHH</code>) or a full Amazon product URL. A full URL's marketplace overrides the Marketplace field below.

## `category` (type: `array`):

Used by <b>Best sellers</b> and <b>New releases</b> modes. An Amazon category slug (e.g. <code>electronics</code>, <code>books</code>, <code>toys-and-games</code>, <code>kitchen</code>) OR a full best-sellers/new-releases URL. You can list several. Tip: open a Best Sellers page on Amazon and copy the word after <code>/bestsellers/</code> in the URL.

## `sellerIds` (type: `array`):

Used by <b>Seller storefront</b> mode. One or more Amazon seller IDs (the value after <code>seller=</code> or <code>me=</code> in a seller's storefront URL, e.g. <code>A2L77EE7U53NWQ</code>). Returns every product listed on each seller's storefront.

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

Which Amazon site to scrape. For bare ASINs/keywords/categories this decides the domain; a full product URL overrides it. Works on all listed marketplaces.

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

Hard cap on the total number of result rows this run will produce (across all your inputs). Keeps cost predictable. You are only charged per result row returned.

## `maxPagesPerQuery` (type: `integer`):

For Search, Seller, Best sellers and New releases modes: how many result pages to follow per input (each page is ~16–60 products). 1 = first page only. Ignored by Product detail and Keyword suggestions modes.

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

Maximum requests fetched in parallel.

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

Proxy for requests. Residential proxies are the default and strongly recommended, Amazon blocks datacenter IPs quickly. The Actor pins the residential exit to the marketplace's country automatically (for example UK IPs for amazon.co.uk), because Amazon serves a bot challenge to out-of-country IPs. Set a country here only if you need to override that.

## Actor input object example

```json
{
  "mode": "search",
  "search": [
    "wireless headphones",
    "yoga mat"
  ],
  "asins": [
    "B09XS7JWHH",
    "https://www.amazon.com/dp/B08N5WRWNW"
  ],
  "category": [
    "electronics",
    "books"
  ],
  "sellerIds": [
    "A2L77EE7U53NWQ"
  ],
  "marketplace": "in",
  "maxItems": 100,
  "maxPagesPerQuery": 1,
  "maxConcurrency": 8,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

## `results` (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 = {
    "search": [
        "wireless headphones"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation_craft/amazon-data-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 = { "search": ["wireless headphones"] }

# Run the Actor and wait for it to finish
run = client.actor("automation_craft/amazon-data-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 '{
  "search": [
    "wireless headphones"
  ]
}' |
apify call automation_craft/amazon-data-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,automation_craft/amazon-data-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/7hS2baVFiqh4rbgFy/builds/0MQC4t7QCVysBvGqk/openapi.json