# Amazon Scraper: Product Search & Sales Volume (`automation-lab/amazon-scraper`) Actor

Scrape Amazon search results in 10 marketplaces: price, list price, rating, reviews, "bought in past month" sales volume, Best Seller and Amazon's Choice badges, Prime and delivery. Filter by price or exclude sponsored. Export JSON, CSV, Excel.

- **URL**: https://apify.com/automation-lab/amazon-scraper.md
- **Developed by:** [Automation Lab](https://apify.com/automation-lab) (community)
- **Categories:** E-commerce, Lead generation
- **Features:** Limited permissions, Multi-tenant, Server interface
- **Stats:** 399 total users, 75 monthly users, 99.9% runs succeeded, 4 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $2.40 / 1,000 product scrapeds

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

### What does Amazon Scraper do?

Amazon Scraper extracts product data from **Amazon search results** across **10 marketplaces**. Search by keyword and get structured data for every product — prices, list prices, ratings, review counts, **"bought in past month" sales volume**, Best Seller and Amazon's Choice badges, delivery promise, Prime status, and images. It keeps loading result pages until it delivers the number of products you ask for, and supports price, rating, Prime and sponsored filters, sorting, and automatic currency detection.

Use it for **price monitoring**, **competitive intelligence**, **dropshipping research**, **market analysis**, and **product research** across any Amazon product category.

### Price monitoring workflow

Schedule recurring Amazon searches for the SKUs, brands, or product queries you care about. Each run captures the current `price`, `listPrice`, deal badges, `boughtPastMonth` sales volume, Prime flag, availability, and `scrapedAt` timestamp so you can export fresh datasets to CSV/JSON, Google Sheets, webhooks, or your BI stack.

Example: monitor 20–100 Amazon keywords or ASIN-adjacent queries daily, compare `price` against `listPrice` in downstream spreadsheets or alerts, and flag price drops, discount depth, or MAP-policy violations. For cross-merchant benchmarking beyond Amazon, pair these retailer-specific results with [Google Shopping Scraper](https://apify.com/automation-lab/google-shopping-scraper) as the comparison hub, [eBay Scraper](https://apify.com/automation-lab/ebay-scraper) for active marketplace asking prices, and [eBay Sold Listings Scraper](https://apify.com/automation-lab/ebay-sold-scraper) for realized resale comps.

### Who is it for?

Amazon Scraper is built for ecommerce teams, marketplace sellers, price-intelligence analysts, dropshipping researchers, agencies, and developers who need repeatable Amazon search-result data in structured datasets instead of manual copy-paste.

### Use cases

- **Price monitoring** — Schedule recurring runs, export each dataset, and compare `price` vs `listPrice` downstream to spot price drops, discounts, and MAP violations.
- **Dropshipping and retail arbitrage** — Find profitable products by comparing Amazon prices with other marketplaces. Identify items with large price gaps.
- **Competitive intelligence** — Monitor competitor product listings, pricing, search rank (`searchPosition`), and monthly sales volume across Amazon marketplaces.
- **Market research** — Analyze product categories, pricing distributions, ratings, and review volumes to identify market trends and opportunities.
- **Product research for sellers** — Find high-demand, low-competition products. Use `boughtPastMonthMin`, Best Seller badges, and review counts to validate product ideas.

### Why use Amazon Scraper?

- **10 Amazon marketplaces** — US, UK, Germany, France, Italy, Spain, Canada, Japan, India, Australia. Proxy country is set automatically.
- **Fast and lightweight** — Pure HTTP extraction with Cheerio, no browser needed. Scrapes 20+ products per page.
- **Reliable anti-bot handling** — Residential proxy rotation with automatic retries and locale-aware cookies.
- **Gets the count you ask for** — Loads as many result pages as needed (up to Amazon's 20-page limit, about 300 products per keyword) and the run's status message says how many products you got and why it stopped.
- **Sales and badge signals** — `boughtPastMonth` ("4K+ bought in past month"), `badges`, `isBestSeller`, `isAmazonChoice`, and `deliveryText` on every result where Amazon shows them.
- **Result filters** — Minimum/maximum price (Amazon applies the range itself on every marketplace, so result pages stay full) and exclude sponsored. You only pay for products that match. To sort by rating, use `sort: avg_rating`; `isPrime` and `rating` are in every row for your own filtering.
- **Clean structured data** — Every product includes price, list price, rating, review count, Prime status, and images, with localized prices and ratings parsed to numbers on every marketplace.
- **Query-aware deduplication** — Skips duplicate ASINs within each keyword while preserving the same product when it ranks for different queries.
- **Multiple search queries** — Run several keyword searches in a single run and attribute every result to its query, page, and 1-based position.
- **Flexible sorting** — Sort by relevance, price (low/high), average rating, or newest.
- **Pay-per-event pricing** — You only pay for products scraped. No monthly subscription.

### What data can you extract?

Each product in the output includes:

| Field | Description |
|-------|-------------|
| `searchQuery` | Search keyword that produced the result |
| `searchPage` | 1-based Amazon results page where the product appeared |
| `searchPosition` | 1-based product position within the query across all scraped pages |
| `asin` | Amazon Standard Identification Number |
| `name` | Full product title |
| `brand` | Brand name (only when Amazon shows it separately from the title; usually empty) |
| `price` | Current selling price (number) |
| `priceString` | Formatted price (e.g., "$299.99") |
| `listPrice` | Original/list price before discount |
| `listPriceString` | Formatted original price |
| `currency` | Currency code (USD, GBP, EUR, etc.) |
| `availability` | Stock status |
| `rating` | Average customer rating (1-5) |
| `reviewCount` | Total number of customer ratings |
| `seller` | Not shown in Amazon search results; always empty (kept for compatibility) |
| `thumbnail` | Product image URL |
| `images` | Array of product image URLs |
| `url` | Direct link to product on Amazon |
| `isSponsored` | Whether the product is a sponsored listing |
| `isPrime` | Whether Amazon marks the offer as Prime-eligible (amazon.com only; always `false` on other marketplaces, which don't show Prime to visitors who aren't signed in) |
| `bestSellerRank` | First badge text (legacy; see `badges`) |
| `badges` | All badges, e.g. "Overall Pick", "Best Seller in Earbud & In-Ear Headphones", "Limited time deal" |
| `isBestSeller` | Whether the product shows a Best Seller badge |
| `isAmazonChoice` | Whether the product shows an Amazon's Choice / Overall Pick badge |
| `boughtPastMonth` | Amazon's sales-volume label, e.g. "4K+ bought in past month" (null when not shown) |
| `boughtPastMonthMin` | The same as a number ("4K+" = 4000) |
| `deliveryText` | Delivery promise shown on the result |
| `categoryBreadcrumb` | Not shown in Amazon search results; always empty (kept for compatibility) |
| `scrapedAt` | ISO timestamp of when data was collected |

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

This Actor uses **pay-per-event** pricing — you pay only for what you scrape. No monthly subscription. All platform costs (compute, proxy, storage) are **included**.

Current actor charges are:

| Event | Free | Bronze | Silver | Gold | Platinum | Diamond |
|---|---:|---:|---:|---:|---:|---:|
| Actor start | $0.001 | $0.001 | $0.001 | $0.001 | $0.001 | $0.001 |
| Per product | $0.0046 | $0.004 | $0.00312 | $0.0024 | $0.0016 | $0.00112 |

The total actor charge is the one-time actor-start event plus the applicable per-product rate multiplied by the number of products saved. Check the live pricing panel before a large run because Apify may update prices or plan tiers.

### How to scrape Amazon products

1. Click **Try for free** to open the Actor in Apify Console.
2. Enter one or more search keywords (e.g., "laptop", "wireless mouse").
3. Choose your Amazon marketplace (US, UK, DE, etc.).
4. Set the maximum number of products per keyword, and optional filters (price range, exclude sponsored).
5. Click **Start** and wait for the run to finish.
6. Download your data as JSON, CSV, or Excel from the **Dataset** tab.

**Example input:**

```json
{
    "searchQueries": ["laptop", "gaming mouse"],
    "marketplace": "US",
    "maxProductsPerSearch": 100,
    "sort": "relevance",
    "minPrice": 20,
    "maxPrice": 500,
    "excludeSponsored": true
}
```

### Input parameters

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `searchQueries` | array | *required* | Keywords to search on Amazon |
| `marketplace` | string | "US" | Amazon marketplace: US, UK, DE, FR, IT, ES, CA, JP, IN, AU |
| `maxProductsPerSearch` | integer | 100 | Maximum products to return per keyword |
| `maxSearchPages` | integer | 20 | Safety cap on result pages per keyword. The Actor stops earlier once it has `maxProductsPerSearch` products or Amazon has no more pages |
| `sort` | string | "relevance" | Sort: relevance, price_low, price_high, avg_rating, newest |
| `minPrice` / `maxPrice` | number | — | Only return products in this price range (marketplace currency; Amazon applies it; the maximum must be above 0) |
| `excludeSponsored` | boolean | false | Skip sponsored placements |
| `maxRequestRetries` | integer | 10 | Maximum attempts for transient failures; healthy sessions keep one coherent browser fingerprint and retries rotate proxy identity, fingerprint, and search route |

### Output example

```json
{
    "type": "product",
    "searchQuery": "budget laptop",
    "searchPage": 1,
    "searchPosition": 1,
    "asin": "B0947BJ67M",
    "name": "HP 14 Laptop, Intel Celeron N4020, 4 GB RAM, 64 GB Storage",
    "brand": "",
    "price": 184,
    "priceString": "$184.00",
    "listPrice": 229.99,
    "listPriceString": "$229.99",
    "currency": "USD",
    "availability": "In stock",
    "rating": 4,
    "reviewCount": 5144,
    "seller": "",
    "images": ["https://m.media-amazon.com/images/I/71cWZUr9SVL._AC_UY218_.jpg"],
    "thumbnail": "https://m.media-amazon.com/images/I/71cWZUr9SVL._AC_UY218_.jpg",
    "url": "https://www.amazon.com/dp/B0947BJ67M",
    "isSponsored": false,
    "isPrime": false,
    "bestSellerRank": "Best Seller",
    "badges": ["Best Seller in Traditional Laptops"],
    "isBestSeller": true,
    "isAmazonChoice": false,
    "boughtPastMonth": "2K+ bought in past month",
    "boughtPastMonthMin": 2000,
    "deliveryText": "FREE delivery Sat, Nov 7",
    "categoryBreadcrumb": "",
    "scrapedAt": "2026-03-02T20:45:28.024Z"
}
```

### Tips for best results

- **Start with low limits** — Set `maxProductsPerSearch` to 10-20 for testing before scaling up.
- **Use specific keywords** — "wireless gaming mouse logitech" returns better results than just "mouse".
- **Try different marketplaces** — Compare prices across US, UK, DE for arbitrage opportunities.
- **Schedule regular runs** — Use [Apify Schedules](https://docs.apify.com/platform/schedules) for daily price monitoring.
- **Sort by price** — Use `price_low` or `price_high` to find the cheapest or most expensive products in a category.
- **Multiple keywords per run** — Add several keywords to `searchQueries` for efficient batch scraping. Use `searchQuery` and `searchPosition` to compare a product's ranking across keywords; an ASIN can appear once for each query.
- **Combine with other scrapers** — Cross-reference Amazon prices with Walmart or Target data for price comparison.

### Integrations

Connect Amazon Scraper to your existing tools and workflows:

- [**Google Sheets**](https://apify.com/integrations/google-sheets) — Export scraped data directly to Google Sheets.
- [**Zapier**](https://apify.com/integrations/zapier) — Trigger actions in 5,000+ apps when new data is scraped.
- [**Make (Integromat)**](https://apify.com/integrations/make) — Build automated workflows with scraped Amazon data.
- [**Slack**](https://apify.com/integrations/slack) — Get notified when prices drop below a threshold.
- [**Webhooks**](https://docs.apify.com/platform/integrations/webhooks) — Send data to your own API endpoint after each run.
- [**Apify API**](https://docs.apify.com/api/v2) — Programmatically start runs and retrieve results.
- [**Amazon → Google Sheets price tracker**](https://apify.com/integrations/google-sheets) — Schedule daily runs and auto-append results to a spreadsheet. Build a price history dashboard without writing code.
- [**Amazon → Slack deal alerts**](https://apify.com/integrations/slack) — Get a Slack message when a product drops below your target price. Combine with Zapier filters to set per-product thresholds.

### API usage

Start the actor programmatically and read the default dataset from the Apify API.

**Node.js:**

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

const client = new ApifyClient({ token: 'YOUR_API_TOKEN' });

const run = await client.actor('automation-lab/amazon-scraper').call({
    searchQueries: ['laptop'],
    marketplace: 'US',
    maxProductsPerSearch: 100,
});

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

**Python:**

```python
from apify_client import ApifyClient

client = ApifyClient('YOUR_API_TOKEN')

run = client.actor('automation-lab/amazon-scraper').call(run_input={
    'searchQueries': ['laptop'],
    'marketplace': 'US',
    'maxProductsPerSearch': 100,
})

items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

**cURL:**

```bash
curl "https://api.apify.com/v2/acts/automation-lab~amazon-scraper/runs" \
  -X POST \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer YOUR_API_TOKEN" \
  -d '{
    "searchQueries": ["laptop"],
    "marketplace": "US",
    "maxProductsPerSearch": 50
  }'
```

### Use with AI agents via MCP

Amazon Scraper is available as a tool for AI assistants that support the [Model Context Protocol (MCP)](https://docs.apify.com/platform/integrations/mcp).

#### Setup for Claude Code

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

#### Setup for Claude Desktop, Cursor, or VS Code

Add this to your MCP config file:

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

#### Example prompts

Once connected, try asking your AI assistant:

- "Search Amazon for wireless headphones under $50 and get the top 20 results"
- "Find Prime-eligible coffee grinders rated 4+ stars on Amazon US, without sponsored results"
- "Compare prices of MacBook Air across Amazon marketplaces"

Learn more in the [Apify MCP documentation](https://docs.apify.com/platform/integrations/mcp).

### Is it legal to scrape Amazon?

Scraping publicly available Amazon product data is generally considered legal. The landmark *hiQ Labs v. LinkedIn* ruling confirmed that scraping public data does not violate the Computer Fraud and Abuse Act. Amazon product listings, prices, and reviews are publicly visible to anyone with a browser.

Key points:

- Only publicly available product data is collected
- No login credentials or private accounts are accessed
- The scraper respects rate limits to avoid overloading servers
- Extracted data should be used responsibly and in compliance with applicable laws

Always review Amazon's Terms of Service and consult legal counsel if you plan to use scraped data commercially. For more details, see [Apify's guide on web scraping legality](https://blog.apify.com/is-web-scraping-legal/).

### FAQ

**How many products can I scrape per run?**
Amazon shows at most 20 result pages per search, which is usually about 300 products per keyword (16–22 per page). For more, split a broad keyword into narrower ones or run the same keyword with different sort orders; you can run many keywords in a single run.

**How fast is the scraper?**
Each search page takes about 3-5 seconds. A full 20-page search (about 300 products) typically completes in 1-2 minutes.

**Which Amazon marketplaces are supported?**
US, UK, Germany, France, Italy, Spain, Canada, Japan, India, and Australia. The scraper automatically sets the correct proxy country and currency for each marketplace.

**Can I get product reviews?**
The scraper returns the average rating and total review count for each product. For individual review text, use a dedicated Amazon reviews scraper.

**Why are some fields empty?**
`seller` and `categoryBreadcrumb` are not shown in Amazon search results, so they are always empty (kept so existing integrations don't break). `brand` is filled only when Amazon shows the brand separately from the title. `boughtPastMonth` and badges are filled only when Amazon shows them for that product.

**Why is the price null for some products?**
Some products show "See all buying options" instead of a direct price. This is Amazon's behavior for products with multiple seller options or variable pricing.

**The scraper is returning fewer products than expected. What can I do?**
Read the run's status message: it says how many products you got against what you asked for and why each keyword stopped. "Amazon had no more results" means the search (with your filters) has no more products — Amazon stops at 20 pages. If the "Max search pages" limit stopped a keyword, raise `maxSearchPages`. If a keyword stopped because too few products matched your filters, widen the price range or allow sponsored results. If a run fails because Amazon blocked every retry, try again or raise `maxRequestRetries` up to 12.

**Can I scrape a specific Amazon product page by URL?**
This scraper focuses on search results. For individual product page scraping (detailed specs, Q\&A, full review text), check the Apify Store for dedicated Amazon product detail scrapers.

### How do I monitor Amazon prices automatically?

To track Amazon prices over time, schedule the scraper to run on a recurring interval using [Apify Schedules](https://docs.apify.com/platform/schedules). Set up a daily or hourly cron and pipe results into Google Sheets or a database. Each run captures the current price for every product, giving you a timestamped history you can query to detect drops or spikes.

A practical setup: create a schedule that runs every morning, export results to a Google Sheet via the Apify–Google Sheets integration, and use a Zapier filter to send a Slack notification whenever a product's `price` falls below a threshold you define. This takes under 10 minutes to configure with no code.

### Can I scrape Amazon product prices across multiple marketplaces at once?

Yes. Each run supports one marketplace at a time, but you can queue runs for multiple marketplaces in parallel using the Apify API. For example, run the same keyword query against the US, UK, and DE marketplaces simultaneously, then merge the resulting datasets to compare prices in USD, GBP, and EUR side by side.

The scraper automatically sets the correct proxy country and currency for each marketplace, so you get locally accurate prices — not redirected international ones. This makes cross-marketplace price comparison or arbitrage research straightforward without any manual proxy configuration.

### What is the difference between scraping Amazon search results vs product pages?

This scraper targets **search results pages** — the listings grid you see when you type a keyword into Amazon's search bar. Each result includes the price, rating, review count, Prime badge, and thumbnail shown in the search view.

**Product detail pages** (individual ASIN pages) contain additional data: full product descriptions, bullet-point features, Q\&A sections, individual review text, and detailed specifications. If you need that level of detail, search the Apify Store for a dedicated Amazon product detail scraper. For price monitoring, competitor research, and category overviews, search results scraping is typically faster and more cost-effective.

### How do I find profitable products for dropshipping using Amazon data?

Dropshipping and retail arbitrage research with this scraper typically follows this workflow:

1. Run searches for broad product categories (e.g., "kitchen gadgets under $30") across multiple Amazon marketplaces.
2. Filter results where `listPrice` significantly exceeds `price` — large discounts indicate demand but also signal competition.
3. Cross-reference `reviewCount` and `rating` to identify products with strong social proof but manageable review velocity (hard to compete if a product has 50,000 reviews; a sweet spot is 500–5,000).
4. On amazon.com, flag products with `isPrime: false` — non-Prime items often have weaker competition and higher margin potential for FBA sellers who can offer Prime shipping.
5. Sort by `boughtPastMonthMin` to see which products actually sell, then export to a spreadsheet for margin calculations to build your shortlist.

Combine with the [Walmart Scraper](https://apify.com/automation-lab/walmart-scraper) to compare Amazon prices against Walmart for arbitrage gaps.

### Why is Amazon data sometimes incomplete or blocked?

Amazon actively defends against automated data collection. Common reasons for incomplete data:

- **CAPTCHA pages** — Amazon serves challenges during high-traffic periods or when a proxy IP is flagged. The scraper keeps proxy, browser fingerprint, and marketplace locale coherent for healthy sessions. Blocked retries rotate all identity components and equivalent search routes, using 10 attempts by default; you can raise `maxRequestRetries` to 12 for unusually intermittent runs.
- **"See all buying options" prices** — Some products list multiple sellers and don't show a single price in search results. The `price` field will be `null` for these. This is Amazon's design, not a scraper limitation.
- **Empty `brand` or `seller` fields** — These fields are inconsistently included in Amazon's search result HTML. They're more reliably available on individual product pages.
- **Marketplace-specific layouts** — Non-US marketplaces occasionally serve different HTML structures. If results look sparse on a specific marketplace, try a fresh run or a more specific keyword.

### Data handling and affiliation

The Actor sends your search keywords and standard request metadata to Amazon's public search pages through Apify Proxy. When a run fails, it sends sanitized diagnostic input, the exception, and the Actor, build and run IDs to our private GlitchTip error-tracking service so we can fix the problem; secret fields and URL query strings are removed, and reports are retained for 30 days. It does not request Amazon credentials, use an external data store, or retain a separate copy of inputs or results; Apify's normal run-storage retention and deletion controls apply. Use the data responsibly and comply with applicable laws and source terms.

This Actor is independently operated and is not affiliated with, endorsed by, or sponsored by Amazon.

### Related actors

- [Google Shopping Scraper](https://apify.com/automation-lab/google-shopping-scraper) — Use as the cross-merchant comparison hub for price-monitoring workflows.
- [eBay Scraper](https://apify.com/automation-lab/ebay-scraper) — Extract active eBay listings, asking prices, shipping, and seller information.
- [eBay Sold Listings Scraper](https://apify.com/automation-lab/ebay-sold-scraper) — Add realized sold prices and resale comps to Amazon price analysis.
- [Walmart Scraper](https://apify.com/automation-lab/walmart-scraper) — Scrape Walmart product data, prices, and reviews.
- [Etsy Scraper](https://apify.com/automation-lab/etsy-scraper) — Scrape Etsy product listings, seller data, and shop reviews.
- [Craigslist Scraper](https://apify.com/automation-lab/craigslist-scraper) — Scrape Craigslist listings by keyword and city.
- [Target Scraper](https://apify.com/automation-lab/target-scraper) — Scrape Target product data and pricing.
- [Shopify Scraper](https://apify.com/automation-lab/shopify-scraper) — Extract products from any Shopify store.

### Use with AI agents via x402 (no Apify account)

Agent workflows can run this actor through Apify MCP without an Apify account when the MCP client uses a funded x402 wallet. Use the actor-specific MCP endpoint:

`https://mcp.apify.com?tools=automation-lab/amazon-scraper&payment=x402`

This keeps existing Apify MCP/API usage unchanged; x402 only changes payment/authentication for clients that support it. Learn more in Apify's [x402 integration docs](https://docs.apify.com/platform/integrations/x402).

### Server API: search Amazon over HTTP

Amazon Scraper is also a Server Actor. Besides normal runs, it answers short HTTP requests directly, without starting a run for each search. Copy the server URL from the Actor's **Server** tab (do not build it from the Actor name) and authenticate with your Apify token. Use normal Actor runs for many keywords, more than 60 products or deeper result pages.

```bash
curl -sS "$SERVER_URL/search?query=wireless+earbuds&maxProducts=10" -H "Authorization: Bearer $APIFY_TOKEN"
curl -sS "$SERVER_URL/search?query=kaffeemaschine&marketplace=DE&sort=price_low&maxPrice=100" -H "Authorization: Bearer $APIFY_TOKEN"
```

| Method and path | Input | Output and charge |
| --- | --- | --- |
| `GET /` | None | `ready: true`, the routes and limits; no scraping or charge |
| `GET /search` | Query `query`: search keyword (1–200 characters); optional `marketplace` (`US`, `UK`, `DE`, `FR`, `IT`, `ES`, `CA`, `JP`, `IN`, `AU`; default `US`), `maxProducts` 1–60 (default 20), `sort` (`relevance`, `price_low`, `price_high`, `avg_rating`, `newest`; default `relevance`), `minPrice` and `maxPrice` (marketplace currency), `excludeSponsored` (`true` or `false`) | `{ok,count,results}` with the same records as a normal run's dataset items, from the first 3 result pages at most; one Product scraped event per returned product; no start fee |

A search with no matching products returns an error and is free. If Amazon blocks a later result page, the products already found are returned and charged. Each request has a 90-second deadline and a 512 KiB response cap, and one server works on at most six requests at once. Nothing is cached. Errors use `{ "ok": false, "error": { "code": "...", "message": "...", "retryable": false } }`: 400 `INVALID_QUERY`, `INVALID_MARKETPLACE`, `INVALID_SORT`, `INVALID_LIMIT`, `INVALID_PRICE` or `INVALID_INPUT`; 402 spending limit; 404 `NO_RESULTS` or unknown route; 405 wrong method; 502 `BLOCKED`, `UPSTREAM_ERROR` or charging failure; 503 server busy or stopping; 504 `TIMEOUT`. Failed requests are free. Retry only when `retryable` is true. The Server tab shows the full OpenAPI description.

# Changelog

This Actor's version history is a separate document: https://apify.com/automation-lab/amazon-scraper/changelog.md

# Actor input Schema

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

Search Amazon for these keywords. Each keyword runs a separate search. Example: laptop stand, wireless earbuds, coffee grinder.

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

Which Amazon marketplace to scrape. Proxy country is set automatically.

## `maxProductsPerSearch` (type: `integer`):

Maximum number of product records to return per search keyword.

## `maxSearchPages` (type: `integer`):

Safety cap on result pages per keyword. The Actor keeps loading pages until it reaches "Max products per search" or Amazon has no more results, so you normally don't need to change this. Amazon shows about 16-60 products per page.

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

Sort order for Amazon search results.

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

Only return products priced at or above this amount, in the marketplace currency. Amazon applies the range itself; products without a shown price are skipped when a price filter is set.

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

Only return products priced at or below this amount, in the marketplace currency. Must be greater than 0; leave empty for no maximum.

## `excludeSponsored` (type: `boolean`):

Skip sponsored (ad) placements and return organic results only.

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

Maximum request attempts for transient failures. Healthy residential sessions are reused across searches; each retry rotates identity and alternates an equivalent Amazon search route.

## Actor input object example

```json
{
  "searchQueries": [
    "laptop"
  ],
  "marketplace": "US",
  "maxProductsPerSearch": 10,
  "maxSearchPages": 20,
  "sort": "relevance",
  "excludeSponsored": false,
  "maxRequestRetries": 10
}
```

# Actor output Schema

## `overview` (type: `string`):

Dataset containing the extracted Amazon products.

# 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": [
        "laptop"
    ],
    "maxProductsPerSearch": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/amazon-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": ["laptop"],
    "maxProductsPerSearch": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/amazon-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 '{
  "searchQueries": [
    "laptop"
  ],
  "maxProductsPerSearch": 10
}' |
apify call automation-lab/amazon-scraper --silent --output-dataset

```

## MCP server setup

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