# Amazon Product Search Results Scraper (`automation-lab/amazon-product-search-results-scraper`) Actor

Export ranked Amazon keyword search results with ASINs, prices, ratings, images, Prime, sponsored placement, and merchandising badges across five marketplaces.

- **URL**: https://apify.com/automation-lab/amazon-product-search-results-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** E-commerce
- **Stats:** 3 total users, 2 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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/platform/actors/running/actors-in-store#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 Results Scraper

Export ranked **Amazon** keyword search results as structured product cards for assortment research, search-rank analysis, price tracking, and data pipelines. The Actor returns ASINs, titles, prices, ratings, review counts, images, Prime and sponsored signals, merchandising badges, delivery text, result positions, and source URLs.

It supports Amazon United States, United Kingdom, Germany, India, and Canada. Country-matched residential proxy sessions are selected automatically, so a new run needs keywords—not proxy configuration or a browser.

### What can you do with this Amazon scraper?

- Capture a product assortment snapshot for one or many keywords.
- Compare organic and sponsored product placement.
- Track keyword rank, displayed price, rating, badges, and Prime status over scheduled runs.
- Research Amazon Germany, India, UK, Canada, or US search results with one output contract.
- Feed ranked product cards into Sheets, a warehouse, BI tools, or a monitoring workflow.
- Start from keywords or from real Amazon `/s?k=...` search URLs.

This Actor extracts search-result cards. It does not scrape product detail pages, reviews, seller profiles, inventory history, or a logged-in customer's personalized data.

### Who is it for?

**Brands and marketplace teams** can watch which products appear for commercial keywords and how sponsored placement changes.

**Amazon sellers** can build repeatable snapshots of assortment, rank, price, ratings, and merchandising signals.

**Agencies and analysts** can export a consistent result table across supported marketplaces instead of maintaining locale-specific parsers.

**Data engineers** can schedule runs and send the default dataset to databases, spreadsheets, webhooks, or other Actors.

### Why use this Actor?

- Search cards are normalized into a typed dataset rather than returned as HTML.
- Every row keeps the query, marketplace, page, position, and source URL that produced it.
- Search URLs and keyword inputs share the same filters and output schema.
- Challenge pages are treated as failures, not as valid empty results.
- Blocked proxy identities are retired with bounded retries.
- A global result limit prevents unexpectedly large runs.
- The lightweight HTTP implementation uses 256 MB rather than launching a browser for every page.

Amazon can vary the card layout, item count, and merchandising labels by marketplace, location, time, and session. Treat each run as an observable search snapshot, not a universal or personalized ranking.

### What data does it extract?

| Field | Meaning |
|---|---|
| `asin` | Amazon Standard Identification Number |
| `title` | Product title displayed in search |
| `url` | Canonical `/dp/{ASIN}` product URL |
| `marketplace` | `US`, `UK`, `DE`, `IN`, or `CA` |
| `searchQuery` | Keyword that produced the card |
| `rank` | Approximate rank across fetched result pages |
| `page` | Search result page number |
| `positionOnPage` | Card position on that page |
| `price`, `priceText` | Parsed numeric price and displayed price text |
| `currency` | Marketplace ISO currency code |
| `rating` | Displayed star rating, when present |
| `reviewCount` | Displayed rating/review count |
| `imageUrl` | Product thumbnail URL |
| `isPrime` | Whether the result card displays Prime |
| `isSponsored` | Whether Amazon identifies sponsored placement |
| `badges` | Labels such as Best Seller or limited-time deal |
| `deliveryText` | Delivery message shown on the card |
| `sourceUrl` | Exact search page requested |
| `scrapedAt` | UTC extraction timestamp |

A price, rating, image, delivery message, or badge can be `null` or empty when Amazon does not display it on the search card.

### How to scrape Amazon product search results

1. Open the Actor on Apify Console.
2. Add one or more values to **Search keywords**.
3. Choose the marketplace used for those keywords.
4. Set the maximum products and pages per keyword.
5. Optionally apply sort, price, rating, or sponsored-result filters.
6. Click **Start**.
7. Open the **Product results** dataset and export JSON, CSV, Excel, XML, RSS, or HTML.

The prefilled input searches for `wireless mouse` on Amazon US and returns up to 50 rows.

