# Amazon Product Search Scraper – Prices, Ratings, ASINs (`moyadata/amazon-product-search-scraper`) Actor

Extract Amazon product search results by keyword: ASIN, title, price, rating, review count, Best Seller/Amazon's Choice labels, sponsored flag and more. No proxies, no browser, no bans -- data comes from a licensed SERP provider, from $0.0035 per product.

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

## Pricing

from $3.50 / 1,000 products

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?

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 Product Search Scraper – Prices, Ratings, ASINs, Best Sellers

Search Amazon by keyword and get structured product data back: ASIN, title, price, rating, review count, Best Seller / Amazon's Choice labels, sponsored flag, delivery info and more. This actor calls a licensed SERP data provider directly — **no proxies, no headless browser, no IP bans, no CAPTCHAs.** Results typically come back in a few seconds per query, and the same low, transparent price applies whether you scrape 20 products or 20,000.

### What data you get

Each result item includes:

- `asin` — Amazon's product identifier
- `title`, `url`, `imageUrl`
- `priceFrom`, `priceTo`, `currency`
- `rating`, `reviewsCount`
- `boughtPastMonth` — Amazon's "X+ bought in past month" badge, when shown
- `isAmazonChoice`, `isBestSeller`
- `isSponsored` — `true` for a paid/ad placement, `false` for an organic result
- `specialOffers` — coupon/Subscribe & Save/Prime-price badges, as shown on the listing
- `deliveryMessage`, `deliveryPrice`
- `labels` — Amazon's own label badges on the listing (e.g. "Audiobook"), usually empty
- `section` — `null` for a normal search result, or `editorial_recommendations` / `top_rated_from_our_brands` when the product was pulled out of one of those SERP sections (see Sections below)
- `rank`, `rankAbsolute` — position in the search results for its query (`null` for `section` products — see Sections)
- `query`, `department`, `marketplace` (the `se_domain` searched, e.g. `amazon.com`)
- `scrapedAt` (ISO 8601 UTC)

### Why this scraper

- **Fast** — results come from a real-time SERP data pipeline, typically seconds per query, not minutes of browser automation.
- **Cheap** — pay only for products actually scraped, a flat **$0.0035 per product** regardless of your Apify plan (see Pricing).
- **Up to 700 results per query** — go well past Amazon's default page of ~20-60 results.
- **12 marketplaces** — amazon.com, .co.uk, .de, .fr, .es, .it, .ca, .com.mx, .co.jp, .in, .com.br, .com.au (see Input).
- **Price and sort filters** — narrow by `priceMin`/`priceMax`/`department` and choose Amazon's sort order, all applied upstream so you never pay for products you filtered out.

### Pricing

This actor uses Apify's **pay-per-event** pricing, flat across all plans. You are charged for:

| Event | What it means | Price |
|---|---|---|
| `apify-actor-start` | Apify's platform-billed "run started" event, charged once per run automatically -- no code call needed, so a run with zero results costs almost nothing | $0.00005 |
| `apify-default-dataset-item` ("Product" in Console) | Charged once per product written to the output dataset | $0.0035 |

**Worked example:** scraping 1,000 products costs `1,000 × $0.0035 + $0.00005 ≈ $3.50`.

Apify's free plan includes monthly platform credit that, on its own, covers roughly the first **1,400 products** scraped with this actor before you'd need to add a payment method.

### Input

Minimal example:

```json
{
  "queries": ["wireless earbuds"],
  "country": "US",
  "maxResultsPerQuery": 20
}
```

| Field | Type | Default | Description |
|---|---|---|---|
| `queries` | array of strings | `["wireless earbuds"]` | One or more Amazon search keywords. Max 700 characters each, max 500 queries per run. |
| `country` | string (ISO-2) | `"US"` | Selects the Amazon marketplace, language and location: `US`, `GB`, `DE`, `FR`, `ES`, `IT`, `CA`, `MX`, `JP`, `IN`, `BR`, `AU` (see Marketplaces). |
| `maxResultsPerQuery` | integer | `20` (max 700) | Maximum number of products returned per query. |
| `department` | string | — | Restrict results to one Amazon department (e.g. `"Electronics"`). See the full list in the actor's input editor. Applied upstream, so filtered-out products are never charged. |
| `priceMin` | integer | — | Only return products priced at or above this amount, in the marketplace's currency. Applied upstream. |
| `priceMax` | integer | — | Only return products priced at or below this amount, in the marketplace's currency. Applied upstream. |
| `sortBy` | string | — (Amazon default) | One of `relevance`, `price_low_to_high`, `price_high_to_low`, `featured`, `avg_customer_review`, `newest_arrival`. Leave unset to keep Amazon's own relevance order. |
| `includeSponsored` | boolean | `false` | `true`: keep sponsored/ad products, marked `isSponsored: true`. `false`: organic results only. |
| `deduplicate` | boolean | `true` | Remove duplicate products (by `asin`) seen across multiple queries in this run. See Sponsored products below for the one edge case this affects. |

#### Marketplaces

