# Amazon Product Scraper (`jdtpnjtp/amazon-products`) Actor

Scrape Amazon products, prices, offers, sellers, bestsellers and deals in one run. ASINs, search queries, seller IDs, category node IDs or URLs in - clean structured rows out. Pay only per result, no subscription.

- **URL**: https://apify.com/jdtpnjtp/amazon-products.md
- **Developed by:** [Data Forge](https://apify.com/jdtpnjtp) (community)
- **Categories:** Automation, E-commerce, Lead generation
- **Stats:** 4 total users, 2 monthly users, 91.4% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 product results

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 Scraper

**Get live Amazon product, price, offers, best seller and deal data in clean JSON.** Feed it ASINs, search keywords, seller IDs, category node IDs or paste Amazon URLs, pick your data types, and export ready-to-use structured rows. Seven data surfaces, eight marketplaces, full per-seller offer breakdowns and merchant profiles. No subscription, pay only per result.

### Why this Actor?

| Capability | This Actor | Typical Amazon scraper |
|---|---|---|
| Data surfaces in one run | **7** - search, product detail by ASIN, offers, sellers, best sellers, new releases, deals (plus category-node browse) | 1 (search only) |
| Search filters | **Price band, min rating, Prime-only, brand, condition** + 6 sort orders (incl. price low-to-high / high-to-low) | Keyword only |
| Marketplaces | **8** - us, uk, de, fr, it, es, ca, jp | 1 (US only) |
| Offer + seller data | **Every offer per ASIN, incl. used and renewed resale, Buy Box flag, seller rating** | Not available |
| Merchant profiles | **Rating, feedback %, business name + address** | Not available |
| Pricing | **Pay per result, error rows free** | Monthly subscription |

### What you can scrape

Feed it any mix of search keywords, ASINs, seller IDs, category node IDs, or Amazon URLs, tick the data types you want, and it pulls up to **seven product-side surfaces** in one run:

- 🔎 **Products (search + category)** - search any keyword (paginated to your cap) or browse a category node: title, price, list price, rating, review count, brand, image, Prime badge, URL
- 📦 **Product detail (by ASIN)** - the full product page: specs, variations, all images, bullet points, description, best seller rank (everything in the `data` payload)
- 🏷 **Offers** - every seller offer for an ASIN: price, condition, seller, seller rating, Buy Box flag, ships-from, delivery
- 🏪 **Sellers** - merchant profiles: rating, rating count, positive-feedback %, business name and address, ships-from (plus the full feedback breakdown in the `data` payload), optionally their whole catalog
- 🏆 **Best sellers** - ranked category lists
- 🆕 **New releases** - the newest products by category
- 🔥 **Deals** - lightning deals, coupons, premium-brand and Amazon-brand deals, filtered by department, discount % and Prime

Flip on **Fan out search results to full product detail** and every search / category / seller-products result is enriched with its full product page. Already have specific pages? Paste them into **Start URLs** - a product, search, best seller, new-releases, seller or offer-listing URL is auto-detected and parsed directly.

### Input modes

Nine copy-paste recipes, each mapped to a one-click example task in the Actor. Mix and match freely: pass several inputs and data types in one run.

##### 1. Niche keyword search with ASINs

Catalog and market researchers mapping a whole niche. Returns up to 100 ranked listings with ASINs, price and rating.

```json
{"searchQueries": ["laptop"], "dataTypes": ["search"], "maxResultsPerType": 100}
```

##### 2. Cheapest first

Price analysts who want the low end of a category. Sorts Amazon by price, low to high.

```json
{"searchQueries": ["laptop"], "dataTypes": ["search"], "sortBy": "PRICE_LOW_TO_HIGH", "maxResultsPerType": 100}
```

##### 3. Price-band segment

Merchandisers studying a single price tier. Keeps only listings priced 300 to 600.

```json
{"searchQueries": ["laptop"], "dataTypes": ["search"], "minPrice": 300, "maxPrice": 600, "maxResultsPerType": 100}
```

##### 4. 4-star-and-up only

Quality-focused sourcing teams. Keeps only products rated 4.0 and above.

```json
{"searchQueries": ["bluetooth speaker"], "dataTypes": ["search"], "minRating": "4", "maxResultsPerType": 100}
```

##### 5. Best sellers chart

Trend spotters who want the top-ranked products in a department.

```json
{"dataTypes": ["bestsellers"], "bestsellersCategory": "electronics", "maxResultsPerType": 100}
```

##### 6. Product detail by ASIN

Teams that already know the ASIN and want the full product page.

```json
{"asins": ["B0C5144PTJ"], "dataTypes": ["product"]}
```

##### 7. Every offer for an ASIN

Repricing and Buy Box monitoring - all sellers competing on one ASIN, new and resale.

```json
{"asins": ["B0DGHMNQ5Z"], "dataTypes": ["offers"]}
```

##### 8. Today's deals

Deal-hunters and affiliate sites tracking discounts across the store.

```json
{"dataTypes": ["deals"], "maxResultsPerType": 100}
```

##### 9. New releases

Scouts watching what just launched in a category.

```json
{"dataTypes": ["newReleases"], "bestsellersCategory": "electronics", "maxResultsPerType": 100}
```

### All input fields

```json
{
  "searchQueries": ["wireless earbuds"],
  "asins": ["B0FQFB8FMG"],
  "dataTypes": ["search", "product"],
  "country": "us",
  "maxResultsPerType": 20,
  "sortBy": "PRICE_LOW_TO_HIGH",
  "minPrice": 20,
  "maxPrice": 200,
  "isPrime": true,
  "includeProductDetails": false
}
```

| Field | What it does |
|---|---|
| **searchQueries** | Keyword searches, paginated to the per-type cap. |
| **asins** | Product IDs (or /dp/ URLs) to pull as full detail (and offers, if requested). |
| **sellerIds** | Merchant IDs to pull as seller profiles (+ their catalog, optionally). |
| **categoryNodeIds** | Numeric category nodes to browse page by page. |
| **startUrls** | Paste any Amazon URL (product / search / best seller / seller / offers) to parse directly. |
| **dataTypes** | Multi-select: search, product, offers, sellers, bestsellers, newReleases, deals (default: search + product). |
| **country** | Amazon marketplace: us, uk, de, fr, it, es, ca, jp. |
| **maxResultsPerType** | Cap per surface / input item, 1 to 1000. Search paginates Amazon to reach it. |
| **includeProductDetails** | Enrich every listing result with its full product page. Extra charge per detail. |
| **Search filters** | sortBy, searchCategoryId, brand, minPrice, maxPrice, minRating, isPrime, productCondition, dealsAndDiscounts. |
| **Deals filters** | dealsCategory, dealsDepartmentId, dealsDiscountMin, dealsIsPrime. |

### Output

One flat row per result, discriminated by `row_type`, with the full payload under `data`. The dataset ships with **four ready-made table tabs** - **Overview**, **Products**, **Offers**, **Sellers** - so each surface reads as a clean spreadsheet you can sort, filter and export to CSV / Excel / JSON in one click.

#### Row types

| `row_type` | Produced by | Key columns |
|---|---|---|
| `search_result` | search queries, category node IDs | asin, title, price, rating, review\_count, is\_prime, url |
| `product_detail` | ASINs (product data type) | title, brand, price, plus specs / variations / all images in `data` |
| `offer` | offers data type on an ASIN | price, condition, seller\_name, seller\_rating, is\_buybox, ships\_from, delivery\_info |
| `seller_profile` | seller IDs | seller\_name, rating, rating\_count, positive\_feedback\_pct, business\_name, business\_address |
| `bestseller` | bestsellers data type | rank, asin, title, price |
| `new_release` | newReleases data type | rank, asin, title, price |
| `deal` | deals data type | asin, title, price, original\_price, discount\_percent |

Error rows carry an `error_code` (NOT\_FOUND, UPSTREAM\_BLOCKED, INVALID\_URL, UNSUPPORTED\_TYPE, INTERNAL\_ERROR) and are **free** - you only pay for real results.

#### Example output row

A real search-result row:

```json
{
  "query": "wireless earbuds",
  "row_type": "search_result",
  "asin": "B0CHX1W1XY",
  "title": "Wireless Earbuds Bluetooth 5.3 Headphones",
  "price": "39.99 USD",
  "original_price": "59.99 USD",
  "rating": 4.4,
  "review_count": 12834,
  "brand": "Acme",
  "is_prime": true,
  "url": "https://www.amazon.com/dp/B0CHX1W1XY",
  "image_url": "https://m.media-amazon.com/images/I/61abc.jpg",
  "country": "us",
  "seller_id": null,
  "rank": null,
  "discount_percent": 33,
  "data": { "...": "full listing object" }
}
```

Console columns include `asin`, `title`, `price`, `original_price`, `rating`, `review_count`, `is_prime`, `url` for products; `price`, `condition`, `seller_name`, `seller_rating`, `is_buybox`, `ships_from`, `delivery_info` for offers; and `seller_id`, `seller_name`, `rating`, `rating_count`, `positive_feedback_pct`, `business_name`, `business_address` on the Sellers tab. A run-summary record (`OUTPUT` key) reports per-surface counts and the estimated cost. Live per-event pricing is shown on this Actor's Apify Store page.

### Use cases

- **Repricing and Buy Box** - pull every offer on an ASIN to see who holds the Buy Box, at what price, in what condition.
- **Catalog and price monitoring** - track title, price, list price and rating across a keyword or category on a schedule.
- **Deal and discount tracking** - watch today's deals, coupons and lightning deals by department and minimum discount %.
- **Market and trend research** - snapshot best sellers and new releases per category across 8 marketplaces.
- **Seller intelligence** - build merchant profiles with rating, feedback % and disclosed business name and address.

### FAQ

**Is scraping Amazon legal?**
This Actor reads only publicly visible Amazon pages - the same product, offer and best-seller pages any shopper can open in a browser. It collects no personal or private data. You are responsible for using the output in line with Amazon's terms and the laws that apply to you; price monitoring and market research on public data are common, legitimate uses.

**How fresh is the data?**
Every row is fetched live from Amazon on each run, so there is no stale cache. Schedule the Actor to re-pull as often as you need.

**What happens when an ASIN is dead or blocked?**
That single input yields a free diagnostic row with an `error_code` (for example NOT\_FOUND or UPSTREAM\_BLOCKED) and the run keeps going through the rest of your inputs. You are never charged for error rows. Set `stopOnError: true` only if you want the whole run to abort on the first failure.

**Which marketplaces are supported?**
8 of them - United States (us), United Kingdom (uk), Germany (de), France (fr), Italy (it), Spain (es), Canada (ca) and Japan (jp). Set `country` per run.

**How many results can I get per run?**
Set `maxResultsPerType` from 1 to 1000 per surface / input item. Search paginates Amazon under the hood to reach your cap; 20 is a quick sample, 100 a solid dataset.

**Can I schedule recurring runs?**
Yes. Use Apify Schedules to run the Actor on any cron interval and append to a dataset or push to your webhook, database or storage.

**Do I need customer reviews too?**
This Actor covers product, offer, seller and deal data. For customer-review extraction, pair it with the Amazon Reviews Actor below.

### Related actors

Part of the Data Forge Amazon suite:

- **[Amazon Reviews Scraper](https://apify.com/jdtpnjtp/amazon-reviews)** - deep customer-review samples for any ASIN, with rating, text, date and verified-purchase flags.
- **[Amazon Scraper](https://apify.com/jdtpnjtp/amazon)** - the all-in-one umbrella Actor across the full Amazon data set.
- **[Walmart Product Scraper](https://apify.com/jdtpnjtp/walmart-product-scraper)** - the same structured-product approach for Walmart catalogs.

### Support

I personally support every customer - drop a message on any channel.

[![Telegram](https://img.shields.io/badge/Telegram-2CA5E0?style=for-the-badge\&logo=telegram\&logoColor=white)](https://t.me/j4dtpnj2tp)
[![WhatsApp](https://img.shields.io/badge/WhatsApp-25D366?style=for-the-badge\&logo=whatsapp\&logoColor=white)](https://wa.me/380686031542)
[![Email](https://img.shields.io/badge/Email-D14836?style=for-the-badge\&logo=gmail\&logoColor=white)](mailto:jdtpnjtp@gmail.com)

# Actor input Schema

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

Keyword searches (e.g. `wireless earbuds`, `4k monitor`). Each query is paginated up to the per-type cap below. Apply the search filters (sort, price, brand, Prime, condition, rating) in the Search options section. Optional if you provide ASINs / URLs / seller IDs / category IDs.

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

Amazon products by ASIN or product URL (the 10-char code in any /dp/ link, e.g. `B0FQFB8FMG`, or paste the full URL). Each is pulled as a full product detail; when **Offers** is selected, every seller offer for it is pulled too. Optional if you provide search queries / URLs.

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

Amazon merchant IDs (e.g. `A2L77EE7U53NWQ`). Pulled as seller profiles when **Sellers** is selected. Turn on 'Also list each seller's products' to list each seller's catalog too.

## `categoryNodeIds` (type: `array`):

Amazon category node IDs (numeric, e.g. `172282`). Each is browsed page by page up to the per-type cap and returns its product listings. Runs when **Products (search + category)** is selected.

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

Paste any Amazon URL - a product (/dp/), a search results page (/s?k=), a bestseller / new-releases list, a seller page or an offer-listing. Each is auto-detected and parsed into its own row(s), independent of the data types below. (Review URLs are not handled here - use the Amazon Reviews actor.)

## `dataTypes` (type: `array`):

Which Amazon verticals to pull. Each type runs only when you supply matching input (e.g. Offers needs ASINs, Sellers needs Seller IDs). Start URLs always run regardless of this selection.

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

Which Amazon marketplace to scrape.

## `maxResultsPerType` (type: `integer`):

Upper bound on results pulled for EACH vertical / input item (search results per query, products per category, offers per ASIN, seller products per seller, etc.). 20 = quick sample, 100 = solid dataset. Search paginates Amazon under the hood to reach this number.

## `includeProductDetails` (type: `boolean`):

When on, every product from a search / category / seller-products row is enriched with a second call that pulls its full product page (specs, variations, all images, description, bestseller rank). **This adds a `product-detail` charge per result on top of the listing event.** Leave off for a fast, cheap listing-only run.

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

Order of keyword-search and category-browse results.

## `searchCategoryId` (type: `string`):

Optional Amazon category node ID to restrict keyword searches to a department (different from the Category node IDs input, which browses a category directly).

## `brand` (type: `string`):

Restrict results to one or more brands (comma-separated).

## `minPrice` (type: `integer`):

Minimum price filter (whole units of the marketplace currency).

## `maxPrice` (type: `integer`):

Maximum price filter (whole units of the marketplace currency).

## `minRating` (type: `string`):

Keep only products at or above this average review. Amazon's SERP exposes only a '4 stars & up' facet, so values >= 4 apply it; lower values are not applied.

## `isPrime` (type: `boolean`):

Keep only Prime-eligible search results.

## `productCondition` (type: `string`):

Filter search results by item condition.

## `dealsAndDiscounts` (type: `string`):

Restrict keyword-search results to discounted / today's-deal items.

## `includeSellerProducts` (type: `boolean`):

When on, each Seller ID also returns that seller's product catalog (paginated to the per-type cap), each as a `product-result` row.

## `bestsellersCategory` (type: `string`):

Category slug for the bestsellers and new-releases lists (e.g. electronics, books, toys, kitchen).

## `includeNewReleases` (type: `boolean`):

When on, the new-releases list for the same category is pulled alongside the bestsellers list (you can also select 'New releases' in Data types directly).

## `dealsCategory` (type: `string`):

Which deals to pull.

## `dealsDepartmentId` (type: `string`):

Optional Amazon department node ID to scope the deals (e.g. 16333373011).

## `dealsDiscountMin` (type: `integer`):

Keep only deals at or above this discount percentage.

## `dealsIsPrime` (type: `boolean`):

Keep only Prime-exclusive deals.

## `stopOnError` (type: `boolean`):

If on, the run aborts as soon as one vertical / URL fails (e.g. UPSTREAM\_BLOCKED). If off (default), the failure is logged with a free diagnostic row and the run continues.

## Actor input object example

```json
{
  "searchQueries": [
    "wireless earbuds"
  ],
  "asins": [
    "B0FQFB8FMG"
  ],
  "sellerIds": [],
  "categoryNodeIds": [],
  "startUrls": [],
  "dataTypes": [
    "search",
    "product"
  ],
  "country": "us",
  "maxResultsPerType": 20,
  "includeProductDetails": false,
  "sortBy": "RELEVANCE",
  "minRating": "",
  "isPrime": false,
  "productCondition": "ALL",
  "dealsAndDiscounts": "NONE",
  "includeSellerProducts": false,
  "bestsellersCategory": "electronics",
  "includeNewReleases": false,
  "dealsCategory": "all",
  "dealsIsPrime": false,
  "stopOnError": false
}
```

# Actor output Schema

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

The default dataset. Each row carries one result discriminated by row\_type, with common fields flattened to top-level columns and the full payload under `data`. Use the Overview / Products / Offers / Sellers tabs to view per-vertical tables.

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

A single JSON object written to the default key-value store under the OUTPUT key. Contains per-vertical counts (product\_results, product\_details, offers, seller\_profiles), total\_rows, errors, estimated\_cost\_usd, limit\_reached, and actor\_version.

# 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 earbuds"
    ],
    "asins": [
        "B0FQFB8FMG"
    ],
    "sellerIds": [],
    "categoryNodeIds": [],
    "startUrls": [],
    "dataTypes": [
        "search",
        "product"
    ],
    "maxResultsPerType": 20,
    "bestsellersCategory": "electronics"
};

// Run the Actor and wait for it to finish
const run = await client.actor("jdtpnjtp/amazon-products").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 earbuds"],
    "asins": ["B0FQFB8FMG"],
    "sellerIds": [],
    "categoryNodeIds": [],
    "startUrls": [],
    "dataTypes": [
        "search",
        "product",
    ],
    "maxResultsPerType": 20,
    "bestsellersCategory": "electronics",
}

# Run the Actor and wait for it to finish
run = client.actor("jdtpnjtp/amazon-products").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 earbuds"
  ],
  "asins": [
    "B0FQFB8FMG"
  ],
  "sellerIds": [],
  "categoryNodeIds": [],
  "startUrls": [],
  "dataTypes": [
    "search",
    "product"
  ],
  "maxResultsPerType": 20,
  "bestsellersCategory": "electronics"
}' |
apify call jdtpnjtp/amazon-products --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=jdtpnjtp/amazon-products",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/HGMmddbSHCc2qxpS8/builds/6fvBwX4GqlEgfuLpE/openapi.json
