# Amazon Scraper — Products, Offers & Bestsellers (`muhammadafzal/amazon-product-offers-bestsellers-scraper`) Actor

Scrape Amazon product details, all offers and sellers, search results, seller profiles and Best Sellers ranks on 23 marketplaces. USD 2.50 per 1,000 rows.

- **URL**: https://apify.com/muhammadafzal/amazon-product-offers-bestsellers-scraper.md
- **Developed by:** [Muhammad Afzal](https://apify.com/muhammadafzal) (community)
- **Categories:** E-commerce
- **Features:** Limited permissions
- **Stats:** 5 total users, 4 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 1,000 amazon rows

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 Scraper — Products, Offers & Bestsellers

Amazon Scraper returns Amazon product data as JSON or CSV: product details by ASIN or product link, every offer and seller on an ASIN, keyword search results, seller profiles and Best Sellers rankings, from 23 Amazon marketplaces. It costs USD 2.50 per 1,000 rows on the FREE tier (USD 2.00 on GOLD) plus USD 0.005 per run, and you pay only for rows delivered.

It is built for price monitoring, Buy Box and reseller research, catalog enrichment, competitor tracking and market research. You can scrape Amazon without an API key, a login or your own proxies: the Actor handles data access and gives you clean, typed rows.

### What Amazon data does the scraper return?

Each run uses one mode, and each dataset row carries a `recordType` so mixed exports stay readable. The dataset has a view per mode.

| Mode | Input | One row per | Main fields |
|---|---|---|---|
| `product` | ASINs or product links | product | `title`, `brand`, `price`, `listPrice`, `currency`, `availability`, `inStock`, `rating`, `reviewsCount`, `ratingDistribution`, `salesVolume`, `bestSellersRank`, `categoryPath`, `bulletPoints`, `description`, `images`, `sellerName`, `sellerId`, `fulfilledByAmazon`, `offersCount`, `isPrimeEligible`, `isAmazonChoice`, `coupon`, `deliveryOptions`, `variations`, `productDetails` |
| `offers` | ASINs | seller offer | `condition`, `price`, `shippingPrice`, `currency`, `sellerName`, `sellerId`, `sellerRating`, `sellerRatingsCount`, `shipsFrom`, `deliveryOptions`, `position`, `offerId` |
| `search` | keywords | product in the results | `asin`, `title`, `price`, `listPrice`, `rating`, `reviewsCount`, `salesVolume`, `isSponsored`, `isPrime`, `isBestSeller`, `isAmazonChoice`, `couponDiscount`, `placement`, `positionOnPage`, `page`, `totalResults` |
| `sellers` | seller IDs or seller links | seller | `sellerName`, `businessName`, `businessAddress`, `rating`, `description`, `missingFields` |
| `bestsellers` | Best Sellers category IDs or links | ranked product | `rank` (1–100), `asin`, `title`, `price`, `priceText`, `rating`, `ratingsCount`, `imageUrl` |

Every row also has `marketplace`, `url` (a clean `https://www.amazon.<marketplace>/dp/<ASIN>` link, or the seller link), and `scrapedAt`. Product, offer and search rows carry `postalCode`, the delivery location the prices were read for.

A value Amazon did not show is `null`, never a guess: an unavailable product has `price: null` and `inStock: false`. Seller pages often omit the rating or the business address; those fields are `null` and named in `missingFields`.

### How do I scrape Amazon product details by ASIN?

Choose **Product details**, paste ASINs (or product links), pick the marketplace and run. The prefilled example reads one product on amazon.com:

```json
{
  "mode": "product",
  "asins": ["B09B8V1LZ3"],
  "marketplace": "com"
}
```

Product links from several Amazon countries can be mixed in `productUrls`; each link is read on its own storefront. Up to 500 ASINs and links per run. Lists longer than 30 are sent in paced batches, so a 500-ASIN run takes a few minutes. An ASIN Amazon has no page for is reported as `not-found` in `OUTPUT` and is not charged.

### How do I get all offers and sellers for an ASIN (Amazon price scraper)?

Choose **All offers and sellers**. Each page lists 10 offers, so `maxPages: 3` reads up to 30 offers per ASIN, stopping early when there are no more:

```json
{
  "mode": "offers",
  "asins": ["0735211299"],
  "marketplace": "com",
  "postalCode": "10001",
  "maxPages": 3
}
```

Every offer row has the seller ID, so you can pass those IDs to **Seller profiles** in a second run.

### How do I scrape Amazon search results?

Choose **Search results** and add keywords as a shopper types them. Each page lists about 20 to 80 products, organic results first, then sponsored ones (`isSponsored: true`). A product found by several keywords or pages is returned once. Sort and price filters use Amazon's own options; prices are in the marketplace currency:

```json
{
  "mode": "search",
  "searchQueries": ["wireless earbuds", "usb c cable"],
  "marketplace": "co.uk",
  "sortBy": "average_review",
  "minPrice": 10,
  "maxPrice": 40,
  "maxPages": 2
}
```

### How do I get the Amazon Best Sellers list for a category?

Choose **Best Sellers rankings** and paste the category number from a Best Sellers link (172282 is Electronics on amazon.com) or the whole link; a link is read on its own storefront, because category numbers differ between storefronts. Each category returns up to 100 ranked products over 2 pages. Every ranking is kept whole: a product that ranks in two of your categories appears once in each, with that category's rank.

```json
{
  "mode": "bestsellers",
  "categoryIds": ["172282"],
  "maxPages": 2
}
```

### How do I read Amazon seller information?

Choose **Seller profiles** and paste seller IDs (they start with A, for example `A2L77EE7U53NWQ`) or links such as `https://www.amazon.com/sp?seller=A2L77EE7U53NWQ` (a link is read on its own storefront). You get the seller's display name, legal business name and address when the profile shows them, the star rating, and the seller's own description.

### Which marketplaces and delivery locations are supported?

amazon.com, .ca, .com.mx, .com.br, .co.uk, .ie, .de, .fr, .it, .es, .nl, .com.be, .se, .pl, .com.tr, .ae, .sa, .eg, .in, .co.jp, .sg, .com.au and .co.za. Prices come in each marketplace's currency unless you set `currency` to another one it offers.

Prices, stock and delivery dates depend on where Amazon delivers. Set `postalCode` (for example 10001 on amazon.com, SW1A 1AA on amazon.co.uk, 10115 on amazon.de; a city name such as Dubai on amazon.ae) to read them for one fixed location. Left empty, Amazon uses its default location for the marketplace, which can differ between runs. amazon.com.tr does not accept a delivery location.

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

You pay per row delivered plus a small start fee, all-inclusive (no separate platform usage charge):

| Tier | Price per row | Per 1,000 rows | Start fee per run |
|---|---|---|---|
| FREE | USD 0.0025 | USD 2.50 | USD 0.005 |
| BRONZE (2.5% off) | USD 0.0024375 | USD 2.4375 | USD 0.005 |
| SILVER (5% off) | USD 0.002375 | USD 2.375 | USD 0.005 |
| GOLD (20% off) | USD 0.002 | USD 2.00 | USD 0.005 |

The start fee is charged once per started GB of allocated memory; the default 256 MB is one start event. Examples on FREE: one product costs USD 0.0075 (0.005 + 0.0025); 100 products cost USD 0.255; 1,000 search results cost USD 2.505. Inputs that return nothing (unknown ASINs, invalid entries, empty searches) are not charged as rows. `maxResults` (default 1,000) and the run's maximum charge both stop the run cleanly.

### What does a result look like?

A product row (shortened):

```json
{
  "recordType": "product",
  "asin": "B09B8V1LZ3",
  "title": "Amazon Echo Dot - Vibrant sounding speaker, Designed for Alexa+, Great for bedrooms, dining rooms and offices, Charcoal",
  "brand": "Amazon",
  "url": "https://www.amazon.com/dp/B09B8V1LZ3",
  "price": 79.99,
  "currency": "USD",
  "availability": "In Stock",
  "inStock": true,
  "rating": 4.7,
  "reviewsCount": 202011,
  "salesVolume": "10K+ bought",
  "sellerName": "Amazon.com",
  "sellerId": "ATVPDKIKX0DER",
  "fulfilledByAmazon": true,
  "isAmazonChoice": true,
  "deliveryOptions": [{ "type": "FREE delivery", "from": null, "by": "Friday, November 13" }],
  "variations": [{ "asin": "B09B94RL1R", "selected": false, "attributes": { "Color": "Glacier White", "Size": "Pack of 1" } }],
  "marketplace": "com",
  "postalCode": "10001",
  "scrapedAt": "2026-11-08T12:00:00.000Z"
}
```

An offer row (shortened):

```json
{
  "recordType": "offer",
  "asin": "0735211299",
  "position": 1,
  "condition": "Used - Acceptable",
  "price": 7.25,
  "shippingPrice": 3.99,
  "currency": "USD",
  "sellerName": "Easterseals-Goodwill Northern Rocky Mountain",
  "sellerId": "AJ2Q8MY175BQP",
  "sellerRating": 4.5,
  "sellerRatingsCount": 1083,
  "marketplace": "com"
}
```

The `OUTPUT` record in the key-value store summarizes the run: `status` (SUCCEEDED, PARTIAL, EMPTY, FAILED or REJECTED), rows delivered, the result of every input (`ok`, `empty`, `not-found`, `rejected`, `failed`, `skipped`), skipped entries with the reason, and the stop reason.

### When should I use Amazon Scraper, and when not?

**Use it when** you need current Amazon prices, offers, rankings, search positions or product details for a list of ASINs, keywords, sellers or categories, on a schedule or on demand.

**Use another tool when:**

- You need review text. This Actor returns ratings and rating counts, not reviews.
- You need price history over months. It reads today's pages; schedule it to build your own history.
- You need data from another marketplace: see [eBay Scraper](https://apify.com/muhammadafzal/ebay-scraper), [Google Shopping Scraper](https://apify.com/muhammadafzal/google-shopping-scraper), [AliExpress Scraper](https://apify.com/muhammadafzal/aliexpress-products-reviews-sellers) or [MercadoLibre Product & Seller Data Scraper](https://apify.com/muhammadafzal/mercadolibre-product-seller-scraper).

### Use it from an AI assistant

The Actor works from Claude, ChatGPT, Cursor or any MCP client through Apify's MCP server. Add `https://mcp.apify.com/?tools=muhammadafzal/amazon-product-offers-bestsellers-scraper` as an MCP server, then ask, for example: "List every new and used offer for ASIN 0735211299 on amazon.com with the seller ratings, cheapest first." The assistant fills in the input, runs the Actor and reads the rows.

You can also call it from the Apify API, the JavaScript or Python client, Make, Zapier or n8n, and export results as JSON, CSV or Excel.

### FAQ

**Can I scrape Amazon without an API key?**
Yes. You need only an Apify account. The Actor does not use Amazon's Product Advertising API, so there is no affiliate account, request quota or approval process.

**Is it legal to scrape Amazon?**
The Actor reads public product, offer, search, seller and Best Sellers pages that anyone can open without logging in. It collects no personal customer data. Check that your own use of the data follows the laws and terms that apply to you.

**Why is a price `null`?**
Amazon showed no price for that product at that moment: it is unavailable, needs a variant to be selected, or the offer is hidden until it is added to the cart. The Actor never fills in a price.

**Why did an ASIN return nothing?**
`OUTPUT` lists it as `not-found` when Amazon has no page for that ASIN on the chosen marketplace. Entries that are not ASINs at all are skipped before any request. Neither is charged.

**Why are some seller fields empty?**
Many seller profiles do not show a rating, business name or address, and some pages lay them out differently. Those fields are `null` and listed in `missingFields`; nothing is invented.

**How many rows can one run return?**
Up to 500 ASINs, product links or seller IDs, or 50 keywords or categories with up to 20 pages each, capped by `maxResults` (default 1,000, at most 50,000).

**Can I schedule it for price monitoring?**
Yes. Save your input as a task in Apify Console and add a schedule. Keep `postalCode` fixed so prices are comparable between runs.

Last verified: 2026-11-08

# Actor input Schema

## `mode` (type: `string`):

Use this to choose the data you want. product: full product details for each ASIN or product link. offers: every seller offer (price, condition, shipping, seller rating) for each ASIN. search: the products Amazon lists for each keyword, with prices and sponsored flags. sellers: a seller's profile page (name, business name and address, description). bestsellers: the Best Sellers ranking (top 100) of each category. Each mode reads only its own list below.

## `asins` (type: `array`):

Use this in product or offers mode. Amazon product IDs (ASINs): 10 letters and digits, for example B09B8V1LZ3, or a 10-digit ISBN for books. Up to 500 per run, together with product links. Entries that are not ASINs are skipped before any request and listed in OUTPUT.

## `productUrls` (type: `array`):

Use this in product mode when you have Amazon product page links instead of ASINs, for example https://www.amazon.com/dp/B09B8V1LZ3. The link's storefront is used, so links from different Amazon countries can be mixed. Search and category links are not product links: use search or bestsellers mode for those.

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

Use this in search mode. Keywords exactly as a shopper types them in the Amazon search box, for example wireless earbuds. Up to 50 per run. A product found under several keywords is returned once.

## `sellerIds` (type: `array`):

Use this in sellers mode. Amazon seller IDs (start with A, for example A2L77EE7U53NWQ) or seller page links such as https://www.amazon.com/sp?seller=A2L77EE7U53NWQ (a link is read on its own storefront). Offers mode returns the seller ID of every offer. Up to 500 per run.

## `categoryIds` (type: `array`):

Use this in bestsellers mode. The category number from a Best Sellers link, for example 172282 for Electronics on amazon.com, or the whole link such as https://www.amazon.com/Best-Sellers-Electronics/zgbs/electronics/172282 (a link is read on its own storefront; category numbers differ between storefronts). Each category gives up to 100 ranked products (2 pages). Up to 50 per run. Top-level links without a number (…/zgbs/electronics) are not accepted; open a subcategory or copy its number.

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

Which Amazon storefront to read ASINs, keywords, seller IDs and category IDs on. Prices come in that storefront's currency. Product, seller and Best Sellers links always use their own storefront.

## `postalCode` (type: `string`):

Optional. Use this when prices, stock or delivery dates must match a buyer location, for example 10001 (New York) on amazon.com, SW1A 1AA on amazon.co.uk or 10115 on amazon.de. amazon.ae and amazon.co.za take a city name (Dubai, Johannesburg); amazon.com.tr takes none. Left empty, Amazon uses its default delivery location for the marketplace, which can change between runs.

## `currency` (type: `string`):

Optional. A currency the marketplace offers for display, for example EUR on amazon.co.uk. Left empty, prices come in the marketplace's own currency (USD on amazon.com).

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

Search mode only. The order Amazon lists results in. Left empty, Amazon's default order (featured) is used.

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

Search mode only. Lowest price to include, in the marketplace currency, for example 25 or 19.99.

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

Search mode only. Highest price to include, in the marketplace currency.

## `maxPages` (type: `integer`):

Search, offers and bestsellers modes. How many result pages to read for each input: a search page lists about 20 to 80 products, an offers page 10 offers, a Best Sellers page 50 products (2 pages = top 100). Reading stops early when Amazon has no more pages. Each page read is one request, so more pages cost more only when they return rows.

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

The run stops after this many dataset rows (products, offers, search results, sellers or Best Sellers entries). You pay only for rows delivered.

## Actor input object example

```json
{
  "mode": "product",
  "asins": [
    "B09B8V1LZ3"
  ],
  "marketplace": "com",
  "maxPages": 1,
  "maxResults": 1000
}
```

# Actor output Schema

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

Dataset rows: one per product, offer, search result, seller or Best Sellers entry.

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

The OUTPUT record: status, per-input results, skipped entries, stop reason, warnings and request counters.

# 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 = {
    "mode": "product",
    "asins": [
        "B09B8V1LZ3"
    ],
    "marketplace": "com"
};

// Run the Actor and wait for it to finish
const run = await client.actor("muhammadafzal/amazon-product-offers-bestsellers-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 = {
    "mode": "product",
    "asins": ["B09B8V1LZ3"],
    "marketplace": "com",
}

# Run the Actor and wait for it to finish
run = client.actor("muhammadafzal/amazon-product-offers-bestsellers-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 '{
  "mode": "product",
  "asins": [
    "B09B8V1LZ3"
  ],
  "marketplace": "com"
}' |
apify call muhammadafzal/amazon-product-offers-bestsellers-scraper --silent --output-dataset

```

## MCP server setup

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