# Amazon Listings Scraper 2026 (`devcake/amazon-listings-scraper`) Actor

Amazon product data scraper for keyword search. Get ASIN, title, price, currency, rating, Prime and badge per result.

- **URL**: https://apify.com/devcake/amazon-listings-scraper.md
- **Developed by:** [devcake](https://apify.com/devcake) (community)
- **Categories:** E-commerce
- **Features:** Limited permissions
- **Stats:** 10 total users, 2 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.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.
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 · Amazon Listings Scraper

> **Extract Amazon products and listings by keyword across 12 marketplaces.** Fast, accurate, and ready to run — no setup needed.

***

### ✨ At a glance

| | |
|---|---|
| 🌍 **Marketplaces** | 11 — US, UK, DE, IT, ES, CA, MX, BR, IN, JP, AU |
| ⚡ **Speed** | Search results in seconds; a fully enriched run takes a couple of minutes per keyword |
| 📦 **Output** | One clean row per Amazon product — ASIN, price, rating, reviews, Prime, sponsored flag, and more |
| 🔬 **Enrichment** | Optional detail-page pass (`enrichDetails: true`) adds specs, feature bullets, hi-res gallery, variations, best-sellers rank, seller and more — 54 extra fields |
| 🚀 **Scale** | Up to 10,000 unique products per keyword, 1,000 keywords per run |

***

### 📑 Table of contents

- [🛒 What does it do?](#-what-does-amazon-product-scraper-do)
- [👥 Who it's for](#-who-its-for)
- [💡 Use cases](#-use-cases)
- [🚀 How to use it](#-how-to-use-amazon-product-scraper)
- [⚙️ Input](#-input)
- [🔬 Enrichment](#-enrichment--what-the-detail-page-adds)
- [🔬 Enrichment](#-enrichment--what-the-detail-page-adds)
- [📦 Output](#-output)
- [📊 Data table](#-data-table)
- [💡 Tips](#-tips)
- [❓ FAQ, disclaimers, and support](#-faq-disclaimers-and-support)

***

### 🛒 What does Amazon Product Scraper do?

This **Amazon listings scraper** pulls **product listings from Amazon search pages** for one or more keywords across all 12 major Amazon marketplaces. For each keyword it goes through Amazon's search pages and returns one row per product — a clean **Amazon product dataset** with ASIN, title, price, rating, review count, Prime badge, sponsored flag, thumbnail, brand, and 20+ more fields.

Optionally it goes one level deeper — flip `enrichDetails` on and for every product it also reads the **product detail page** and merges the full catalogue record into the same row — feature bullets, the specification tables, the product description, the hi-res image gallery, the colour variants and their sibling ASINs, best-sellers rank, delivery promise, seller, coupons and whether the listing has A+ content. That turns a 31-field search dataset into an 85-field product database.

It's built to bypass Amazon's bot detection automatically, so you don't have to wrestle with proxies, captchas, or browser setup. Just paste your keywords, hit start, and get your data.

Try it with three sample keywords (`"wireless earbuds"`, `"bluetooth headphones"`, `"noise cancelling earbuds"`) in the **Input** tab — you'll see a clean Amazon product dataset within a minute.

***

### 👥 Who it's for

> Built for anyone who works with Amazon listings and product data.

- 🛒 **Amazon FBA sellers** — track your ASIN's organic position, watch competitor pricing, and spot listing-rank changes week over week.
- 🏪 **E-commerce resellers & dropshippers** — find winning products, compare supplier pricing, and monitor availability across marketplaces.
- 📊 **Market & product researchers** — generate bulk product datasets for trend analysis, category sizing, and assortment comparison.
- 💼 **Procurement & sourcing teams** — discover candidate products, evaluate review velocity, and shortlist private-label opportunities.
- 📈 **Price monitoring services** — batch thousands of keywords into one run and feed structured price + discount data into your tracking pipeline.
- 🎯 **Amazon agencies & consultants** — produce client-ready reports on keyword ranking, sponsored share, and competitor moves.

***

### 💡 Use cases

> Seven battle-tested workflows for sellers, analysts, and operators.

#### 📦 Scrape Amazon listings at scale

Pull hundreds of product cards per keyword and up to 10,000 unique ASINs per keyword in a single run.

#### 🔎 Bulk product discovery

Build seed product lists for catalog enrichment, review scraping, variant extraction, or supplier sourcing.

#### 🏷️ Keyword research for Amazon listings

See exactly which products rank for your target keyword, their pricing tiers, and review velocity.

#### 🆚 Competitor analysis

Track competing ASINs across price, rating, review count, and "bought in past month" signals.

#### 💹 Price monitoring at scale

Batch hundreds of keywords into one run and pull structured prices and discount percentages in a single dataset.

#### 🌐 Multi-marketplace expansion

Compare product assortments, pricing, and ratings across Amazon.com, Amazon.de, Amazon.co.jp, and 9 more storefronts.

#### 🎯 Sponsored vs. organic analysis

`isSponsored` and `organicRank` fields let you separate paid placements from real organic winners.

***

### 🚀 How to use Amazon Product Scraper

> Five steps from input to downloadable dataset.

1. **📝 Open the Input tab** and paste one or more keywords into the **Search keywords** field (1–1,000 keywords per run).
2. **🌍 Pick an Amazon domain** — `amazon.com` (US) is the default. Switch to `co.uk`, `de`, `jp`, etc. for other storefronts.
3. **🎯 Set Maximum products per keyword** (default 100) — the scraper stops each keyword once that many unique products are collected.
4. **▶️ Click Start** and wait. A 100-product run finishes in under a minute.
5. **⬇️ Download results** from the **Output** tab — CSV, JSON, Excel, or HTML. Use the **Products** table for a quick scan, **Full data** for everything.

> 🤖 **Want to automate it?** Use the **API** tab to trigger runs from your own scripts, or schedule hourly/daily keyword-tracking jobs from the **Schedules** tab.

***

### ⚙️ Input

> Four fields, that's all. Everything else is handled for you.

| Parameter | Type | Required | Default | Description |
|---|---|---|---|---|
| 📝 `keywords` | array of strings | ✅ **Yes** | — | One or more keywords to search on Amazon (1–1,000 per run). |
| 🌍 `domain` | enum | ❌ No | `com` | Which Amazon storefront: `com`, `co.uk`, `de`, `fr`, `it`, `es`, `ca`, `com.mx`, `com.br`, `in`, `jp`, `com.au`. |
| 🎯 `maxResults` | integer | ❌ No | `50` | Stop each keyword once this many unique products (by ASIN) are collected. |
| 🔬 `enrichDetails` | boolean | ❌ No | `false` | Fetch every product's **detail page** and merge the full catalogue record into the row. Every product a keyword returns is enriched. |

> 💡 **The Amazon region is auto-selected from `domain`.** amazon.com → US · amazon.de → DE · amazon.co.jp → JP, and so on — so you always get a real local view of that storefront.

#### 📝 Example input

```json
{
  "keywords": ["wireless earbuds", "bluetooth headphones", "noise cancelling earbuds"],
  "domain": "com",
  "maxResults": 100,
  "enrichDetails": false
}
```

***

### 🔬 Enrichment — what the detail page adds

> Off by default. The search page only renders a teaser card — the **product detail page** carries the whole catalogue record, and the scraper merges it into the same row.

| From the detail page | Fields |
|---|---|
| **Copy** | `description`, `features` (the "About this item" bullets), `savingsText` |
| **Specifications** | `specifications`, `productDetails`, `productOverview`, `additionalDetails` — flat key/value maps with Brand Name, Item Weight, Material Type, Color, Dimensions, Model Number, Manufacturer Part Number, UPC, Date First Available, … |
| **Ranking** | `bestSellersRank` (`[{rank, category}]`), `bestSellersRankText` |
| **Media** | `images` / `imagesHiRes` (full gallery at 1500 px), `mainImage`, `mainImageHiRes`, `videos` |
| **Variations** | `variations` (`{color_name: [...], size_name: [...]}`), `variationAsins` (every sibling ASIN in the variation graph) |
| **Commerce** | `sellerText`, `amazonsChoice`, `whatsInTheBox`, `warranty`, `sizeGuide`, `brandInsights`, `hasAplus` |
| **Category hierarchy** | `category`, `categorySymbol`, `glProductGroup`, `categoryId`, `subCategoryId`, `productType` |
| **Image data** | the hi-res image set, `imageVariants`, `leadColor`, `dominantColors` |

> 🛡️ **Your search-page snapshot is never overwritten.** `price`, `rating` and `reviewCount` keep the value Amazon showed on the search page; the detail-page values are added as `pdpPrice`, `pdpRating`, `pdpReviewCount`, `pdpListPrice` and `pdpDiscountPercent`. That way you can always compare "as listed in search" vs "as detailed on the product page".

***

### 📦 Output

> Every product is pushed as one row to the default dataset. Fields follow the **Apify Amazon-search market standard** — they line up with the leading Amazon scrapers on the platform, so existing pipelines keep working. With `enrichDetails: true` the extra columns are added on top.

#### 📄 Example row

> A fully enriched row — with `enrichDetails: true`.

```json
{
  "asin": "B0BSHF7WHW",
  "title": "Apple AirPods Pro (2nd Gen)",
  "url": "https://www.amazon.com/dp/B0BSHF7WHW",
  "thumbnail": "https://m.media-amazon.com/images/I/71zny78BxWL._AC_UX200_.jpg",
  "price": 199.99,
  "priceText": "$199.99",
  "listPrice": 249.0,
  "listPriceText": "$249.00",
  "discountPercent": 20,
  "currency": "USD",
  "rating": 4.6,
  "ratingText": "4.6 out of 5 stars",
  "reviewCount": 89412,
  "reviewCountText": "89,412",
  "isPrime": true,
  "isSponsored": false,
  "badgeText": "Amazon's Choice",
  "boughtInPastMonth": "10K+ bought in past month",
  "boughtInPastMonthValue": 10000,
  "deliveryText": "Get it by Tomorrow, July 26",
  "couponText": null,
  "availabilityText": "In Stock",
  "brand": "Apple",
  "marketplace": "com",
  "searchQuery": "wireless earbuds",
  "searchUrl": "https://www.amazon.com/s?k=wireless+earbuds&page=1",
  "sourceType": "keyword",
  "page": 1,
  "positionOnPage": 3,
  "organicRank": 2,
  "globalPosition": 3,
  "scrapedAt": "2026-07-25T10:30:00.000Z",
  "enriched": true,
  "pdpPrice": 199.99,
  "pdpRating": 4.6,
  "pdpReviewCount": 89412,
  "pdpListPrice": 249.0,
  "pdpDiscountPercent": 20,
  "amazonsChoice": true,
  "description": "AirPods Pro (2nd generation) with Active Noise Cancellation...",
  "features": [
    "Active Noise Cancellation",
    "Personalized Spatial Audio with dynamic head tracking"
  ],
  "specifications": {
    "Brand Name": "Apple",
    "Item Weight": "0.19 pounds",
    "Model Number": "MTJV3AM/A",
    "Manufacturer Part Number": "MTJV3AM/A",
    "Best Sellers Rank": "#1 in Headphones & Earbuds"
  },
  "bestSellersRank": [
    { "rank": 1, "category": "Headphones & Earbuds" }
  ],
  "mainImageHiRes": "https://m.media-amazon.com/images/I/71zny78BxWL._SL1500_.jpg",
  "imagesHiRes": [
    "https://m.media-amazon.com/images/I/71zny78BxWL._SL1500_.jpg"
  ],
  "variations": { "color_name": ["White", "Black"] },
  "variationAsins": { "0:0": "B0BSHF7WHW", "0:1": "B0CHXH2QZK" },
  "category": "Premium Consumer Electronics Brands",
  "productType": "HEADPHONES",
  "hasAplus": true
}
```

> ⬇️ **You can download the dataset in JSON, CSV, Excel, or HTML** from the Output tab. For large runs, use the **API** tab to fetch paginated items programmatically.

***

### 📊 Data table

> Every field the scraper emits, grouped by purpose so you can scan what you need.

#### 🆔 Identity

| Field | Type | Description |
|---|---|---|
| `asin` | string | Amazon Standard Identification Number (10 alphanumeric chars). **Unique key.** |
| `title` | string | Product title as displayed in the search result card. |
| `url` | string | Canonical Amazon product URL (`/dp/<ASIN>`). |
| `thumbnail` | string | Product thumbnail image URL. |
| `brand` | string | Brand name — from the card, or back-filled from the detail page. |
| `marketplace` | string | Amazon domain code (`com`, `co.uk`, `de`, `jp`, …). |
| `category` | string | Amazon's marketplace display group from the product API — e.g. `"Kitchen"`, `"Premium Consumer Electronics Brands"`, `"CE"`. |
| `categorySymbol` | string | Machine-readable symbol of the display group, e.g. `"kitchen_display_on_website"`. |
| `glProductGroup` | string | The global product group — the top of the hierarchy, e.g. `"gl_kitchen"`. |
| `categoryId` | string | Amazon browse-node id of the category, e.g. `"7907500"`. |
| `subCategoryId` | string | Amazon browse-node id of the sub-category, e.g. `"7907512"`. |
| `productType` | string | Amazon's internal product type (`HEADPHONES`, `BOTTLE`, …). |

#### 💰 Price

| Field | Type | Description |
|---|---|---|
| `price` | number | Numeric current price in `currency`. Raw locale string preserved as `priceText`. |
| `listPrice` | number | Strike-through "was" price. Empty when Amazon doesn't show a discount. |
| `discountPercent` | number | Calculated as `round((1 - price / listPrice) × 100)`. Empty if either is missing. |
| `currency` | string | Currency code (USD, GBP, EUR, JPY, INR, …). |
| `couponText` | string | Visible coupon / savings text. Empty when no coupon is shown. |
| `pdpPrice` | number | Price read from the detail page. `price` keeps the search-page value. |
| `pdpListPrice` | number | List price read from the detail page. |
| `pdpDiscountPercent` | number | Discount computed from the detail-page prices. |
| `savingsText` | string | Amazon's savings line on the detail page ("Save $20"). |

#### ⭐ Reviews & rating

| Field | Type | Description |
|---|---|---|
| `rating` | number | Numeric rating 0.0–5.0. Raw text preserved as `ratingText`. |
| `reviewCount` | integer | Parsed integer review count. Raw text preserved as `reviewCountText`. |
| `boughtInPastMonthValue` | integer | Parsed threshold from "10K+ bought in past month" → 10000. Empty when absent. |
| `pdpRating` | number | Rating read from the detail page. |
| `pdpReviewCount` | integer | Review count read from the detail page. |
| `amazonsChoice` | boolean | Whether the product carries the "Amazon's Choice" badge. |

#### 🏷️ Listing signals

| Field | Type | Description |
|---|---|---|
| `isPrime` | boolean | Whether the listing shows the Prime badge. |
| `isSponsored` | boolean | Whether the card is a sponsored (paid) placement. |
| `badgeText` | string | SERP badge label (e.g. "Best Seller", "Amazon's Choice", "Climate Pledge Friendly"). |
| `deliveryText` | string | Delivery promise string ("Get it by Tomorrow, July 26"). |
| `availabilityText` | string | Stock / availability string ("In Stock", "Only 3 left", …). |
| `sellerText` | string | Who sells the product / where it ships from. |
| `hasAplus` | boolean | Whether the listing has A+ (enhanced brand) content. |

#### 🖼️ Media

| Field | Type | Description |
|---|---|---|
| `thumbnail` | string | Search-card thumbnail. |
| `mainImage` | string | Main product image. |
| `mainImageHiRes` | string | Main product image at the full 1500 px resolution. |
| `images` | array | Full image gallery from the detail page. |
| `imagesHiRes` | array | Full image gallery at 1500 px. |
| `imageVariants` | array | Variant label per gallery image (`MAIN`, `PT01`, …). |
| `videos` | array | Product video links. |
| `leadColor` | string | Dominant colour of the main image (hex). |
| `dominantColors` | array | Dominant colours of the main image (hex). |

#### 📋 Product details

| Field | Type | Description |
|---|---|---|
| `features` | array | The "About this item" bullets. |
| `description` | string | Long-form product description. |
| `specifications` | object | Every spec table merged into one key/value map. |
| `productDetails` | object | The "Product details" table (Best Sellers Rank, Item Type Name, Model Number, …). |
| `productOverview` | object | The "Product overview" table. |
| `additionalDetails` | object | Style / materials & care / user guide / warranty rows. |
| `itemTypeName` | string | Amazon's item type ("Bottle", "Headphones", …). |
| `modelNumber` | string | Model number. |
| `modelName` | string | Model name. |
| `manufacturerPartNumber` | string | Manufacturer part number (MPN). |
| `manufacturer` | string | Manufacturer name. |
| `countryOfOrigin` | string | Country the product is made in. |
| `upc` | string | UPC / EAN barcode. |
| `itemWeight` | string | Item weight as stated by the seller. |
| `dateFirstAvailable` | string | Date the product was first listed. |
| `bestSellersRank` | array | Parsed category ranks: `[{rank, category}]`. |
| `bestSellersRankText` | string | Raw best-sellers-rank line. |
| `variations` | object | Option values per dimension (`{color_name: [...]}`). |
| `variationAsins` | object | Sibling ASINs of the variation graph. |
| `whatsInTheBox` | string | What's in the box. |
| `warranty` | string | Warranty information. |
| `sizeGuide` | string | Size guide. |
| `brandInsights` | string | Brand insights block. |
| `brandStoreUrl` | string | Link to the brand's Amazon store. |

#### 🔍 Provenance & ranking

| Field | Type | Description |
|---|---|---|
| `searchQuery` | string | The keyword that produced this row. |
| `searchUrl` | string | The exact Amazon SERP URL the row was scraped from. |
| `sourceType` | string | How the row was sourced. Always `"keyword"` for this scraper. |
| `page` | integer | Result page number (1-based). |
| `positionOnPage` | integer | 1-based position on this page, counting sponsored + organic. |
| `organicRank` | integer | Position among organic (non-sponsored) ASINs across all pages. Empty for sponsored cards. |
| `globalPosition` | integer | 1-based position across all unique ASINs for this keyword across all pages. |
| `scrapedAt` | string | ISO 8601 UTC timestamp of when the keyword was scraped. |
| `enriched` | boolean | Whether the detail page was fetched for this row. |

***

### 💡 Tips

> Workflow patterns from production users.

- 🔬 **Turn the deep data on.** Set `enrichDetails: true` to get the specification tables, feature bullets, hi-res gallery, variations and the category hierarchy on every row.

- 📦 **Batch your keywords.** One run with 50 keywords is much faster than 50 separate runs — and you get all the results in a single dataset.

- 🎯 **Track a specific ASIN.** Even though the input is keywords, you can pull a single product's current search-page context by searching its exact brand + model — `globalPosition` makes it easy to see ranking drift over time.

- 💸 **Use `discountPercent` for deal hunting.** A keyword where most top results show `discountPercent >= 30` is a competitive, high-velocity niche — useful for sourcing or private-label research.

- 🎯 **Separate organic vs. paid winners.** Filter the dataset on `isSponsored=false` to see real organic ranking for a keyword, then sort by `organicRank` to identify the top organic winners vs. paid placements.

- 🖼️ **Use `imagesHiRes` for catalogs.** The search card gives a 200 px thumbnail; the enriched rows give the full gallery at 1500 px plus the dominant colour of the main image.

- 🔀 **Compare `price` vs `pdpPrice`.** A gap means the search card and the detail page disagree — a useful signal that the listing is being repriced, or that a coupon/deal is active on the product page.

- 🌐 **Compare marketplaces.** Run the same keyword against `domain=com` and `domain=de` to see how pricing, assortment, and review counts differ.

- ⏰ **Schedule hourly tracking.** Combine with the **Schedules** tab to monitor a fixed keyword list daily — each row carries `scrapedAt`, so you can chart ranking and price drift over time.

***

### ❓ FAQ, disclaimers, and support

> Tap a question to read the answer.

#### ⚖️ Is this legal?

Scraping publicly visible Amazon search results is a common, lawful practice used by sellers, analysts, and researchers. **You are responsible for complying with Amazon's Terms of Service and any applicable laws in your jurisdiction.** Don't republish raw Amazon content at scale; use the data for analysis, internal tools, and product research.

#### 🌍 Which Amazon marketplaces are supported?

> All 11 — the region auto-matches the domain.

`amazon.com` (US) · `amazon.co.uk` (UK) · `amazon.de` (DE) · `amazon.it` (IT) · `amazon.es` (ES) · `amazon.ca` (CA) · `amazon.com.mx` (MX) · `amazon.com.br` (BR) · `amazon.in` (IN) · `amazon.co.jp` (JP) · `amazon.com.au` (AU)

#### 🎯 What's the difference between `positionOnPage`, `organicRank`, and `globalPosition`?

| Field | Meaning |
|---|---|
| `positionOnPage` | 1-based position on this specific search results page, counting sponsored + organic. |
| `organicRank` | Position among non-sponsored ASINs across all paginated rows. Empty for sponsored cards. |
| `globalPosition` | 1-based position across all unique ASINs across all pages for this keyword. |

#### 🔁 Why do I see duplicate ASINs in the raw output?

You shouldn't — the scraper de-duplicates by ASIN across all pages for a given keyword. If you see duplicates, you've likely joined two keywords' datasets downstream; **`searchQuery` is the join key.** A summary record reports the within-keyword duplicates the scraper filtered out.

#### 🚫 Can I get more than 10,000 products per keyword?

No — `maxResults` is capped at 10,000. For bulk catalog scraping (millions of ASINs per category), use a dedicated category-browser scraper instead.

#### 🧩 What's the `keyword` legacy field?

It's an alias for `searchQuery`. The scraper emits both for backward compatibility with older pipelines; **new code should use `searchQuery`**.

#### 🔬 Does enrichment change the search-page numbers?

No. `price`, `rating` and `reviewCount` always hold what Amazon showed on the search page, so existing pipelines keep their current semantics. The detail-page values live in the `pdp*` columns (`pdpPrice`, `pdpRating`, `pdpReviewCount`, `pdpListPrice`, `pdpDiscountPercent`).

#### 🌍 Are the fields localized?

They are read from the storefront of the marketplace you scrape, so the values are in that marketplace's language — the spec table on amazon.de calls the brand "Marke", on amazon.it "Marca" and on amazon.co.jp "ブランド名", and the scraper resolves all of them to the same `brand` field. The Best Sellers Rank is parsed out of every local convention: `#12 in Sports`, `Nr. 12 in Elektronik`, `nº2 en Auriculares` and `家電＆カメラ - 327位` all become `[{rank, category}]`.

Fields that Amazon only shows for part of the catalogue — `dateFirstAvailable`, `itemTypeName`, `warranty`, the Q\&A count — are empty for the products that do not carry them, and `specifications` always holds every row the page had, in the original language.

#### 💬 Custom solutions or integration help?

> 📬 Open an issue on the [Apify console Issues tab](https://console.apify.com) for this scraper, or contact Apify support through the platform. The scraper is actively maintained and field-aligned with the leading Amazon search scrapers on the marketplace.

# Actor input Schema

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

One or more keywords to search on Amazon. URL-encoded automatically. Each keyword is scraped independently up to maxResults; all rows flow into the same dataset and carry the originating keyword in the `keyword` field.

## `domain` (type: `string`):

Which Amazon storefront to scrape. Determines the URL host, the proxy country, and the locale-specific price formatting.

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

Stop each keyword once this many unique products have been collected. De-duplicated by ASIN. The billable unit is the total number of dataset rows pushed across all keywords.

## `enrichDetails` (type: `boolean`):

Fetch each product's detail page and merge the full catalogue record into the row: feature bullets, specification tables, description, image gallery (incl. hi-res), variations and sibling ASINs, best-sellers rank, delivery promise, seller, coupons, brand, model numbers and A+ content. Every product the keyword search returns is enriched. Off by default: a search-only run is much lighter. Amazon's product API is always queried either way, so the hi-res image set, the colour palette and the category hierarchy come through regardless.

## Actor input object example

```json
{
  "keywords": [
    "wireless earbuds"
  ],
  "domain": "com",
  "maxResults": 50,
  "enrichDetails": false
}
```

# Actor output Schema

## `dataset` (type: `string`):

One row per scraped product. De-duplicated by ASIN across pages.

## `summary` (type: `string`):

Counts (products, pages, duplicates, wire/decoded bytes) plus the run's stop_reason.

# 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"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("devcake/amazon-listings-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"] }

# Run the Actor and wait for it to finish
run = client.actor("devcake/amazon-listings-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"
  ]
}' |
apify call devcake/amazon-listings-scraper --silent --output-dataset

```

## MCP server setup

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