### Input parameters

| Input | Type | Default | Description |
|---|---|---:|---|
| `searchQueries` | string array | `[]` | Keywords searched in the selected marketplace |
| `startUrls` | URL array | `[]` | Amazon `/s` search URLs; their domain and `k` keyword are detected |
| `marketplace` | string | `US` | Marketplace for `searchQueries` |
| `maxItems` | integer | `50` | Maximum saved products across all searches (1–1,000) |
| `maxPagesPerQuery` | integer | `5` | Maximum pages per keyword (1–20) |
| `sort` | string | `relevance` | Relevance, featured, price ascending/descending, or newest |
| `minPrice` | number | unset | Minimum price in marketplace currency |
| `maxPrice` | number | unset | Maximum price in marketplace currency |
| `minimumRating` | number | unset | Minimum displayed rating from 0 to 5 |
| `includeSponsored` | boolean | `true` | Keep sponsored cards and label them |
| `maxRequestRetries` | integer | `4` | Residential sessions tried per blocked page (1–8) |

Provide at least one non-empty keyword or supported search URL. Unsupported domains, product URLs, negative prices, inverted price ranges, and invalid limits fail with a clear error.

#### Supported marketplaces

| Code | Domain | Currency | Proxy geography |
|---|---|---|---|
| `US` | amazon.com | USD | United States |
| `UK` | amazon.co.uk | GBP | United Kingdom |
| `DE` | amazon.de | EUR | Germany |
| `IN` | amazon.in | INR | India |
| `CA` | amazon.ca | CAD | Canada |

A `startUrls` entry selects its marketplace from the URL, even when `marketplace` has another value.

### Input examples

Search two related US assortments:

```json
{
  "searchQueries": ["standing desk", "office chair"],
  "marketplace": "US",
  "maxItems": 60,
  "maxPagesPerQuery": 1,
  "minimumRating": 4,
  "maxPrice": 500,
  "includeSponsored": false
}
```

Use a specific Amazon Germany search URL:

```json
{
  "startUrls": [
    { "url": "https://www.amazon.de/s?k=kaffeemaschine" }
  ],
  "maxItems": 20,
  "maxPagesPerQuery": 2
}
```

### Output example

A dataset row has this shape (values vary with the live search page):

```json
{
  "asin": "B004YAVF8I",
  "title": "Logitech M185 Compact Wireless Mouse",
  "url": "https://www.amazon.com/dp/B004YAVF8I",
  "marketplace": "US",
  "searchQuery": "wireless mouse",
  "rank": 1,
  "page": 1,
  "positionOnPage": 1,
  "price": 12.99,
  "priceText": "$12.99",
  "currency": "USD",
  "rating": 4.5,
  "reviewCount": 125000,
  "imageUrl": "https://m.media-amazon.com/images/I/example.jpg",
  "isPrime": true,
  "isSponsored": false,
  "badges": ["Overall Pick"],
  "deliveryText": "Free delivery tomorrow",
  "sourceUrl": "https://www.amazon.com/s?k=wireless+mouse&page=1",
  "scrapedAt": "2026-08-01T09:00:00.000Z"
}
```

The default dataset contains only validated product cards. Failed pages and challenge HTML are never pushed as rows and are never charged as product results.

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

The Actor uses pay-per-event pricing: one **Start** event per run plus one **Product result** event for every validated row saved. Product-result rates decrease across Apify plan tiers. The current Console pricing is the source of truth.

At the initial BRONZE rate, representative examples are:

| Workflow | Start | Product results | Estimated Actor charge |
|---|---:|---:|---:|
| Small keyword check | 1 | 20 | about **$0.085** |
| Assortment snapshot | 1 | 100 | about **$0.404** |
| Larger export | 1 | 500 | about **$2.001** |

These examples use a $0.005 Start and $0.003992 BRONZE product-result rate. Apify plan tiers can reduce the per-result rate. Your total platform bill can also reflect plan terms; always review the live pricing panel before a run.

### Rank, filters, and interpretation

`positionOnPage` is the observed card order on one page. `rank` combines page and card position using Amazon's typical page capacity, so it is useful for repeated comparisons but should not be treated as an immutable universal rank.

