# Amazon Scraper (`dami_studio/amazon-scraper`) Actor

Amazon scraper for products by ASIN lookup or keyword on seven marketplaces. ASIN rows have the title, price, rating, review count, brand, availability, bullets, image gallery and on-page reviews; search rows the listing tile. Prices in the marketplace's own currency. $0.75 per 1,000 products.

- **URL**: https://apify.com/dami_studio/amazon-scraper.md
- **Developed by:** [Dami's Studio](https://apify.com/dami_studio) (community)
- **Categories:** E-commerce, Integrations, Lead generation
- **Features:** Limited permissions
- **Stats:** 15 total users, 2 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.72 / 1,000 products

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
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 for product data by ASIN, product link or keyword, on 21 Amazon stores**: give it ASINs or
product links and each one comes back as a full product row: price, list price, rating, Best Sellers
Rank, "bought in past month", seller, variants, specs, images and the reviews printed on the page.
Give it search terms or a results link and it walks the result pages instead.

The part worth knowing before you plan around it: the two modes do not return the same row. An ASIN
row is the full product page. A search row carries no seller, no specs, no
reviews and no gallery. And the reviews on an ASIN row are only the handful on the page, usually 8 to 13, not the whole review history.

| | |
|---|---|
| **Input** | ASINs, product links, search queries, Amazon results links or Best Sellers pages |
| **Output** | One row per product: price and list price as text and as numbers, rating, review count, Best Sellers Rank, monthly sales floor, seller, variants, specs, images and on-page reviews (search rows carry less) |
| **Ceiling** | 1,000 products per search query, about 20 result pages |
| **Account needed** | None |
| **Price** | $0.75 per 1,000 products on the Free plan, a little less on paid plans. The free plan's $5 a month covers about 6,600 |

### 🔍 What Amazon Scraper does

Two modes, and you can run both in the same job. `asins` and `productUrls` fetch product pages.
`searchQueries` and `searchUrls` page through Amazon's own results until they have as many as you
asked for or the results run out.

Pick a store in `domain`; a link carries its own store, so one run can mix the US, the UK and Japan. Prices come in each store's currency unless you pick another in `currency`.

Every price, rating and count comes twice: as the page prints it (`price` is `"$49.99"`) and as a
number (`priceValue` is `49.99`). Searches can be sorted and filtered by price and stars.

Optional add-ons, off by default, read one more page per product: variants as their own rows, variant
prices, the product page behind each search result, other sellers' offers and the seller's page.

### 📋 What data you get from each Amazon product

| What you get | Field |
|---|---|
| ASIN, link and title | `asin`, `url`, `title`, `resolvedAsin`, `parentAsin` |
| Price as printed and as a number, list price, discount, unit price, Subscribe & Save price, coupon | `price`, `priceValue`, `currency`, `listPrice`, `listPriceValue`, `discountPercent`, `unitPrice`, `subscribeAndSavePrice`, `coupon` |
| Rating and review count as printed and as numbers, share of each star | `rating`, `ratingValue`, `reviewCount`, `reviewCountValue`, `starBreakdown` |
| "Bought in past month" and the sales floor it gives | `boughtPastMonth`, `boughtPastMonthValue`, `salesFloorMonthly`, `revenueFloorMonthly` |
| Best Sellers Rank in every category, category path | `bestSellersRank`, `categoryPath` |
| Seller, who ships it, other sellers' offers (ASIN rows) | `sellerName`, `sellerId`, `sellerUrl`, `shipsFrom`, `fulfilledByAmazon`, `otherOffersCount`, `otherOffersLowestPrice` |
| Stock, delivery date and cost, where the page was read for | `availability`, `inStock`, `stockLeft`, `deliveryDate`, `shippingCost`, `deliverTo` |
| Variants with their attributes (ASIN rows) | `variants` |
| Brand, specs, model number, manufacturer, bullets, description, A+ text and images, brand story, what's in the box (ASIN rows) | `brand`, `specs`, `modelNumber`, `manufacturer`, `featureBullets`, `description`, `aplusText`, `aplusImages`, `brandStory`, `whatsInTheBox`, `importantInformation` |
| Badges, sustainability labels, condition, return policy, brand store link | `badges`, `sustainability`, `condition`, `returnPolicy`, `brandStoreUrl` |
| Images and product video links | `images`, `imageLarge` (search rows), `videos`, `videoCount` |
| The reviews printed on the page, Amazon's "Customers say" summary and its topic tags (ASIN rows) | `reviews`, `reviewsParsed`, `customersSay`, `customersSayAspects`, `reviewsUrl`, `hasReviews` |
| Related products from the page's own carousels (ASIN rows) | `relatedAsins` |
| Search position, sponsored flag, other colors and sizes hint (search rows) | `page`, `positionOnPage`, `position`, `sponsored`, `variantHint` |
| Rank and category on a Best Sellers page | `rank`, `categoryName`, `categoryPath`, `listType` |
| Add-ons: variant prices, the product page behind a search row, other offers, seller page, the ASIN a variant row came from | `variants[].price`, `detail`, `offers`, `sellerDetails`, `variantOf` |
| Row kind, store, what you asked for, when it was read | `type`, `query`, `store`, `input`, `scrapedAt` |

### ▶️ How to scrape Amazon products

1. Open [Amazon Scraper](https://apify.com/dami_studio/amazon-scraper) and click **Try for free**.
2. Paste ASINs into **ASINs**, links into **Product links**, terms into **Search queries**, or a
   results page into **Amazon results links**.
3. Pick your **Amazon marketplace**.
4. Set **Max items** for searches, and any sort or filter you want. 20 is enough while you look at
   the row shape.
5. Click **Start**, then download the dataset as JSON, CSV or Excel.

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

**$0.75 per 1,000 products** on the Free plan. Paid plans pay a little less: $0.74 on Starter, $0.73 on Scale and $0.72 on Business. On the free plan, the $5
Apify gives you each month covers about 6,600 products.

You pay per product row, whichever input it came from. Diagnostic rows are not billed, results left
out by a filter are not billed, and a dead ASIN or a query that matches nothing produces no product
rows to bill for. If you set a maximum cost for the run, it stops there.

An out-of-stock product is a complete row apart from the price, so it counts. A repeated ASIN counts
each time unless you turn on **Skip repeated products**, and a product found by two searches counts
twice.

The optional add-ons are free until 9 November 2026. From that day they cost, on the Free plan, with paid
plans paying a little less:

| Add-on | Price |
|---|---|
| `variantPrices` | $5.00 per 1,000 variants |
| `searchDetails` | $5.00 per 1,000 product pages |
| `includeOffers` | $0.40 per 1,000 offers |
| `includeSellerDetails` | $5.00 per 1,000 sellers |
| `deliveryZip`, `deliveryCountry` | $0.005 a run |

### 📥 What you give it

```json
{
  "asins": ["B0BS1PRC4L"],
  "productUrls": ["https://www.amazon.co.uk/dp/B0833NW6SN"],
  "searchQueries": ["wireless earbuds"],
  "domain": "com",
  "maxItems": 50,
  "sort": "price-low-to-high",
  "minRating": "4"
}
```

| Field | Default | What it is |
|---|---|---|
| `asins` | none | Ten-character product ids. Find one in any product URL after `/dp/`. |
| `productUrls` | none | Product links copied from Amazon. The store comes from each link. |
| `searchQueries` | none | Search terms, as you would type them into Amazon's own box. |
| `searchUrls` | none | A results page with your filters set, a department page, or a Best Sellers, New Releases, Movers & Shakers or Most Wished For page. |
| `domain` | `com` | Which store for ASINs and search terms. 21 of them, from `com` to `ie`. |
| `language` | none | Ask for the pages in another language, such as German on `de`. |
| `currency` | none | Ask for prices in another currency, on stores that convert. |
| `maxItems` | `50` | Products per search, results link or list, 1 to 1,000. Ignored for ASINs. This is your spend cap. |
| `maxPages` | `20` | Result pages per search at most. |
| `maxTotalItems` | none | One cap for all searches, results links and lists together. |
| `skipDuplicateAsins` | `false` | Read and charge a repeated ASIN or product link once. |
| `sort` | `relevance` | Search order: price either way, reviews, newest or best selling. Sorted by price, low to high, the listings Amazon shows out of price order (mostly ones you can't buy right now) are skipped and not charged. |
| `minPrice`, `maxPrice` | none | Price range, in the store's currency. Results with no price are left out when set. |
| `minRating` | none | Only results with at least 4, 3, 2 or 1 stars. |
| `excludeSponsored` | `false` | Leave out sponsored results. |
| `includeVariants` | `false` | Also read each product's other colours and sizes as product rows. |
| `variantPrices` | `false` | Optional add-on: each variant's price and stock in the parent row. |
| `maxVariantsPerProduct` | `10` | Variants read per product by the two options above. |
| `searchDetails` | `false` | Optional add-on: the full product page behind every search row, as `detail`. |
| `includeOffers` | `false` | Optional add-on: other sellers' offers on each product. |
| `includeSellerDetails` | `false` | Optional add-on: the buy-box seller's own page, once per seller. |
| `deliveryZip`, `deliveryCountry` | none | Optional add-on: read the chosen store for this postcode or country, so prices and delivery are local. |
| `notionConnector`, `notionParentId` | none | Optional. Write each product into your Notion as well as the dataset. |
| `proxyConfiguration` | leave it alone | Leave it alone unless the run has to leave through servers of your own. |

Fill in at least one of the four inputs. An empty run, a link from a store this does not read, or a
minimum price above the maximum writes a free `BAD_INPUT` row instead.

### 📤 What you get back

A real ASIN row from a test run on 24 October 2026, cut short so the block stays readable:

```json
{
  "ok": true,
  "type": "product",
  "asin": "B0CRTR3PMF",
  "url": "https://www.amazon.com/dp/B0CRTR3PMF",
  "title": "Soundcore P30i by Anker Noise Cancelling Earbuds, Hands-Free Viewing",
  "price": "$49.99",
  "currency": "USD",
  "rating": "4.3",
  "reviewCount": "(45,213)",
  "brand": "Visit the Soundcore Store",
  "availability": "In Stock",
  "featureBullets": ["Strong and Smart Noise Cancelling: Reduce noise by up to 42dB...", "..."],
  "images": ["https://m.media-amazon.com/images/I/51013C6va8L._AC_SL1500_.jpg", "..."],
  "reviews": [{ "rating": "5", "title": "AWESOME!", "verifiedPurchase": true, "body": "This is a great pair of earbuds!..." }],
  "reviewsParsed": 13,
  "priceValue": 49.99,
  "ratingValue": 4.3,
  "reviewCountValue": 45213,
  "starBreakdown": { "1": 7, "2": 4, "3": 7, "4": 12, "5": 70 },
  "boughtPastMonth": "10K+ bought in past month",
  "boughtPastMonthValue": 10000,
  "salesFloorMonthly": 10000,
  "revenueFloorMonthly": 499900,
  "bestSellersRank": [
    { "rank": 23, "category": "Electronics", "url": "https://www.amazon.com/gp/bestsellers/electronics/ref=pd_zg_ts_electronics" },
    { "rank": 4, "category": "Earbud & In-Ear Headphones", "url": "https://www.amazon.com/gp/bestsellers/electronics/12097478011/ref=pd_zg_hrsr_electronics" }
  ],
  "categoryPath": ["Electronics", "Headphones, Earbuds & Accessories", "Headphones & Earbuds", "Earbud Headphones"],
  "parentAsin": "B0D5QS3L86",
  "variants": [{ "asin": "B0CRTPF7CZ", "attributes": { "Color": "Blue" } }, "..."],
  "sellerName": "AnkerDirect",
  "sellerId": "A294P4X9EWVXLJ",
  "shipsFrom": "Amazon",
  "fulfilledByAmazon": true,
  "deliveryDate": "Thursday, October 29",
  "shippingCost": "FREE",
  "inStock": true,
  "modelNumber": "A3959",
  "manufacturer": "Anker",
  "store": "amazon.com",
  "input": "B0CRTR3PMF",
  "scrapedAt": "2026-10-24T22:43:10.265Z"
}
```

| Field | How to read it |
|---|---|
| `type` | `product` for an ASIN or product link, `search` for a search or results link, `bestsellers` for a Best Sellers style page. |
| `price` | The buy-box price, symbol included. `null` when out of stock, not deliverable to the location the page was read for, or only "See All Buying Options". |
| `currency` | The store's currency code, or the one you asked for when the price shows it. |
| `boughtPastMonthValue`, `salesFloorMonthly` | Amazon prints a floor ("10K+"), so this is "at least", not an estimate. `revenueFloorMonthly` is that floor times today's price. |
| `position` | Place in the results counted across pages, sponsored tiles included, before repeats and filters. |
| `customersSay` | Amazon's own summary of its reviews, word for word, with `customersSayAspects` its topic tags and mention counts. |
| `deliverTo` | The location Amazon read the page for. `null` when none was set. |

### 🧾 Reading the output

Two kinds of row land in the dataset, and only the first kind is billed. There is no sample row.

| Row | How to spot it | Billed |
|---|---|---|
| A product | `ok: true` and an `asin` | yes |
| A diagnostic | `ok: false` and an `errorCode` | no |

Filter on `ok == true`, then split on `type` if you used more than one input.

| Code | What it means |
|---|---|
| `BAD_INPUT` | Nothing to read, a link this does not read, or an option it cannot apply. Nothing was fetched for it. |
| `NOT_FOUND` | Amazon has no page for that ASIN or that Best Sellers style link. With an ASIN it is usually a typo or a delisted product. |
| `NO_RESULTS` | The query ran and matched nothing, or nothing it read matched your filters. |
| `NOT_SERVED` | This product, search or list was not served this run. Re-run it later. Runs before 13 October 2026 wrote `BLOCKED` here, and runs from 13 to 18 October wrote `NETWORK`. |
| `RATE_LIMITED` | Too much traffic on that page just now. Try again shortly. |
| `NETWORK`, `SERVER_ERROR` | Amazon was unreachable or answered badly. Re-run it. |
| `TIME_LIMIT` | The run got close to its time limit and stopped early. Every product delivered before that is in your dataset; give the run more time, or ask for fewer products. If none came back at all, the run still ends as succeeded, with an amber status message. |
| `UNEXPECTED_ERROR` | The run stopped early on an unexpected error. The results before this row are kept. |

A search that returned some products and then stopped early writes both: the products it collected,
which are charged, and one uncharged diagnostic saying how far it got. Apart from that time-limit
case, the run finishes green even when items fail, so judge it by rows rather than by status.

### 💡 What people use it for

- Watching the price, stock and Best Sellers Rank of a list of ASINs on a schedule.
- Seeing who ranks for a keyword, and at which position.
- Sizing a niche from the "bought in past month" floors of the products that rank.
- Comparing one ASIN's price on the UK, German and US stores in one run.

From a keyword to the products worth a closer look, in three runs:

1. Run [Keyword Autocomplete Scraper](https://apify.com/dami_studio/keyword-autocomplete-scraper)
   with your term in `seeds` and `engines` set to `amazon`, to see what shoppers actually type.
2. Search the best phrases here, sorted by best selling, and keep the tiles' `asin`.
3. Run those ASINs here for the full page, then send the best ones to
   [Amazon Reviews Scraper](https://apify.com/dami_studio/amazon-reviews-scraper).

### 🚧 What it does not do

- **Search rows are thin.** No seller, specs, reviews or gallery. Take the ASINs from search mode and
  run them through ASIN mode when you need the detail.
- **Only the reviews on the page.** Roughly 8 to 13 per product.
- **No sales estimates.** `salesFloorMonthly` is Amazon's own "bought in past month" floor, not a model.
- **No Prime flag and no Prime filter.**
- **A run can finish green with nothing useful in it.** Check the row count, not the status.
- It is not an official Amazon tool. Dami's Studio is independent and is not affiliated with or endorsed by Amazon, or by any other company named on this page.

### 🧭 Which Amazon scraper do you need?

| If you want | Use |
|---|---|
| Amazon products by keyword, ASIN or link, with the on-page reviews | This one |
| The reviews on an Amazon product page, as one row each | [Amazon Reviews Scraper](https://apify.com/dami_studio/amazon-reviews-scraper) |
| The Best Sellers, New Releases or Movers & Shakers ranking for a category, by name | [Amazon Bestsellers Scraper](https://apify.com/dami_studio/amazon-bestsellers-scraper) |
| What shoppers type into Amazon's search box | [Keyword Autocomplete Scraper](https://apify.com/dami_studio/keyword-autocomplete-scraper) |
| Search results with prices and order counts on AliExpress | [AliExpress Products Scraper](https://apify.com/dami_studio/aliexpress-products-scraper) |
| Keyword numbers, rank tracking and reverse ASIN on Amazon | [Amazon Keyword Research](https://apify.com/dami_studio/amazon-keyword-research-scraper) |
| The same keyword search on Naver Shopping, for products sold in Korea | [Naver Shopping Scraper](https://apify.com/dami_studio/naver-shopping-scraper) |

### ❓ Questions people ask

#### Do I need an Amazon account or an API key?

Neither. Nothing to register and nothing that expires.

#### Why is the price empty on some Amazon rows?

Out of stock, not deliverable where the page was read for, a
"see price in cart" item, or only "See All Buying Options". The price of a different product shown elsewhere on the page is never used.

#### Are the search results the same as what I see?

Close. Treat a search
run as a snapshot, and if a field looks off, open the page in a private browser window: that is the
view this reads.

#### Can I call it from code or connect it to an AI assistant?

The [API tab](https://apify.com/dami_studio/amazon-scraper/api/python) has code for Python, JavaScript and the CLI.
MCP clients like Claude and ChatGPT use `https://mcp.apify.com/?tools=fetch-actor-details,dami_studio/amazon-scraper`;
coding assistants can load [our skill
file](https://api.apify.com/v2/key-value-stores/BTBHU3DdiuoF4JOsK/records/apify-ecommerce-SKILL.md). All three bill
your Apify account at the same price.

#### Is scraping Amazon legal?

This reads public product pages, the same ones any shopper sees. Reviews are personal data under
GDPR and similar laws, so have a reason for keeping them. Seller details carry the business name,
address and phone a seller's page prints; for a sole trader that is personal data under GDPR and
Canada's PIPEDA, and anti-spam laws limit contacting anyone with it. Amazon's own terms still apply
to what you do with the data. Apify's write-up on
[the legality of web scraping](https://blog.apify.com/is-web-scraping-legal/) is a good starting
point, and we are not lawyers.

### 🆘 If something breaks

Open the **Issues** tab on the actor page. Send the ASIN, link or query and the run ID; the log
usually shows what the page did.

# Actor input Schema

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

List of Amazon ASINs (10-character product IDs, e.g. B0BS1PRC4L) to scrape. Each ASIN returns full product details (including hi-res images) plus the on-page top customer reviews. Individual fields (price, rating, reviewCount, brand, availability, images, reviews) can be null/empty when they are not on the page. Find the ASIN in a product URL: amazon.com/dp/{ASIN}. Leave empty if you only want search results.

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

Optional. Product links copied from Amazon (amazon.com/dp/{ASIN}, /gp/product/{ASIN} and the like). The store comes from each link, so one run can mix countries; every link is read like an ASIN and billed the same way. A link to a store this actor does not read gets a free row saying so.

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

List of search terms (e.g. "wireless earbuds", "4k monitor") to scrape from Amazon search result pages. Each query returns products with asin, title, price, rating, reviewCount, url and an images array, paginated until maxItems is reached. Note: search-mode images contain only a small (~200px) thumbnail URL, product/ASIN mode returns hi-res images. Fields like price, rating and reviewCount can be null when a listing omits them. Leave empty if you only want product details by ASIN.

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

Optional. Paste a results page from Amazon with your filters already set (a search, a department, a filtered category), or a Best Sellers, New Releases, Movers & Shakers or Most Wished For page. Results links are paged like a search, up to Max items each. A Best Sellers style page gives up to 60 ranked products with their rank and category. Each row is billed like a search row.

## `domain` (type: `string`):

Which Amazon marketplace (TLD) to scrape. Prices come back in that marketplace's own currency and language.

## `language` (type: `string`):

Optional. Ask Amazon for its pages in this language, where the store offers it (for example German on amazon.de, or English on a store that defaults to another language). Leave empty for the pages this actor normally reads. Titles, bullets and labels come back in the language Amazon serves.

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

Optional. Ask Amazon to show prices in this currency, on stores that convert. Where a store does not convert, prices stay in its own currency and the currency column says so. Leave empty for the store's own currency.

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

Maximum number of search result products to return per search query. The actor paginates through ?page=N until this many products are collected or the results run out. Ignored in ASIN-only mode.

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

Optional. Stop each search or results link after this many result pages, even if Max items has not been reached. Amazon shows at most about 20.

## `maxTotalItems` (type: `integer`):

Optional. One cap across all searches, results links and list pages together. Leave empty for no run-wide cap (each search still stops at Max items). Product rows from ASINs and product links do not count against it.

## `skipDuplicateAsins` (type: `boolean`):

Optional. When the same product appears more than once in your ASINs and product links (same store), read and charge it once. Off by default, so every entry still gets its own row in order.

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

Optional. The order Amazon returns search results in. Relevance is Amazon's default order.

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

Optional. Only results at or above this price, in the store's currency (whole units, e.g. 20). Results with no price shown are left out when a price filter is set.

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

Optional. Only results at or below this price, in the store's currency.

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

Optional. Only results rated at least this many stars. Results with no rating yet are left out when this is set.

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

Optional. Drop results Amazon marks as sponsored. They are not charged.

## `includeVariants` (type: `boolean`):

Optional. For each ASIN or product link, also read its other variants (colours, sizes) as their own product rows, up to Max variants per product. Each variant row is a product row like any other and is billed the same way. Rows carry variantOf, the ASIN they were found from.

## `variantPrices` (type: `boolean`):

Optional add-on. Read each variant's own page and put its price and stock inside the parent row's variants list, up to Max variants per product.

## `maxVariantsPerProduct` (type: `integer`):

How many variants of one product the two options above read at most.

## `searchDetails` (type: `boolean`):

Optional add-on. For every search or results-link row, also read the product page and add it to the row as detail: seller, specs, bullets, gallery, Best Sellers Rank, reviews on the page and the rest of an ASIN row.

## `includeOffers` (type: `boolean`):

Optional add-on. For each ASIN or product link, read the list of offers from other sellers: price, condition, seller and who ships it.

## `includeSellerDetails` (type: `boolean`):

Optional add-on. Read the buy-box seller's own page once per seller: rating, number of ratings, and the business details the page prints.

## `deliveryZip` (type: `string`):

Optional add-on. Read the chosen store's pages for this postcode (for example 10001 on amazon.com), so price, delivery and stock are what a shopper there sees. It applies to ASINs, searches and links on the store picked above; links to other stores are read as usual. If Amazon does not take the postcode, the run returns a free row saying so and reads nothing for that store.

## `deliveryCountry` (type: `string`):

Optional add-on, instead of a postcode. Read the chosen store's pages as delivered to this country, where the store ships abroad. Two-letter code, for example CA or DE.

## `notionConnector` (type: `string`):

Optional. Write each product as a page into your Notion when the run finishes. Authorize a Notion connector once in Settings → API & Integrations → MCP connectors, then pick it here. Leave empty to skip (default), results are always saved to the dataset regardless.

## `notionParentId` (type: `string`):

Optional. The Notion data source ID of the database to write into (only used if a Notion connector is set). Leave empty to create the pages privately in your workspace instead.

## `proxyConfiguration` (type: `object`):

Optional. Leave this alone unless you need the run to go out through a particular network. Your own proxy servers are used exactly as given.

## Actor input object example

```json
{
  "asins": [
    "B0BS1PRC4L"
  ],
  "searchQueries": [
    "wireless earbuds"
  ],
  "domain": "com",
  "maxItems": 50,
  "maxPages": 20,
  "skipDuplicateAsins": false,
  "sort": "relevance",
  "excludeSponsored": false,
  "includeVariants": false,
  "variantPrices": false,
  "maxVariantsPerProduct": 10,
  "searchDetails": false,
  "includeOffers": false,
  "includeSellerDetails": false
}
```

# Actor output Schema

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

Scraped rows are stored in the default dataset (one row per result). Empty or failed runs return a single uncharged diagnostic row instead.

# 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 = {
    "asins": [
        "B0BS1PRC4L"
    ],
    "searchQueries": [
        "wireless earbuds"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("dami_studio/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 = {
    "asins": ["B0BS1PRC4L"],
    "searchQueries": ["wireless earbuds"],
}

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

```

## MCP server setup

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