# Amazon Product Search Scraper - Prices & Ranks (`zyra/amazon-products-search-scraper`) Actor

Every product on any Amazon search URL: price and list price, rating, review count, units sold last month, brand, ASIN, Prime, coupons, badges and search rank. 30 fields per product.

- **URL**: https://apify.com/zyra/amazon-products-search-scraper.md
- **Developed by:** [Zyra](https://apify.com/zyra) (community)
- **Categories:** E-commerce, Lead generation
- **Stats:** 1 total users, 1 monthly users, 80.0% runs succeeded, 1 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $2.00 / 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

**Every product on an Amazon search page — price, rating, rank and demand.**

Search Amazon the way you normally would. Paste the URL. Get every product
behind it as structured data, 30 fields each — from any marketplace.

### Why this one

**List price and sale price, side by side.** Both `initial_price` and
`final_price` come back, so the discount is a subtraction rather than a guess.
That is the field most price-tracking datasets quietly leave out.

**Real demand signals, not just star ratings.** `bought_past_month` carries
Amazon's own "N bought in past month" figure, alongside the rating and the
total number of ratings. Popularity and sentiment, on the same row.

**Search rank, preserved.** `page_number` and `rank_on_page` record exactly
where each product sat in the results, and `sponsored` marks the paid
placements. That is what makes this usable for share-of-shelf and ad
monitoring, not just a price list.

**Any Amazon marketplace.** amazon.com, .co.uk, .de, .co.jp, .com.au, .in and
the rest — the URL decides. Run several marketplaces in one go and compare.

### What you get

**The product** — name, ASIN, brand, product URL, image URL, and the
variations offered.

**The money** — final price, initial list price, and the currency.

**The demand** — rating out of 5, number of ratings, units bought in the past
month, units sold, and any badge such as "Overall Pick" or "#1 Best Seller".

**The placement** — page number, rank on page, whether the result is
sponsored, whether it is a banner product, and the total results the search
reported.

**The offer** — Prime eligibility, Subscribe & Save, coupons, Amazon Fresh,
delivery options, business type, and any sponsored video.

### Sample output

One real row, abridged:

```json
{
  "asin": "B0CF3VGQFL",
  "name": "Redragon Mechanical Gaming Keyboard Wired, 11 Programmable Backlit...",
  "final_price": 29.99,
  "initial_price": 42.21,
  "currency": "USD",
  "rating": 4.3,
  "num_ratings": 67,
  "bought_past_month": 3000,
  "badge": "Overall Pick",
  "sponsored": "false",
  "is_prime": false,
  "page_number": 1,
  "rank_on_page": 1,
  "keyword": "mechanical keyboard",
  "total_results": 30000,
  "input": { "url": "https://www.amazon.com/s?k=mechanical+keyboard" }
}
```

That row came from a live run — 26 of its 30 fields were populated. Export to
JSON, CSV, Excel or XML, or pull it straight from the API.

Fields Amazon does not show on a search result come back empty rather than
guessed at. Prices, ratings, rank and ASIN are near-universal; `brand`,
`badge`, `business_type` and `sponsored_video` appear only on some listings,
because Amazon only shows them on some listings.

### How it works

1. Search on Amazon and copy the URL from your address bar.
2. Paste it into **Amazon search URLs**. Add more URLs to run several searches,
   or several marketplaces, at once.
3. Set a limit if you want one, and run it.

The search term and the marketplace are read out of the URL, so there is
nothing to type twice.

**What carries over, and what does not.** The search term and the marketplace
are used; Amazon's own result filters — department, brand, price band, rating,
Prime — are not. A URL of `/s?k=laptop&rh=p_89:Apple` is collected as a plain
search for *laptop* on that marketplace. Filter the results on your side, on
the fields below, rather than in the Amazon URL.

### Input

| Field | Required | What it does |
| --- | --- | --- |
| **Amazon search URLs** | yes | One or more Amazon search results URLs, from any marketplace. The search term and the marketplace are read from each URL. |
| **Max products per URL** | no | Stop after this many products from each search. **Prefilled at 10**, so a first run is a quick sample. Raise it up to 1,000, or clear the field to collect 1,000 per URL. |
| **Max products in total** | no | Stop the whole run after this many products, across all searches. Up to 10,000; empty means 10,000. |

Limits are applied during collection wherever Amazon allows it, so a limited
run genuinely does less work. Every run is bounded, so a broad search can never
run away with itself.

**Run it once to see the shape of the data, then open it up.** The prefilled 10
products per URL keeps a first run quick and cheap.

### Built to be trusted with real work

**Stop a run at any time and keep what it found.** Aborting stops the
collection and delivers every product completed up to that moment. Nothing is
abandoned and nothing half-fetched is passed off as a result.

**You are never charged for a product you did not receive.** Searches that
failed are reported separately and never reach your dataset. Amazon returns a
whole results page at a time, so a small limit can overshoot — anything past
your limit is dropped before delivery and never billed.

**Results come back in rank order.** When a limit trims a search, what you keep
is the top of the results, not an arbitrary slice.

**Clean, stable output.** Field names come straight from the source schema and
are not renamed or reshaped between runs.

**No invented data.** A field Amazon does not show comes back empty. Nothing is
inferred, averaged or filled in to make a row look complete.

### What people use it for

- **Price and promotion tracking** — watch list price against sale price across
  a category, and catch discounts as they land.
- **Share of shelf** — measure how much of page one a brand occupies, organic
  against sponsored.
- **Competitor and ad monitoring** — see who is paying for placement on which
  search terms, in which marketplace.
- **Product and demand research** — rank a category by units bought last month,
  rating and review volume before committing to a line.
- **Catalogue building** — pull ASINs, brands, images and prices for a whole
  search in one pass.

### Free accounts

On a free Apify plan a run collects up to 10 products, whatever the limits
above say. Nothing beyond that is collected, so a capped run finishes quickly.
Upgrade to a paid plan and the limits above apply in full.

### Good to know

- A URL is checked for shape and for a search term in it. A product page or a
  URL with no search term is refused with a message saying so, rather than
  becoming a collection that returns nothing.
- Two URLs that ask the same marketplace for the same term are collected once,
  even if their other filters differ, because those filters are not used.
- Whether a search returns any products is not knowable until collection runs.
- Amazon paginates in whole pages of roughly 40–60 results, which is why a
  request for 5 products may collect a page and then trim it.
- If a search cannot be collected, it is reported in the log and counted in the
  run summary rather than silently dropped.

# Actor input Schema

## `searchUrls` (type: `array`):

One or more Amazon search results URLs. Every product on each search is collected. Search on Amazon and paste the URL from your address bar — the search term and the marketplace (.com, .co.uk, .de, .co.jp and the rest) are read from it, so nothing needs typing twice. Note that Amazon's own search filters — department, brand, price, Prime — are not carried over; results come back as an unfiltered search for that term on that marketplace.

## `maxProductsPerUrl` (type: `integer`):

Stop after this many products from each search URL. Prefilled at 10 so a first run is a quick sample; raise it for a full collection, up to 1,000. Clearing the field collects up to 1,000 per URL.

## `maxProductsTotal` (type: `integer`):

Stop the whole run after this many products, across all search URLs together. Up to 10,000; empty means 10,000.

## Actor input object example

```json
{
  "searchUrls": [
    "https://www.amazon.com/s?k=wireless+earbuds"
  ],
  "maxProductsPerUrl": 10,
  "maxProductsTotal": 10000
}
```

# Actor output Schema

## `products` (type: `string`):

Every product collected, one item per product.

## `runSummary` (type: `string`):

What was requested, what arrived, and what was charged.

# 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 = {
    "searchUrls": [
        "https://www.amazon.com/s?k=wireless+earbuds"
    ],
    "maxProductsPerUrl": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("zyra/amazon-products-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 = {
    "searchUrls": ["https://www.amazon.com/s?k=wireless+earbuds"],
    "maxProductsPerUrl": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("zyra/amazon-products-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 '{
  "searchUrls": [
    "https://www.amazon.com/s?k=wireless+earbuds"
  ],
  "maxProductsPerUrl": 10
}' |
apify call zyra/amazon-products-search-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,zyra/amazon-products-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/8ID7VnzjPmJMuia0P/builds/riUGzVMaLYlzsbI92/openapi.json