| `country` | Marketplace | `country` | Marketplace |
|---|---|---|---|
| `US` | amazon.com | `MX` | amazon.com.mx |
| `GB` | amazon.co.uk | `JP` | amazon.co.jp |
| `DE` | amazon.de | `IN` | amazon.in |
| `FR` | amazon.fr | `BR` | amazon.com.br |
| `ES` | amazon.es | `AU` | amazon.com.au |
| `IT` | amazon.it | `CA` | amazon.ca |

### Output

One real dataset item, taken from a live run for `"wireless earbuds"` (US):

```json
{
  "asin": "B09FT58QQP",
  "title": "TOZO A1 Wireless Earbuds Bluetooth 5.3 Light Weight in Ear Headphones | IPX5 Waterproof,2 Mics for AI Calls,Immersive Premium Sound Bass Headset with Charging Case,32 EQ via App Black",
  "url": "https://www.amazon.com/A1/dp/B09FT58QQP/ref=sr_1_20?crid=GZUED5Y6FDPB&dib=eyJ2IjoiMSJ9.OA77GVVptnLWLp5wJyq85b5v2_lL8sby_HlByFfhcd1fia5lDJCk_t5xuyenvs5FdplmAStb7_P1loStFvKXBbLpj8YFndltE6yKAsfXawI6ZkTjlXpUh43Q_xbK2WSHMKPTPRG8OPqmE7VofU-0sdxuc2HnsybJVAHqX1uhobXc7nclsJ21eNj64JPS8CkUIwlDfLsaraY89k2EfF8R6Nk_tA4HamL63VptdtpTKLc.w0esO02XPKHlCEVhM0bY2yahbjHphfnqlIXE_qAYYZw&dib_tag=se&keywords=wireless+earbuds&qid=1788886578&sprefix=wireless%2Bearbuds%2Caps%2C207&sr=8-20&xpid=8IqHcdwzS3en0",
  "imageUrl": "https://m.media-amazon.com/images/I/81+4jNKVFgL._AC_UY218_.jpg",
  "priceFrom": 13.99,
  "priceTo": null,
  "currency": "USD",
  "rating": 4.3,
  "reviewsCount": 117000,
  "boughtPastMonth": 10000,
  "isAmazonChoice": false,
  "isBestSeller": true,
  "isSponsored": false,
  "specialOffers": ["Exclusive Prime price"],
  "deliveryMessage": "FREE delivery Sun, Sep 13 on $35 of items shipped by Amazon Or fastest delivery Sat, Sep 12",
  "deliveryPrice": null,
  "labels": [],
  "section": null,
  "rank": 22,
  "rankAbsolute": 32,
  "query": "wireless earbuds",
  "department": null,
  "marketplace": "amazon.com",
  "scrapedAt": "2026-09-08T16:56:30Z"
}
```

| Field | Type | Description |
|---|---|---|
| `asin` | string | null | Amazon's product identifier |
| `title` | string | null | Product title |
| `url` | string | null | Link to the product page (organic results) or the click-tracking ad link (sponsored) |
| `imageUrl` | string | null | Product image URL |
| `priceFrom` | float | null | Regular/lowest price shown |
| `priceTo` | float | null | Upper end of the price range, when Amazon shows one (e.g. multi-variant listings) |
| `currency` | string | null | ISO currency code (e.g. `USD`) |
| `rating` | float | null | Average rating (0–5), null if the product has no ratings |
| `reviewsCount` | integer | null | Total number of ratings/reviews |
| `boughtPastMonth` | integer | null | "X+ bought in past month" badge value, null if not shown |
| `isAmazonChoice` | boolean | null | "Amazon's Choice" label |
| `isBestSeller` | boolean | null | "Best Seller" label |
| `isSponsored` | boolean | `true` for a paid/ad placement, `false` for organic |
| `specialOffers` | array of strings | Coupon/Subscribe & Save/Prime-price badges, empty if none |
| `deliveryMessage` | string | null | Delivery text as shown on the listing |
| `deliveryPrice` | float | null | Delivery price, null when free delivery is shown or no price is given |
| `labels` | array of strings | Amazon's own label badges (e.g. `"Audiobook"`), usually empty |
| `section` | string | null | `null` for a normal result, or `editorial_recommendations` / `top_rated_from_our_brands` (see Sections) |
| `rank` | integer | null | Position within its result group for the query. `null` for `section` products (see Sections) |
| `rankAbsolute` | integer | null | Absolute position in the full SERP. `null` for `section` products (see Sections) |
| `query` | string | The input query that returned this product |
| `department` | string | null | The `department` input filter used for this query, if any |
| `marketplace` | string | The Amazon domain searched (`se_domain`, e.g. `amazon.com`) |
| `scrapedAt` | string | ISO 8601 UTC timestamp of when the product was scraped |

### Sponsored products

Set `includeSponsored: true` to include paid/ad placements alongside organic results, marked `isSponsored: true`. They're excluded by default.

