# Amazon Search Or Category Scrapper (`sigma-dev/amazon-search-or-category-scrapper`) Actor

Scrape Amazon search results and category pages with ease. Extract product titles, prices, ratings, reviews, ASINs, images, URLs, and other key product details in structured JSON.

- **URL**: https://apify.com/sigma-dev/amazon-search-or-category-scrapper.md
- **Developed by:** [Sigma Dev](https://apify.com/sigma-dev) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.00 / 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.

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

### What does Amazon Search & Category Scraper do?

**Amazon Search & Category Scraper** extracts product listings from [Amazon](https://www.amazon.com) **search results**, **category pages** and **Best Sellers lists** in **23 Amazon marketplaces**. Enter keywords or paste Amazon URLs and get one clean record per product: **ASIN, title, price, list price, discount, star rating, number of ratings, "bought in past month", sponsored flag, Prime, Amazon's Choice and Best Seller badges, coupons, delivery info, images and the product's rank on the page**.

It works like a shopper browsing the listing pages. It never opens individual product pages, so it is **fast and cheap**: a single request returns 16–60 products.

Running it on the Apify platform also gives you:

- API access, plus scheduling to track prices and rankings over time
- integrations with Google Sheets, Make, Zapier, Slack and webhooks
- automatic proxy rotation in the right country for every marketplace
- run monitoring and alerts

### Why scrape Amazon search results and categories?

- 📈 **Price monitoring:** follow the prices, list prices and discounts of a whole product category every day.
- 🥇 **Rank tracking and SEO:** see where your products, and your competitors', rank for a keyword, both organically and as sponsored ads.
- 🔎 **Market and competitor research:** find the best-rated, best-selling and newest products in any niche, with review counts and "bought in past month" demand signals.
- 🏆 **Best Sellers intelligence:** download the top 100 of any Best Sellers, New Releases, Movers & Shakers, Most Wished For or Gift Ideas list.
- 🛒 **Catalog and lead enrichment:** collect ASINs to feed into your own pipelines or other Actors.

### How to scrape Amazon search results

1. Click **Try for free** and open the **Input** tab.
2. Type one or more **search keywords** (e.g. `wireless mouse`) and pick the **marketplace**, *or* paste Amazon URLs into **Start URLs**: searches, categories or Best Sellers lists.
3. Optionally set the **sort order**, a **price range** and **how many results** you want per keyword or URL.
4. Click **Start** and wait for the run to finish. Most runs take less than a minute.
5. Download your data from the **Output** tab as JSON, CSV, Excel, XML or HTML, or fetch it through the API.

#### Which Amazon URLs can I use?

| Page type | Example URL |
|---|---|
| Search results | `https://www.amazon.com/s?k=laptop&s=review-rank` (filters and sort order in the URL are kept) |
| Category / browse node | `https://www.amazon.com/b?node=172282`, `https://www.amazon.com/s?rh=n%3A541966`, `https://www.amazon.com/gp/browse.html?node=11036491` |
| Best Sellers | `https://www.amazon.com/gp/bestsellers/electronics` or `https://www.amazon.com/Best-Sellers-Electronics/zgbs/electronics` |
| New Releases, Movers & Shakers, Most Wished For, Gift Ideas | `https://www.amazon.co.uk/gp/new-releases/kitchen`, `https://www.amazon.de/gp/movers-and-shakers/toys` |

Category URLs are converted to Amazon's **full product listing** for that category (`/s?rh=n:<node>&fs=true`). Top-level categories would otherwise show a curated landing page without a product grid. Product detail pages (`/dp/…`) are not supported.

**Marketplaces:** amazon.com, .co.uk, .de, .fr, .it, .es, .nl, .com.be, .ie, .se, .pl, .com.tr, .ca, .com.mx, .com.br, .in, .co.jp, .com.au, .sg, .ae, .sa, .eg and .co.za.

### Input

All options are described in the **Input** tab. The most important ones:

| Field | Description | Default |
|---|---|---|
| `searchKeywords` | Keywords to search for, one search per keyword | – |
| `marketplace` | Amazon site used for the keywords | `amazon.com` |
| `startUrls` | Amazon search, category and Best Sellers URLs | – |
| `sortBy` | Featured, price low→high or high→low, average review, newest, best sellers | Featured |
| `minPrice` / `maxPrice` | Price range in whole units of the marketplace currency | – |
| `maxItemsPerSource` | Max products per keyword or URL (`0` = no limit) | 100 |
| `maxPagesPerSource` | Max result pages per keyword or URL | 20 |
| `maxItems` | Max products for the whole run (`0` = no limit) | 0 |
| `includeSponsored` | Keep sponsored products (always flagged with `isSponsored`) | `true` |
| `deduplicateItems` | Save each product only once per keyword or URL | `true` |
| `language` | Page language such as `en_GB` (e.g. amazon.de in English) | marketplace default |
| `proxyConfiguration` | Proxies. Residential is recommended | Apify Residential |

Example input:

```json
{
    "searchKeywords": ["wireless mouse", "mechanical keyboard"],
    "marketplace": "amazon.com",
    "startUrls": [
        { "url": "https://www.amazon.com/gp/bestsellers/electronics" },
        { "url": "https://www.amazon.com/b?node=11036491" }
    ],
    "sortBy": "review-rank",
    "minPrice": 20,
    "maxItemsPerSource": 200,
    "proxyConfiguration": { "useApifyProxy": true, "apifyProxyGroups": ["RESIDENTIAL"] }
}
```

### Output

Each product is one item in the dataset. You can download the dataset in various formats such as **JSON, HTML, CSV, or Excel**. A search result looks like this:

```json
{
    "asin": "B004YAVF8I",
    "title": "Logitech M185 Compact Ambidextrous 2.4 GHz Wireless Mouse - Swift Grey",
    "subtitle": "Ambidextrous mouse with 2.4 GHz USB-A Nano Receiver, Optical Tracking, 12-Months Battery Life, PC, Mac, Laptop compatible",
    "brand": null,
    "url": "https://www.amazon.com/dp/B004YAVF8I",
    "price": { "value": 13.99, "currency": "USD", "raw": "$13.99" },
    "priceMax": null,
    "listPrice": { "value": 17.99, "currency": "USD", "raw": "$17.99", "label": "List" },
    "discountPercent": 22,
    "unitPriceText": null,
    "stars": 4.4,
    "reviewsCount": 45051,
    "boughtInPastMonth": 10000,
    "boughtInPastMonthText": "10K+ bought in past month",
    "isSponsored": false,
    "isPrime": true,
    "isAmazonChoice": true,
    "isBestSeller": false,
    "badges": ["Overall Pick"],
    "couponText": null,
    "deliveryText": "Join Prime to get FREE delivery Tomorrow, Sep 24 Or Non-members get FREE delivery Mon, Sep 28 on $35 of items shipped by Amazon",
    "availabilityText": null,
    "otherOffersText": "More Buying Choices $6.72 (5+ used & new offers)",
    "thumbnailImage": "https://m.media-amazon.com/images/I/51WN5aXZWIL._AC_UY218_.jpg",
    "image": "https://m.media-amazon.com/images/I/51WN5aXZWIL.jpg",
    "rank": null,
    "salesRank": null,
    "salesRankPrevious": null,
    "salesRankChangePercent": null,
    "isPartial": false,
    "page": 1,
    "positionOnPage": 3,
    "organicRank": 1,
    "position": 3,
    "input": "wireless mouse",
    "sourceType": "keyword",
    "searchKeyword": "wireless mouse",
    "listType": null,
    "listTitle": null,
    "sourceUrl": "https://www.amazon.com/s?k=wireless%20mouse",
    "pageUrl": "https://www.amazon.com/s?k=wireless%20mouse",
    "marketplace": "US",
    "domain": "amazon.com",
    "deliverTo": "Update location",
    "scrapedAt": "2026-09-24T10:12:31.204Z"
}
```

Best Sellers items have the same fields, plus `rank` (1–100), `listType` (`bestsellers`, `new-releases`, `movers-and-shakers`, `most-wished-for` or `most-gifted`) and `listTitle` (e.g. "Best Sellers in Electronics"). Movers & Shakers items also get `salesRank`, `salesRankPrevious` and `salesRankChangePercent`.

#### Run summary

Every run also saves a **`RUN_SUMMARY`** record in the key-value store (linked from the Output tab). For each keyword and URL it lists:

- the number of products saved and pages scraped;
- the total results Amazon reported;
- duplicates and ads skipped;
- **why crawling stopped**: `limit-reached`, `last-page`, `max-pages`, `no-results`, `blocked` or `failed`;
- any pages that failed.

Errors never end up in the dataset, so you don't pay for them.

### Data fields

| Field | Description |
|---|---|
| `asin` | Amazon Standard Identification Number |
| `title`, `subtitle`, `brand` | Product title, the feature line shown under it, and the brand line when the listing shows one |
| `url` | Canonical product URL (`/dp/<ASIN>`) |
| `price`, `priceMax` | Current price (`value`, ISO `currency`, `raw` text); `priceMax` is set for price ranges |
| `listPrice`, `discountPercent` | Crossed-out price with its label (List, Typical, Was, UVP, M.R.P…) and the discount in % |
| `unitPriceText` | Price per unit, e.g. `$4.05/pack` |
| `stars`, `reviewsCount` | Average rating and exact number of ratings |
| `boughtInPastMonth` | "10K+ bought in past month" as a number (10000) plus the original text |
| `isSponsored`, `isPrime`, `isAmazonChoice`, `isBestSeller`, `badges` | Ad flag and badges |
| `couponText`, `deliveryText`, `availabilityText`, `otherOffersText` | Coupon, delivery promise, low-stock warning, other offers |
| `thumbnailImage`, `image` | Listing thumbnail and full-size image |
| `page`, `positionOnPage`, `organicRank`, `position` | Where the product appeared: page number, slot on the page, rank among non-sponsored results, and position among all saved results |
| `rank`, `salesRank*` | Best Sellers rank and Movers & Shakers sales-rank change |
| `input`, `sourceType`, `searchKeyword`, `listType`, `listTitle`, `sourceUrl`, `pageUrl` | Which keyword or URL the product came from |
| `marketplace`, `domain`, `deliverTo`, `scrapedAt` | Marketplace, the delivery location Amazon showed, and the scrape time |

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

The Actor only loads listing pages and each page returns 16–60 products, so it needs roughly **40–60 page loads per 1,000 products**.

- **Proxy traffic:** each page load uses about **0.2 MB** of proxy traffic, so 1,000 products typically take **8–12 MB of Residential proxy traffic**.
- **Compute:** a few minutes at 2 GB of memory, a small fraction of a compute unit.

With Apify's free monthly credits you can scrape thousands of products per month. Blocked pages are retried through new IPs, which adds some traffic on busy days. The **`RUN_SUMMARY`** shows how many pages each keyword needed.

### Tips and advanced options

- **Use Residential proxies and leave the proxy country empty.** The Actor then loads every marketplace through IPs from its own country. Amazon adapts prices, currency, delivery information and even the product selection to the visitor's location.
- **More than ~20 pages per keyword?** Amazon stops keyword searches at 7–20 pages. To collect more products:
  - Split the search into narrower keywords.
  - Use price ranges (`minPrice`/`maxPrice`), or combine a keyword with a category URL.
  - Category listings go up to 400 pages.
- **Keep costs predictable.** Set `maxItemsPerSource` and `maxItems`. The Actor also stops as soon as your maximum cost per run is reached.
- **Track rankings.** Schedule the Actor daily and compare `organicRank` and `position` per ASIN over time.
- **Faster runs.** Many keywords run in parallel (`maxConcurrency`). Pages of a single keyword are loaded one after another, which is what Amazon's pagination requires.
- **Debugging.** Enable **Save HTML of problematic pages** to store blocked or empty pages in the key-value store.

### FAQ, disclaimers and support

**Is it legal to scrape Amazon?** The Actor only collects publicly available product data that anyone can see without logging in. It does not collect personal data. Scraping is generally legal, but you should check Amazon's terms of service and the laws that apply to your use case. If in doubt, consult a lawyer. See also our blog post on [the legality of web scraping](https://blog.apify.com/is-web-scraping-legal/).

**Why are some prices missing?** Amazon only shows a price when the product has an offer that can be delivered to the visitor's location, and it shows "See options" for some products with variations. Loading each marketplace from its own country (the default) keeps missing prices to a minimum.

**Does it set a delivery ZIP code?** Not yet. Prices and delivery dates are those Amazon shows to a visitor from the proxy's location.

**Why did a keyword stop early with `blocked`?** Amazon sometimes answers automated traffic with CAPTCHAs or JavaScript challenges. The Actor retries every page with up to 10 new IP addresses and never tries to solve CAPTCHAs. At the time of writing, some marketplaces protect their search pages much more aggressively than others. For example, amazon.it and amazon.fr sometimes challenge every automated request. Best Sellers lists are usually still available there.

**Are sponsored products included?** Yes, marked with `isSponsored: true`. Turn off **Include sponsored products** to skip them. `organicRank` ignores ads.

**Feedback and custom solutions.** Found a bug or a page that doesn't work? Please open an issue in the **Issues** tab and include the run URL. Need a customized version, e.g. product detail pages, reviews, delivery ZIP codes or a different output format? Get in touch through the Issues tab.

# Actor input Schema

## `searchKeywords` (type: `array`):

Keywords to search for on Amazon, e.g. <code>wireless mouse</code>. Each keyword is a separate search on the marketplace selected below.

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

Amazon website used for the search keywords. Start URLs always use their own domain.

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

Amazon pages to scrape:<ul><li><b>Search results</b>, e.g. <code>https://www.amazon.com/s?k=laptop</code></li><li><b>Categories</b>, e.g. <code>https://www.amazon.com/b?node=172282</code> or any <code>/s?rh=n:…</code> link</li><li><b>Best Sellers</b>, <b>New Releases</b>, <b>Movers & Shakers</b>, <b>Most Wished For</b> and <b>Gift Ideas</b> lists, e.g. <code>https://www.amazon.com/gp/bestsellers/electronics</code></li></ul>Product detail pages are not supported.

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

Sort order for keyword searches and category listings. Ignored for URLs that already contain a sort order and for Best Sellers lists.

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

Only return products priced at or above this amount, in whole units of the marketplace currency (e.g. <code>20</code> = $20 on amazon.com). Applies to keyword searches and category listings.

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

Only return products priced at or below this amount, in whole units of the marketplace currency.

## `includeSponsored` (type: `boolean`):

Keep sponsored (advertised) products in the results. They are always marked with <code>isSponsored: true</code>.

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

Optional page language in the form <code>xx\_XX</code>, e.g. <code>en\_GB</code> to get amazon.de in English or <code>es\_US</code> for amazon.com in Spanish. Leave empty for the marketplace default.

## `maxItemsPerSource` (type: `integer`):

Maximum number of products saved for each keyword and each start URL. <code>0</code> means no limit.

## `maxPagesPerSource` (type: `integer`):

Maximum number of result pages visited for each keyword and each start URL. Amazon shows up to 20 pages for keyword searches (often only 7) and up to 400 pages for categories. Best Sellers lists have 2 pages of 50 products.

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

Stop the whole run after saving this many products across all keywords and URLs. <code>0</code> means no limit.

## `deduplicateItems` (type: `boolean`):

Save each product at most once per keyword or URL (Amazon sometimes repeats products on later pages). A sponsored and an organic placement of the same product are both kept.

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

Amazon blocks datacenter IPs quickly, so <b>Residential</b> proxies are recommended. If you don't select a country, every marketplace is loaded through proxies from its own country, so prices and delivery information match that marketplace.

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

Maximum number of pages loaded in parallel. Higher values are faster but more likely to be blocked.

## `maxRequestRetries` (type: `integer`):

How many times a page that failed with an error is retried. Pages blocked by Amazon are additionally retried up to 10 times, each time with a new IP address.

## `debugSaveHtml` (type: `boolean`):

Store the HTML of blocked, empty or failed pages in the key-value store (up to 30 pages) to help with debugging.

## Actor input object example

```json
{
  "searchKeywords": [
    "wireless mouse"
  ],
  "marketplace": "amazon.com",
  "sortBy": "relevanceblender",
  "includeSponsored": true,
  "maxItemsPerSource": 100,
  "maxPagesPerSource": 20,
  "maxItems": 0,
  "deduplicateItems": true,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  },
  "maxConcurrency": 10,
  "maxRequestRetries": 5,
  "debugSaveHtml": false
}
```

# Actor output Schema

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

No description

## `summary` (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 = {
    "searchKeywords": [
        "wireless mouse"
    ],
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("sigma-dev/amazon-search-or-category-scrapper").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 = {
    "searchKeywords": ["wireless mouse"],
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("sigma-dev/amazon-search-or-category-scrapper").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 '{
  "searchKeywords": [
    "wireless mouse"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call sigma-dev/amazon-search-or-category-scrapper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,sigma-dev/amazon-search-or-category-scrapper"
        }
    }
}
```

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/2hJxFrMq0TUed1Dqd/builds/jCEnm3hLHqVsGJ4UB/openapi.json