Price and rating filters are sent where Amazon supports them and are also applied to parsed rows. When a filter is set, a row without the corresponding displayed value is excluded. `includeSponsored: false` removes cards recognized as sponsored.

Amazon may insert widgets, carousels, editorial blocks, or ads that are not ordinary product cards. Those elements can make card rank differ from a human counting every visual block.

### Recurring assortment and price tracking

The Actor produces snapshots; Apify schedules make them recurring:

1. Create a Task with stable keywords, marketplace, filters, and limits.
2. Schedule it daily, weekly, or at another useful interval.
3. Store or export each run's dataset.
4. Join snapshots by `marketplace + searchQuery + asin`.
5. Compare rank, price, rating, sponsored status, badges, and first/last appearance.

The Actor does not maintain historical state or emit change alerts by itself. Use a database, workflow tool, or downstream Actor to compare runs.

### Integrations and exports

You can send results to:

- Google Sheets or Microsoft Excel for assortment review.
- BigQuery, Snowflake, PostgreSQL, or another warehouse for history.
- Make, Zapier, n8n, or webhooks for scheduled workflows.
- Python or JavaScript analysis notebooks.
- Apify Actors that deduplicate, transform, monitor, or enrich datasets.

Every primary result is in the run's default dataset, so standard Apify integrations work without custom storage names.

### Run through the Apify API with cURL

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~amazon-product-search-results-scraper/runs?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "searchQueries": ["wireless mouse"],
    "marketplace": "US",
    "maxItems": 20
  }'
```

To wait for completion and receive dataset items directly:

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~amazon-product-search-results-scraper/run-sync-get-dataset-items?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"searchQueries":["wireless mouse"],"marketplace":"US","maxItems":20}'
```

### JavaScript API example

```javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/amazon-product-search-results-scraper').call({
  searchQueries: ['standing desk', 'office chair'],
  marketplace: 'US',
  maxItems: 60,
  minimumRating: 4,
  includeSponsored: false,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

### Python API example

```python
import os
from apify_client import ApifyClient

client = ApifyClient(os.environ["APIFY_TOKEN"])
run = client.actor("automation-lab/amazon-product-search-results-scraper").call(
    run_input={
        "startUrls": [{"url": "https://www.amazon.de/s?k=kaffeemaschine"}],
        "maxItems": 20,
        "maxPagesPerQuery": 2,
    }
)
items = client.dataset(run["defaultDatasetId"]).list_items().items
print(items)
```

### Use with Apify MCP

#### Claude Code

Add this Actor to Claude Code:

```bash
claude mcp add --transport http apify \
  "https://mcp.apify.com?tools=automation-lab/amazon-product-search-results-scraper"
```

#### Claude Desktop, Cursor, and VS Code

Claude Desktop, Cursor, and VS Code can use this HTTP MCP configuration:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=automation-lab/amazon-product-search-results-scraper"
    }
  }
}
```

Example prompts:

- “Run the Amazon product search results scraper for `wireless mouse` in the US and return 20 products.”
- “Export the first 20 coffee machine results from Amazon Germany.”
- “Find Amazon US standing desks rated at least 4 stars below $500, excluding sponsored cards.”

### Legality, limits, and responsible use

- Results are public search-card data visible to the Actor's marketplace session.
- Search results can vary by geography, time, cookies, experimentation, and availability.
- Maximum output is 1,000 products per run and 20 pages per keyword.
- Residential proxies are required and selected internally; no browser fallback is used.
- A blocked page is retried with bounded session rotation. If every requested search remains blocked, the run fails rather than returning a misleading empty dataset.
- The Actor does not log in, bypass CAPTCHAs, access orders, or scrape customer-specific pages.
- Do not use the output to violate Amazon's terms, intellectual-property rights, privacy laws, or applicable regulations.
- Avoid collecting more data than your legitimate purpose requires and respect retention obligations.

### Troubleshooting

#### Why did the run fail after session rotation?

Amazon may temporarily challenge all tested residential identities for a marketplace. Retry later, reduce the number of pages or keywords, and keep retries at the default before increasing them. The Actor deliberately fails when no requested search reaches a recognizable result page.

#### Why are some prices or ratings missing?

Amazon does not display every field on every card. Variants, unavailable items, ads, and some category layouts can omit a price, rating, delivery message, or Prime badge. Nullable output preserves that distinction instead of inventing values.

