# Amazon Search Scraper With Product Detail Pages (`scrapier/amazon-search-scraper`) Actor

Amazon Search Scraper extracts product listings and detailed product page data, including titles, prices, ASINs, ratings, reviews, images, descriptions, availability, seller details, and URLs. Ideal for product research, price tracking, competitor analysis, and e-commerce intelligence.

- **URL**: https://apify.com/scrapier/amazon-search-scraper.md
- **Developed by:** [Scrapier](https://apify.com/scrapier) (community)
- **Categories:** E-commerce, Lead generation, Automation
- **Stats:** 16 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $5.99 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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 Search Scraper — Products with Brand, BSR and Variant Data

Amazon Search Scraper With Product Detail Pages turns a keyword or Amazon search URL into a clean product dataset, then opens each product's own page for what a search tile cannot carry: brand, best-seller rank, category path, availability, sold-by/ships-from, coupon text, authoritative review count and the real variant map. Every response is structured JSON — ready to pass to an LLM, index into a vector store, or feed a monitoring pipeline. Rows are pushed to the dataset live as the run works.

***

### 🧭 What is Amazon Search Scraper With Product Detail Pages?

It is a query-driven Amazon scraper: you give it a keyword or a full Amazon search URL, and it returns one row per product found in the results — plus, when the detail pass is on, every field that only exists on that product's own page. A plain search-result tile structurally cannot carry brand, best-seller rank, category breadcrumb or sibling-variant ASINs; this Actor opens the product page itself to fill those in, so the same run does discovery and enrichment together. No Amazon account or login is required — requests run through Apify Proxy.

- 🔍 Keyword or full Amazon search-URL input, across 7 marketplaces (`.com`, `.co.uk`, `.de`, `.fr`, `.it`, `.es`, `.ca`)
- 🧬 Detail-page enrichment pass: brand, best-seller ranks, full category path, availability, sold by / ships from, coupon text, the authoritative review count, feature bullets and the real variant map
- ↕️ All six result orders Amazon itself offers: featured, price low→high, price high→low, average customer review, newest arrivals, best sellers
- 📦 Per-search-term product limits, so every keyword you enter is actually searched, not starved by earlier ones
- 🎟️ Locale-correct pricing and coupon text per marketplace, with a captured `currency` on every row
- 🔴 Live results — rows land in the dataset as soon as they're collected, not only at the end of the run

### 📊 What data can you get with Amazon Search Scraper With Product Detail Pages?

Every dataset row is a `product` row that carries two groups of fields: what the search-results page itself shows, and — when the detail pass runs — what only the product's own page has.

| Result Type | Extracted Fields | Primary Use Case |
| --- | --- | --- |
| Search-result fields | `asin`, `productDescription`, `imgUrl`, `dpUrl`, `price`, `currency`, `retailPrice`, `listPriceLabel`, `productRating`, `countReview`, `secondaryOffer`, `offerCount`, `badge`, `prime`, `sponsored`, `salesVolume`, `deliveryMessage`, `manufacturer`, `series` | Fast keyword sweeps, price and offer tracking |
| Detail-page fields (enrichment pass) | `brand`, `bestsellerRanks`, `categoryPath`, `categories`, `nodeHierarchy`, `availability`, `soldBy`, `shipsFrom`, `couponText`, `detailReviewCount`, `productDetails`, `variantAsins`, `variantLabels`, `variantCount`, `variations` | Product research, competitor monitoring, catalogue mapping |
| Run/query context (on every row) | `keyword`, `domainCode`, `page`, `currentPage`, `searchResultPosition`, `resultCount`, `maxPagesAvailable`, `sortStrategy`, `selectedCategory`, `browseNode`, `searchRefinements`, `similarKeywords` | Reconstructing what search produced the row, and where it ranked |
| Zero-result notice (`type: "notice"`, uncharged) | `statusCode`, `statusMessage`, `keyword`, `scrapedAt` | Detecting a run that found nothing at all |

#### Detail-page enrichment

Turning `enrichFromProductPage` on (the default) opens every collected ASIN's own product page and merges in the fields a search tile cannot carry. `brand` comes from the product page's dedicated brand row; `bestsellerRanks` is every Best Sellers Rank the product holds, as `{rank, category, url}`; `categoryPath` is the full breadcrumb, top level first, and `nodeHierarchy` is that same path joined with `" > "`. The variant map — `variantAsins`, `variantLabels`, `variantCount` and `variations` — is read from the product page's own configuration data (colour, size, or spec siblings), not guessed from the title. Coverage is capped by `maxDetailFetches`, a single budget shared across every search term in the run.

```json
{
  "brand": "ASUS",
  "bestsellerRanks": [
    { "rank": 179, "category": "Computers & Accessories", "url": null },
    { "rank": 12, "category": "Traditional Laptop Computers", "url": "https://www.amazon.com/gp/bestsellers/pc/13896615011" }
  ],
  "categoryPath": ["Electronics", "Computers & Accessories", "Computers & Tablets", "Laptops", "Traditional Laptops"],
  "nodeHierarchy": "Electronics > Computers & Accessories > Computers & Tablets > Laptops > Traditional Laptops",
  "variantCount": 4,
  "variantAsins": ["B0H3WXMW41", "B0DW1X5YCQ", "B0H3WNY8RR", "B0DW1FVPK8"],
  "variantLabels": ["Ultra 9 | RTX 5070 | 16GB,1TB", "RTX 5070 Ti", "Ultra 9 | RTX 5070 | 16GB,2TB", "Ultra 9 | RTX 5080"]
}
```

#### Pricing and offer fields

Every row also carries locale-correct pricing: `price`, `retailPrice` (the struck-through list price, when Amazon shows one), `listPriceLabel` (whether that figure was labelled `List` or `Typical`), `currency`, and the lowest competing offer as `secondaryOffer` / `offerCount`. Numbers are parsed with a locale-aware routine, so a German-marketplace price like `1.299,00` and a US price like `1,299.00` both resolve to the same float. `countReview` is `null` when a product genuinely has no ratings — never a fabricated `0`.

### 🆚 How does Amazon Search Scraper With Product Detail Pages differ from the official Amazon API?

Amazon's own catalog API — the Product Advertising API (PA-API 5.0) — has been deprecated in favor of the **Creators API**, which now handles catalog search, ASIN lookup, pricing, images, reviews and availability (Amazon Associates / Creators API documentation, checked 2026-08-15). Reaching it at all requires an approved Associates or Creators account that keeps generating qualifying referral sales; access is reported to be revoked if an account has no qualifying sales for a trailing 30-day period, and PA-API 5.0 itself is reported to be retiring on 15 May 2026 (per third-party migration coverage, checked 2026-08-15). This Actor sidesteps that gate entirely — it reads the same public pages a shopper sees.

| Feature | Amazon Creators API / PA-API | This Actor |
| --- | --- | --- |
| Access requirement | Approved Associates/Creators account, plus ongoing qualifying sales (checked 2026-08-15) | Any Apify account — no Amazon account or approval needed |
| Intended use | Affiliate monetization and promoting products for commission | Any use — research, monitoring, sourcing |
| Catalog coverage | Search, ASIN lookup, pricing, images, reviews, availability | Same, plus best-seller rank, full category path, sold by / ships from, coupon text, real variant map |
| Setup | AWS-signature-based REST integration, Associates approval | Enter a keyword, click Start |
| Status | PA-API 5.0 deprecated; migrating to Creators API | Not affected by that migration — reads rendered HTML, not the deprecated endpoint |

If you already run a qualifying Associates account and only need catalog-standard fields, the official API is the supported, Amazon-sanctioned path. If you need best-seller rank, category breadcrumb, seller attribution or variant siblings — or you don't qualify for Associates access at all — this Actor covers that gap.

### 🔍 What is the difference between an Amazon search scraper and an Amazon product detail scraper?

A search scraper takes a keyword and returns a list — it reads only what's printed on the results-page tile: title, price, rating, a thumbnail. A product detail scraper takes a URL or ASIN you already know and returns one record — everything on that single product's page, including fields the search tile physically doesn't render, like brand, best-seller rank, category breadcrumb and sibling variants. The two categories exist separately because they answer different questions: "what's out there for this keyword?" versus "everything about this one listing."

That split forces a two-step workflow if you need both — search first, then feed every resulting ASIN into a second detail-page run. Amazon Search Scraper With Product Detail Pages does both in one job: every `product` row starts as a search-result row and, when `enrichFromProductPage` is on and the row falls inside `maxDetailFetches`, is enriched from its own detail page in the same pass, marked `detailStatus: "enriched"`. Rows beyond the budget keep their search-result fields only and are marked `"skipped"`.

### 🚀 How to scrape Amazon with Amazon Search Scraper With Product Detail Pages?

1. Open the Actor on its Apify Store page and click **Try for free** (or **Start**) to open the input form in Apify Console.
2. Add one or more entries to `searchTerms` — a plain keyword (`laptop`) or a full Amazon search URL (`https://www.amazon.co.uk/s?k=running+shoes`).
3. Set the real query controls you need: `resultOrder` for one of Amazon's six result orders, `productLimit` for how many products per search term, and `enrichFromProductPage` / `maxDetailFetches` / `detailFields` for the detail pass.
4. Click **Start** to launch the run.
5. When the run finishes (or while it's still working — rows are pushed live), download the dataset as JSON, CSV, Excel or another Apify-supported format from the **Storage** tab, or pull it programmatically with `apify_client`.

```json
{
  "searchTerms": ["laptop", "wireless headphones"],
  "productLimit": 5,
  "resultOrder": "relevanceblender",
  "enrichFromProductPage": true,
  "maxDetailFetches": 10
}
```

#### How to run multiple queries in one job

Add every keyword or search URL as its own entry in the `searchTerms` array — each is searched independently, up to `productLimit` products per entry, with the results de-duplicated by ASIN within that entry. Search terms are processed one at a time, in the order you list them, with a short randomized pause between them; there is no concurrency setting to raise, since the Actor works through one keyword's pages, then the next.

### ⬇️ Input

You can drive the Actor with a list of keywords/URLs (`searchTerms`) or, for backward compatibility, the legacy `urls` key. `urls` is only used when `searchTerms` is empty.

| Parameter | Required | Type | Description | Example Value |
| --- | --- | --- | --- | --- |
| `searchTerms` | No | Array | 🔍 Add one or more entries; each runs as its own search. Plain keywords use `amazon.com`; paste a country search URL (`com`, `co.uk`, `de`, `fr`, `it`, `es`, `ca`) to use that marketplace instead. | `["laptop", "https://www.amazon.co.uk/s?k=running+shoes"]` |
| `productLimit` | No | Integer | 📦 Maximum products to collect **for each** search term. Min `1`, max `10000`. Console prefill is `5`. Example: 2 search terms with a limit of 5 returns up to 10 rows total. | `5` |
| `resultOrder` | No | String (enum) | ↕️ The order Amazon applies before results are collected — one of `relevanceblender` (Featured / best match), `price-asc-rank` (Price: low to high), `price-desc-rank` (Price: high to low), `review-rank` (Average customer review), `date-desc-rank` (Newest arrivals), `exact-aware-popularity-rank` (Best sellers). Prefill `relevanceblender`. | `"review-rank"` |
| `enrichFromProductPage` | No | Boolean | 🧬 When on, every collected product is also read from its own page to add brand, best-seller ranks, category path, availability, sold by, ships from, coupon text, the authoritative review count, feature bullets and the variant map. When off, only search-result fields are returned. Default `true`. | `true` |
| `maxDetailFetches` | No | Integer | 🔢 How many products in the whole run may be enriched from their own page. The budget is spent in collection order and shared **across all search terms**; products beyond it keep search-result fields only and are marked `skipped`. Min `0`, max `1000`, default `10`. Set `0` to disable the pass entirely. | `10` |
| `detailFields` | No | Array (enum, multi-select) | 🧾 Which detail-page field groups to fill: `brand`, `rank`, `categoryPath`, `variants`, `availability`, `seller`, `coupon`, `reviews`, `features`. Default is all nine. | `["brand", "rank", "variants"]` |
| `urls` | No | Array | 🧩 Legacy alias of `searchTerms`. Used only when `searchTerms` is empty. | `["https://www.amazon.com/s?k=laptop"]` |
| `maxResults` | No | Integer | 🧩 Legacy alias of `productLimit`. Used only when `productLimit` is empty. Min `1`, max `10000`. Now applies **per search term**, not as a single shared total. | `5` |
| `sortBy` | No | String (enum) | 🧩 Legacy alias of `resultOrder`. Used only when `resultOrder` is empty. Enum is `relevanceblender` (Featured) or `recent` (Newest arrivals — now correctly mapped to Amazon's real newest-arrivals order instead of silently falling back to featured). | `"recent"` |
| `proxyConfiguration` | No | Object | 🌐 Connection settings. Prefill is `{"useApifyProxy": true, "apifyProxyGroups": ["RESIDENTIAL"]}` — the configuration that returns complete result pages. Leave as prefilled unless you have a reason to change it. | `{"useApifyProxy": true}` |

None of the fields above are required — an empty run with no search terms simply logs a warning and exits with an empty dataset.

#### Example input

```json
{
  "searchTerms": ["laptop", "wireless headphones"],
  "productLimit": 5,
  "resultOrder": "relevanceblender",
  "enrichFromProductPage": true,
  "maxDetailFetches": 10,
  "detailFields": ["brand", "rank", "categoryPath", "variants", "availability", "seller", "coupon", "reviews", "features"],
  "proxyConfiguration": { "useApifyProxy": true, "apifyProxyGroups": ["RESIDENTIAL"] }
}
```

**Common pitfall:** `maxDetailFetches` is one budget shared across the **whole run**, not per keyword. Enter 5 search terms with `maxDetailFetches` left at its default of 10, and only the first 10 products collected overall get enriched — the rest are pushed with `detailStatus: "skipped"` and empty detail columns, even though they still count toward each term's `productLimit`. Raise `maxDetailFetches` if you need every product enriched. A second pitfall: pasting a direct product-page URL (e.g. `.../dp/B0XXXXXXXX`) instead of a **search** URL into `searchTerms` produces nothing — the parser looks for a `k=` query parameter, which only search-result URLs carry.

### ⬆️ Output

Every run writes typed, normalized JSON rows to the default dataset — one row per product, in the order collected. Export as JSON, CSV, Excel, XML, RSS or HTML from the **Storage** tab, or pull it with the Apify API / `apify_client`. If a run's search terms produce zero products across the board, one extra `type: "notice"` row is written instead of leaving the dataset empty (see below).

#### Scraped results

```json
[
  {
    "type": "product",
    "isChild": false,
    "asin": "B0DZZWMB2L",
    "productDescription": "ASUS ROG Strix G16 (2025) Gaming Laptop, 16\" FHD+ 165Hz, NVIDIA GeForce RTX 5060, Intel Core i7 14650HX, 16GB DDR5, 1TB SSD",
    "brand": "ASUS",
    "manufacturer": "ASUS",
    "price": 1393.65,
    "currency": "USD",
    "retailPrice": 1599.99,
    "listPriceLabel": "List Price",
    "productRating": "4.5 out of 5 stars",
    "countReview": 539,
    "detailReviewCount": 552,
    "availability": "In Stock",
    "soldBy": "Amazon.com",
    "shipsFrom": "Amazon.com",
    "couponText": "Save 5% with coupon",
    "bestsellerRanks": [
      { "rank": 179, "category": "Computers & Accessories", "url": null },
      { "rank": 12, "category": "Traditional Laptop Computers", "url": "https://www.amazon.com/gp/bestsellers/pc/13896615011" }
    ],
    "categoryPath": ["Electronics", "Computers & Accessories", "Computers & Tablets", "Laptops", "Traditional Laptops"],
    "categories": ["Electronics", "Computers & Accessories", "Computers & Tablets", "Laptops", "Traditional Laptops"],
    "nodeHierarchy": "Electronics > Computers & Accessories > Computers & Tablets > Laptops > Traditional Laptops",
    "variantCount": 4,
    "variantAsins": ["B0H3WXMW41", "B0DW1X5YCQ", "B0H3WNY8RR", "B0DW1FVPK8"],
    "variantLabels": ["Ultra 9 | RTX 5070 | 16GB,1TB", "RTX 5070 Ti", "Ultra 9 | RTX 5070 | 16GB,2TB", "Ultra 9 | RTX 5080"],
    "variations": ["RTX 5060 | 1TB", "Ultra 9 | RTX 5070 | 16GB,1TB", "RTX 5070 Ti", "Ultra 9 | RTX 5070 | 16GB,2TB", "Ultra 9 | RTX 5080"],
    "badge": "Amazon's Choice",
    "prime": true,
    "sponsored": false,
    "salesVolume": "2K+ bought in past month",
    "deliveryMessage": "FREE delivery Tomorrow",
    "secondaryOffer": 1323.97,
    "offerCount": 2,
    "productDetails": ["16\" WQXGA 165Hz display", "NVIDIA GeForce RTX 5060 8GB GDDR7", "Intel Core i7-14650HX", "16GB DDR5 RAM, 1TB PCIe SSD", "Windows 11 Home"],
    "series": "Model G16",
    "keyword": "laptop",
    "domainCode": "com",
    "searchResultPosition": 1,
    "page": 1,
    "currentPage": 1,
    "maxPagesAvailable": 20,
    "resultCount": 100000,
    "sortStrategy": "relevanceblender",
    "selectedCategory": "aps",
    "browseNode": null,
    "searchRefinements": ["Intel Core i7", "16 GB", "Windows 11"],
    "similarKeywords": [{ "keyword": "gaming laptop", "url": "https://www.amazon.com/s?k=gaming+laptop" }],
    "dpUrl": "https://www.amazon.com/ASUS-ROG-Strix-Gaming-Laptop/dp/B0DZZWMB2L",
    "imgUrl": "https://m.media-amazon.com/images/I/71abc123.jpg",
    "detailStatus": "enriched",
    "statusCode": 200,
    "statusMessage": "FOUND",
    "scrapedAt": "2026-08-15T09:12:03Z"
  },
  {
    "type": "product",
    "isChild": false,
    "asin": "B0CQZX9KLT",
    "productDescription": "Lenovo IdeaPad Slim 5 14\" Laptop, AMD Ryzen 7, 16GB RAM, 512GB SSD",
    "brand": null,
    "manufacturer": "Lenovo",
    "price": 649.99,
    "currency": "USD",
    "retailPrice": null,
    "listPriceLabel": null,
    "productRating": "4.3 out of 5 stars",
    "countReview": 214,
    "detailReviewCount": null,
    "availability": null,
    "soldBy": null,
    "shipsFrom": null,
    "couponText": null,
    "bestsellerRanks": [],
    "categoryPath": [],
    "categories": [],
    "nodeHierarchy": null,
    "variantCount": 0,
    "variantAsins": [],
    "variantLabels": [],
    "variations": [],
    "badge": null,
    "prime": true,
    "sponsored": true,
    "salesVolume": null,
    "deliveryMessage": "FREE delivery Fri, Aug 21",
    "secondaryOffer": null,
    "offerCount": null,
    "productDetails": [],
    "series": null,
    "keyword": "laptop",
    "domainCode": "com",
    "searchResultPosition": 14,
    "page": 2,
    "currentPage": 2,
    "maxPagesAvailable": 20,
    "resultCount": 100000,
    "sortStrategy": "relevanceblender",
    "selectedCategory": "aps",
    "browseNode": null,
    "searchRefinements": ["Intel Core i7", "16 GB", "Windows 11"],
    "similarKeywords": [{ "keyword": "gaming laptop", "url": "https://www.amazon.com/s?k=gaming+laptop" }],
    "dpUrl": "https://www.amazon.com/Lenovo-IdeaPad-Slim-Laptop/dp/B0CQZX9KLT",
    "imgUrl": "https://m.media-amazon.com/images/I/61xyz456.jpg",
    "detailStatus": "skipped",
    "statusCode": 200,
    "statusMessage": "FOUND",
    "scrapedAt": "2026-08-15T09:12:11Z"
  },
  {
    "type": "product",
    "isChild": false,
    "asin": "B0DFJH2K9M",
    "productDescription": "Sony WH-1000XM6 Wireless Noise Cancelling Headphones",
    "brand": null,
    "manufacturer": "Sony",
    "price": 329.0,
    "currency": "GBP",
    "retailPrice": 379.0,
    "listPriceLabel": "Was",
    "productRating": "4.7 out of 5 stars",
    "countReview": 1893,
    "detailReviewCount": null,
    "availability": null,
    "soldBy": null,
    "shipsFrom": null,
    "couponText": null,
    "bestsellerRanks": [],
    "categoryPath": [],
    "categories": [],
    "nodeHierarchy": null,
    "variantCount": 0,
    "variantAsins": [],
    "variantLabels": [],
    "variations": [],
    "badge": "Best Seller",
    "prime": true,
    "sponsored": false,
    "salesVolume": "1K+ bought in past month",
    "deliveryMessage": "FREE delivery tomorrow",
    "secondaryOffer": null,
    "offerCount": null,
    "productDetails": [],
    "series": null,
    "keyword": "wireless headphones",
    "domainCode": "co.uk",
    "searchResultPosition": 3,
    "page": 1,
    "currentPage": 1,
    "maxPagesAvailable": 20,
    "resultCount": 30000,
    "sortStrategy": "relevanceblender",
    "selectedCategory": "aps",
    "browseNode": null,
    "searchRefinements": ["Wireless", "Over-Ear", "Noise Cancelling"],
    "similarKeywords": [],
    "dpUrl": "https://www.amazon.co.uk/Sony-WH-1000XM6-Wireless-Cancelling-Headphones/dp/B0DFJH2K9M",
    "imgUrl": "https://m.media-amazon.com/images/I/61def789.jpg",
    "detailStatus": "unavailable",
    "statusCode": 200,
    "statusMessage": "FOUND",
    "scrapedAt": "2026-08-15T09:12:47Z"
  }
]
```

#### Output field notes

- `statusCode` / `statusMessage` are `200` / `"FOUND"` on every product row — only the zero-result `notice` row (below) uses a different value.
- `categories` duplicates `categoryPath` once the detail pass fills it in; it stays `[]` until then. `nodeHierarchy` is the same path joined with `" > "`.
- `page` and `currentPage` both hold the same search-result page number.
- `detailStatus` is `"enriched"` (detail page read successfully), `"skipped"` (the row was outside `maxDetailFetches`, or the pass is off), or `"unavailable"` (the detail page was attempted but could not be fetched or parsed).
- `browseNode` and `selectedCategory` reflect the marketplace category filter, when your search URL carried one (`selectedCategory` defaults to `"aps"` — Amazon's own "all departments" code — when none is set).

If a run's search terms find no products at all, one extra row is pushed instead of an empty dataset:

```json
{
  "type": "notice",
  "isChild": false,
  "statusCode": 204,
  "statusMessage": "NO_RESULTS",
  "keyword": "laptop, wireless headphones",
  "scrapedAt": "2026-08-15T09:10:00Z"
}
```

### 💼 How can I use the data extracted with Amazon Search Scraper With Product Detail Pages?

- 🛒 **Amazon sellers and brand managers:** track competitor pricing, coupon activity and best-seller rank for every listing in a category using `price`, `couponText` and `bestsellerRanks`, and see whether a rival is even sold and shipped by Amazon (`soldBy`, `shipsFrom`) or by a third party.
- 🤖 **AI engineers and LLM developers:** wire the Actor into a shopping or research agent — a query goes in, structured product JSON comes back as grounding context for the model's answer.
- 📊 **Market researchers:** roll up brand share and price positioning across a keyword using `manufacturer`, `brand` and `categoryPath`, and compare result composition across the six `resultOrder` values.
- 🧩 **Sourcing and product teams:** use `variantAsins` / `variantCount` to size up how many configurations a competing product family covers, and `bestsellerRanks` to spot under-served sub-categories.

### 📈 How do you monitor Amazon product data over time?

Amazon listings change constantly — prices move, coupons appear and disappear, best-seller rank shifts daily, and stock status flips. A single run is a snapshot; monitoring means re-running the same `searchTerms` on a schedule and diffing the fields that matter between runs, keyed on `asin`. Watch `price` and `couponText` for pricing and promotion changes, `bestsellerRanks[].rank` for a product's category ranking, `availability` for stock-outs, and `variantCount` / `variantAsins` for a product family gaining or losing configurations. A typical workflow: schedule a run across a fixed set of keywords or ASIN-bearing search URLs, store each run's dataset, then compare the previous run's row for the same `asin` against the latest one and alert on the delta that matters — a rank that jumped, a coupon that vanished, a variant that went out of stock. This Actor has no built-in scheduler or diffing; use an [Apify Schedule](https://docs.apify.com/platform/schedules) to trigger the recurring runs, and compare consecutive dataset exports through the API or a downstream script.

### 🔌 Integrate Amazon Search Scraper With Product Detail Pages and automate your workflow

Amazon Search Scraper With Product Detail Pages works with any language or tool that can send an HTTP request.

#### REST API with Python

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")

run = client.actor("scrapier/amazon-search-scraper-with-product-detail-pages").call(
    run_input={
        "searchTerms": ["laptop", "wireless headphones"],
        "productLimit": 10,
        "enrichFromProductPage": True,
        "maxDetailFetches": 20,
    }
)

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    if item.get("type") == "product":
        print(item["asin"], item["price"], item.get("bestsellerRanks"))
```

#### Scheduled monitoring and delivery

Set up an [Apify Schedule](https://docs.apify.com/platform/schedules) to re-run the Actor against the same keywords or search URLs on a cadence, and attach an [Apify webhook](https://docs.apify.com/platform/integrations/webhooks) on the run's success event to push each run's dataset to your own endpoint automatically. There is no MCP server or built-in push-notification feature beyond that — polling the dataset via the API or subscribing a webhook are the two supported delivery paths.

### ⚖️ Is it legal to scrape Amazon search results?

Yes. Amazon search-result pages and product pages are publicly accessible to any visitor without logging in, and this Actor returns only what a visitor already sees — product titles, prices, ratings, category placement and seller attribution. Because the entity here is product and business/catalogue data rather than data about private individuals, GDPR's personal-data framework generally does not attach to it; the operative constraints are Amazon's own Conditions of Use, which place restrictions on automated data collection, and — in the EU — database-rights law around bulk extraction of another party's compiled data. Scraping for a one-off research pull and scraping for continuous, large-scale storage or resale carry different risk profiles. Consult your legal team for commercial use cases involving bulk data storage.

### ❓ Frequently asked questions

#### Which Amazon marketplaces does this Actor support?

Seven: `amazon.com`, `amazon.co.uk`, `amazon.de`, `amazon.fr`, `amazon.it`, `amazon.es` and `amazon.ca`. Plain keywords always search `amazon.com`; paste a full search URL on one of the other domains to search that marketplace instead, and prices, availability and badges come back in that marketplace's own locale.

#### How do I change the result order?

Set `resultOrder` to one of the six tokens Amazon's own result-order selector offers: `relevanceblender` (Featured), `price-asc-rank`, `price-desc-rank`, `review-rank`, `date-desc-rank` (Newest arrivals), or `exact-aware-popularity-rank` (Best sellers). The legacy `sortBy` field only accepts `relevanceblender` or `recent`.

#### How does this Actor handle Amazon's anti-bot measures?

Requests impersonate a real Chrome TLS fingerprint and run through Apify Proxy (residential by default), with a warm-up homepage request per marketplace before the first search or detail page. If Amazon serves an edge-verification interstitial, the Actor detects it and automatically follows the verification redirect rather than treating it as a failure. Search-page and detail-page fetches both retry on failure or a detected challenge page, backing off with a randomized delay and re-warming the connection before trying again; there are also randomized pauses between detail-page fetches, between search pages, and between keywords to avoid hammering the site.

#### Does this Actor extract brand, best-seller rank and variant data?

Yes — turn on `enrichFromProductPage` (on by default) and every product within the `maxDetailFetches` budget gets `brand`, `bestsellerRanks`, `categoryPath` / `nodeHierarchy`, and the real variant map (`variantAsins`, `variantLabels`, `variantCount`, `variations`) read straight from its own product page. Products beyond the budget, or when the pass is off, keep these fields empty and are marked `detailStatus: "skipped"`.

#### How many results does this Actor return per search term?

Up to `productLimit` (1–10,000, prefill 5) per search term — but two real ceilings sit under that number. First, the Actor stops paging for a keyword after 20 search-result pages, regardless of how many pages Amazon itself reports being available. Second, it stops early for that keyword if two consecutive pages return no new (non-duplicate) products. Whichever limit is hit first ends that keyword's collection.

#### How do I monitor Amazon product rank and pricing over time?

Re-run the Actor against the same `searchTerms` on a schedule and diff `price`, `couponText`, `bestsellerRanks[].rank` and `availability` between runs for the same `asin`. See "How do you monitor Amazon product data over time?" above for the full workflow.

#### Does this Actor work with Claude, ChatGPT, and AI agent frameworks?

It is callable as an HTTP endpoint via the Apify API from any agent framework that can issue a request and parse JSON, which supports building a grounded shopping-research agent. There is no MCP server documented for this Actor.

#### How does this Actor compare to other Amazon search scrapers?

No competitor Actors were reviewed for this README — check the Apify Store directly for how other Amazon search scrapers document their result types, query controls and output schema before comparing.

#### Can I use this Actor without managing proxies or an Amazon account?

Yes. No Amazon login is required, and Apify Proxy (residential, prefilled) handles the connection by default, automatically pinned to the country of your first search term's marketplace. You only need an Apify account to run it; if you want to supply your own proxy or disable proxying, set `proxyConfiguration` explicitly.

### 💬 Your feedback

Found a bug, or an Amazon field that isn't being captured correctly? Let Scrapier know through the **Issues** tab on this Actor's Apify Store page, or via the developer contact link on the listing. Amazon changes its markup regularly, and field reports are what keep an HTML-scraping Actor like this one working.

# Actor input Schema

## `searchTerms` (type: `array`):

Add one or more entries; each one runs as its own search.

Examples:
• `laptop`
• `wireless headphones`
• `https://www.amazon.com/s?k=gaming+chair`
• `https://www.amazon.co.uk/s?k=running+shoes`

Plain keywords use amazon.com. Paste a country search URL to use that marketplace instead (com, co.uk, de, fr, it, es, ca).

## `productLimit` (type: `integer`):

Maximum products to collect **for each** search term. Example: 2 search terms with a limit of 5 returns up to 10 rows in total. Default is 5.

If you send the legacy `maxResults` key instead, it is used as this per-search-term limit.

## `resultOrder` (type: `string`):

The order Amazon applies to the results before they are collected. These are the six orders Amazon itself offers on the results page.

## `enrichFromProductPage` (type: `boolean`):

When on, every collected product is also read from its own product page so the row gains brand, best seller ranks, category path, availability, sold by, ships from, coupon text, the authoritative review count, feature bullets and the variant map. When off, only search-result fields are returned and those columns stay empty. Default is on.

## `maxDetailFetches` (type: `integer`):

How many products in this run may be enriched from their own page. The budget is spent in collection order and shared across all search terms; products beyond it keep their search-result fields and are marked `skipped` in the `detailStatus` column. Set 0 to disable the pass entirely. Default is 10.

## `detailFields` (type: `array`):

Pick which detail-page field groups to fill. Leaving every option selected is the default.

## `urls` (type: `array`):

Accepted for backward compatibility. Used only when 🔍 Search terms is empty.

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

Accepted for backward compatibility. Used only when 📦 Products per search term is empty. Note that it now applies per search term, so every term you enter is actually searched.

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

Accepted for backward compatibility. Used only when ↕️ Result order is empty. The old `recent` value now maps onto Amazon's real newest-arrivals order instead of quietly returning featured results.

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

Leave this as prefilled unless you have a reason to change it. The prefilled option is the one that returns complete result pages.

## Actor input object example

```json
{
  "searchTerms": [
    "laptop",
    "wireless headphones"
  ],
  "productLimit": 5,
  "resultOrder": "relevanceblender",
  "enrichFromProductPage": true,
  "maxDetailFetches": 10,
  "detailFields": [
    "brand",
    "rank",
    "categoryPath",
    "variants",
    "availability",
    "seller",
    "coupon",
    "reviews",
    "features"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

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

All scraped items in the Actor's default dataset.

## `output` (type: `string`):

The same collected product rows as a single JSON array, written once to the key-value store under the key OUTPUT.

# 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 = {
    "searchTerms": [
        "laptop",
        "wireless headphones"
    ],
    "productLimit": 5,
    "resultOrder": "relevanceblender",
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapier/amazon-search-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 = {
    "searchTerms": [
        "laptop",
        "wireless headphones",
    ],
    "productLimit": 5,
    "resultOrder": "relevanceblender",
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("scrapier/amazon-search-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 '{
  "searchTerms": [
    "laptop",
    "wireless headphones"
  ],
  "productLimit": 5,
  "resultOrder": "relevanceblender",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call scrapier/amazon-search-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,scrapier/amazon-search-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/ZXcYgsIbGuOtWKRwz/builds/4zLGLDsGH6F5K6dxw/openapi.json