**One edge case with `deduplicate`:** in a real Amazon SERP, the same product (same ASIN) sometimes appears twice on one page — once as a sponsored ad and once further down as an organic result. With both `includeSponsored: true` and `deduplicate: true`, only the first occurrence in the page is kept (usually the sponsored slot, since ads are placed above organic results), so that product's `isSponsored` reflects whichever copy came first — not necessarily what you'd expect if you assumed organic always wins. Set `deduplicate: false` to keep both copies instead.

### Sections

Amazon sometimes shows curated product carousels above/alongside the main results: "Editorial recommendations" and "Top rated from our brands" (Amazon private-label picks). This actor flattens the products inside those sections into normal output rows, tagged with `section: "editorial_recommendations"` or `section: "top_rated_from_our_brands"`. Amazon's own data for these products doesn't include a search-result rank (only the section itself has one), so `rank` and `rankAbsolute` are `null` for them — every other field is populated the same way as a regular result. A third section type, "Related searches" (suggested alternate keywords, no product data), is not included in the output at all.

### Limits

- **No reviews or full product-detail data in v1** — this is a search-results scraper. Fields come only from what Amazon's search page itself shows (price, rating, badges, etc.), not from visiting each product page.
- Maximum 700 results per query — this is the data provider's ceiling; most queries have far fewer results anyway, and Amazon's own SERP for a query may return fewer.
- 12 supported marketplaces (see Marketplaces above). Requesting any other `country` fails input validation.
- `department` uses Amazon's US/English department names (e.g. `"Electronics"`). Behavior when combined with a non-US `country` (e.g. `DE`) has not been verified against a live call — if in doubt, leave `department` unset and rely on `queries` and `priceMin`/`priceMax` instead.
- Results reflect Amazon at the moment the query runs; rankings, prices and badges change constantly and can differ between runs.

### FAQ

**Is this legal?**
The actor retrieves publicly available product search-results data through a licensed SERP data provider, the same category of data source used by price-tracking and market-research tools. You are responsible for how you use the extracted data under your local regulations.

**Why is this cheaper than other Amazon scrapers on Apify?**
Most Amazon actors drive a real or headless browser against amazon.com, which means proxy costs, occasional IP blocks/CAPTCHAs, and slower runs. This actor calls a licensed SERP data API directly: no proxies, no browser, no IP bans, and — because there's no proxy or browser compute overhead — a lower price per product.

**How do I filter by price?**
Set `priceMin` and/or `priceMax` on the input. Both are applied upstream by Amazon's own search, so you're never charged for products outside your range.

**Does this include sponsored/ad products?**
Not by default. Set `includeSponsored: true` to include them, marked `isSponsored: true` — see Sponsored products above for one edge case with `deduplicate`.

**Can I run this via API, on a schedule, or trigger it from a webhook?**
Yes. Any Apify actor can be started, monitored and read back through the [Apify API](https://docs.apify.com/api/v2), run on a recurring [schedule](https://docs.apify.com/platform/schedules) from the Apify Console, and wired to webhooks on run events (started, succeeded, failed) from the same Console.

# Actor input Schema

## `queries` (type: `array`):

One or more Amazon search keywords, e.g. "wireless earbuds". Max 700 characters each, max 500 queries per run.

## `country` (type: `string`):

ISO-2 country code selecting the Amazon marketplace, language and location for the search: US -> amazon.com, GB -> amazon.co.uk, DE -> amazon.de, FR -> amazon.fr, ES -> amazon.es, IT -> amazon.it, CA -> amazon.ca, MX -> amazon.com.mx, JP -> amazon.co.jp, IN -> amazon.in, BR -> amazon.com.br, AU -> amazon.com.au.

## `maxResultsPerQuery` (type: `integer`):

Maximum number of products to return per query (1-700).

## `department` (type: `string`):

Restrict results to one Amazon department. Names are Amazon's US/English department list; behavior on non-US marketplaces is unverified (see README Limits).

## `priceMin` (type: `integer`):

Only return products priced at or above this amount, in the marketplace's currency.

## `priceMax` (type: `integer`):

Only return products priced at or below this amount, in the marketplace's currency.

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

How Amazon sorts results. Leave unset to keep Amazon's default relevance order.

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

true: keep sponsored/ad products (amazon\_paid) in the output, marked isSponsored: true. false (default): only organic results.

## `deduplicate` (type: `boolean`):

Remove duplicate products (by ASIN) seen across multiple queries in this run. When includeSponsored is true and the same ASIN appears both as a sponsored and an organic result, the first one encountered in the page (usually the sponsored slot) is kept.

## Actor input object example

```json
{
  "queries": [
    "wireless earbuds"
  ],
  "country": "US",
  "maxResultsPerQuery": 20,
  "includeSponsored": false,
  "deduplicate": true
}
```

# Actor output Schema

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

No description

## `stats` (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 = {
    "queries": [
        "wireless earbuds"
    ],
    "country": "US",
    "maxResultsPerQuery": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("moyadata/amazon-product-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 = {
    "queries": ["wireless earbuds"],
    "country": "US",
    "maxResultsPerQuery": 20,
}

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

```

## MCP server setup

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