#### Why does my result order differ from a browser?

Search order can depend on location, time, session, experiments, account state, and sponsored inventory. The Actor captures a country-matched anonymous session. Compare consistent scheduled inputs rather than expecting a personalized browser session to match exactly.

#### Why did I receive fewer rows than `maxItems`?

`maxItems` is a ceiling. Filters, duplicate ASINs, exhausted pages, natural result volume, and unavailable card fields can all reduce accepted rows.

### FAQ

#### Can I search Amazon India or Germany?

Yes. Choose `IN` or `DE` for keyword inputs, or supply an amazon.in or amazon.de `/s?k=...` URL. Currency and residential proxy geography follow the marketplace.

#### Can I scrape multiple keywords?

Yes. Add several strings to `searchQueries`. `maxItems` applies across the entire run, so raise it enough to allow later keywords to contribute rows.

#### Does it scrape product details or reviews?

No. It returns the fields visible on search cards. Use a related detail or review Actor when you need detail-page attributes or review text.

#### Does it detect sponsored products?

Yes. Sponsored cards are marked with `isSponsored`, and you can remove recognized sponsored rows with `includeSponsored: false`.

#### Can I monitor changes automatically?

Create and schedule an Apify Task, then compare its datasets downstream. This Actor creates clean snapshots but does not persist history or send alerts itself.

### Related automation-lab Actors

- [Amazon Bestsellers Scraper](https://apify.com/automation-lab/amazon-bestsellers-scraper) — category bestseller ranks and cards.
- [Amazon Reviews Scraper](https://apify.com/automation-lab/amazon-reviews-scraper) — product review datasets.
- [Amazon Keywords Discovery Tool](https://apify.com/automation-lab/amazon-keywords-discovery-tool) — autocomplete keyword ideas across marketplaces.
- [Amazon Sellers Scraper](https://apify.com/automation-lab/amazon-sellers-scraper) — public seller information.

### Support

If a supported marketplace consistently fails or a current Amazon card layout produces malformed rows, open an issue from the Actor's Apify page. Include the marketplace, a non-sensitive keyword or search URL, input limits, run ID, and a short description of the expected output. Do not include account credentials or private customer data.

# Actor input Schema

## `searchQueries` (type: `array`):

Keywords to search in the selected marketplace. You can combine several keywords in one run.

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

Optional Amazon /s search URLs. The marketplace and keyword are read from each URL.

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

Amazon marketplace used for searchQueries. Search URLs select their own marketplace.

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

Maximum product records saved across all searches.

## `maxPagesPerQuery` (type: `integer`):

Maximum Amazon result pages requested for each keyword.

## `sort` (type: `string`):

Amazon search sort order.

## `minPrice` (type: `number`):

Optional minimum product price in the selected marketplace currency.

## `maxPrice` (type: `number`):

Optional maximum product price in the selected marketplace currency.

## `minimumRating` (type: `number`):

Keep products at or above this star rating. Products without a rating are excluded when set.

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

Include sponsored product cards and identify them with isSponsored.

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

Residential sessions tried for a blocked or transiently failed page.

## Actor input object example

```json
{
  "searchQueries": [
    "wireless mouse"
  ],
  "startUrls": [],
  "marketplace": "US",
  "maxItems": 20,
  "maxPagesPerQuery": 5,
  "sort": "relevance",
  "includeSponsored": true,
  "maxRequestRetries": 4
}
```

# Actor output Schema

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

Default dataset with all extracted Amazon product cards.

# 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 = {
    "searchQueries": [
        "wireless mouse"
    ],
    "startUrls": [],
    "marketplace": "US",
    "maxItems": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/amazon-product-search-results-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 = {
    "searchQueries": ["wireless mouse"],
    "startUrls": [],
    "marketplace": "US",
    "maxItems": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/amazon-product-search-results-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "searchQueries": [
    "wireless mouse"
  ],
  "startUrls": [],
  "marketplace": "US",
  "maxItems": 20
}' |
apify call automation-lab/amazon-product-search-results-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=automation-lab/amazon-product-search-results-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/9W6tW0uSOFd3DbhXa/builds/UsyLfIHhHAZjRNu33/openapi.json