# Amazon Product Scraper: Prices by ZIP Code, Full Search (`alexmorain/amazon-product-scraper`) Actor

Scrape Amazon.com and Amazon.de products from searches, categories, URLs or ASINs: price, delivery for your ZIP code at no extra cost, seller, rating, bought past month, best sellers rank, AI review summary. Full coverage reads past the 7-page limit. No login, no browser.

- **URL**: https://apify.com/alexmorain/amazon-product-scraper.md
- **Developed by:** [Alexis Morain](https://apify.com/alexmorain) (community)
- **Categories:** E-commerce, Marketing, Automation
- **Features:** Limited permissions
- **Stats:** 1 total users, 1 monthly users, 91.7% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.40 / 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 Product Scraper: prices by ZIP code, the whole search, no 7-page limit

Amazon Product Scraper exports **Amazon products** from search terms, category pages, product URLs or ASINs on amazon.com and amazon.de: price, list price, availability, delivery date and price, seller, rating, ratings count, bought past month, best sellers rank, and from the product page the star histogram, **Amazon's AI review summary**, review aspects, variants and images. It works as an **Amazon product API** without a login, an API key or a browser, and the results land in a dataset you can export as JSON, CSV, Excel or HTML, or read through the Apify API from Python, JavaScript or cURL.

Two things set it apart.

**Prices and delivery for your ZIP code, at no extra cost.** Amazon shows prices, stock and delivery dates for one delivery location. Set `zipCode` (New York 10001 by default) and every row says the location Amazon actually applied in `deliverTo`. If Amazon refuses the ZIP code, the run fails instead of returning prices for another place. The delivery location is part of the product price, not an add-on.

**The whole search, not the first 7 pages.** Amazon stops every search at 7 pages, about 300 products, whatever number of results it announces. Turn on **Full coverage** and the search is split into price bands, each with its own 7 pages, and bands that are still full are split again.

#### How to scrape more than 300 products from an Amazon search

| `coffee maker` on amazon.com, 26 and 27 Oct 2026 | Unique products | Cost on the platform |
|---|---|---|
| Plain pagination (what a search-page scraper returns) | 281 | |
| Full coverage, stopped by a 40-minute timeout (run `YlKyMjCUftFHgjezg`) | 113,802 | $0.70 |

Zero duplicates in the 113,802 rows: a product found in two price bands is pushed and charged once. Amazon announces "over 40,000 results" for this search and attaches a long tail to it: carafes, filters, mugs, moka pots and spare parts come back too. That is what Amazon files under the query, not noise added by the scraper, so set **Max products per search** if you only want the head of the list. A second full coverage test on `french press` returned 458 products (run `20GZqSUfEOukh0MN6`).

### Why use an Amazon product scraper

- **Price monitoring and repricing.** Track your products and your competitors' by ASIN, with the buy box seller, the list price and stock. Schedule the run daily and compare the datasets.
- **Market and category research.** Read a whole category or search with Full coverage, then sort by `boughtPastMonth`, `ratingsCount` or price band to size a niche or find gaps.
- **Regional pricing and delivery checks.** Run the same ASINs under several ZIP codes (`10001`, `99501`, `90210`) and see where delivery is slower or the product is out of stock. In a test on 27 October 2026, `deliverTo` and the fastest delivery changed between 99501 and 10001 (runs `IPcHiQ7xlUSS3q5LD` and `srT9ZETnUgjC8gMOw`).
- **Review insight without signing in.** The AI review summary, the aspects customers mention (each with positive and negative counts) and the star histogram come with every product page. On amazon.de you also get the reviews shown on the page, up to about 13 per product, each with its date, country, verified purchase flag, helpful votes and photos.

What you get on top of the data:

- One row per unique product per search, so sponsored results seen on several pages are never charged twice.
- A SUMMARY record per input: status, products returned, pages read, price bands.
- A run that fails with a clear message when nothing could be read, instead of an empty success.
- Apify scheduling, API access, integrations and webhooks.

### How to scrape Amazon products, step by step

1. Open the Input tab and type a search term, for example `coffee maker`, or paste product URLs, ASINs or a category URL.
2. Choose the marketplace (amazon.com or amazon.de) and, if you want, a delivery ZIP code.
3. Set **Max products per search**, and turn on **Full coverage** to go past 7 pages.
4. Press **Start**, then download the results from the Output tab as JSON, CSV, Excel or HTML, or read them through the API.

#### What you can feed it

- **Search terms**: one per line, as typed in the Amazon search box.
- **Product URLs or ASINs**: one per line, each product page read in full. A product that no longer exists is reported in the log and not charged.
- **Category or search result URLs**: a category page or a search URL with its filters. The marketplace is read from the URL. Best sellers pages are not supported.
- **Marketplace**: amazon.com or amazon.de, for search terms and bare ASINs.
- **Delivery ZIP code**: empty means New York 10001 on amazon.com and Berlin 10115 on amazon.de.
- **Include product page details**: also read the product page of each search result.
- **Include sponsored results**: on by default, sponsored rows are flagged `sponsored`; turn off to keep organic results only.

```json
{
    "searchQueries": ["coffee maker"],
    "productUrls": ["https://www.amazon.com/dp/B07S98411N", "B00005NCWQ"],
    "marketplace": "com",
    "zipCode": "90210",
    "maxItemsPerSearch": 500,
    "fullCoverage": true,
    "includeDetails": false
}
```

### What data does the Amazon scraper extract?

Search rows carry the fields of the search result page. With **Include product page details**, or when you read ASINs and product URLs, the product page fields are added. The full list, from the dataset schema:

| Field | Type | Description |
|---|---|---|
| `input` | string | What you entered: the search term, URL or ASIN this row comes from |
| `asin` | string | Amazon product ID (ASIN) of the page served |
| `requestedAsin` | string | ASIN you asked for, only when Amazon served another one (old ASIN redirected to its successor) |
| `parentAsin` | string | Parent ASIN grouping the variants of the product |
| `url` | string | Product page |
| `marketplace` | string | Amazon marketplace |
| `searchQuery` | string | Search term, for rows from a search |
| `page` | integer | Search result page the product was found on |
| `positionOnPage` | integer | Position on that page, sponsored results included |
| `position` | integer | Position in the plain 7-page results (null for products found in a price band) |
| `priceBand` | string | Price band in which Full coverage found the product (null in the plain 7 pages) |
| `title` | string | Product title |
| `brand` | string | Brand |
| `authors` | array | Authors, for books |
| `price` | number | Price for the delivery postcode, in the marketplace currency |
| `priceText` | string | Price as displayed |
| `listPrice` | number | List or typical price shown struck through, when higher than the price |
| `currency` | string | Currency of the prices (ISO 4217) |
| `inStock` | boolean | Whether the product can be added to the cart |
| `availability` | string | Availability text |
| `deliverTo` | string | Delivery location Amazon actually applied to this page |
| `delivery` | object | Standard delivery for the postcode: date and price on product pages, text only on search rows |
| `fastestDelivery` | object | Fastest delivery option for the postcode (Prime or paid) |
| `seller` | string | Seller of the buy box offer |
| `sellerId` | string | Amazon merchant ID of the seller |
| `shipsFrom` | string | Who ships the buy box offer |
| `soldByAmazon` | boolean | Sold by Amazon itself |
| `fulfilledByAmazon` | boolean | Shipped by Amazon |
| `rating` | number | Average star rating out of 5 |
| `ratingsCount` | integer | Number of ratings |
| `ratingHistogram` | object | Share of ratings per star, in percent |
| `boughtPastMonth` | integer | Lower bound of "bought in past month" (1K+ gives 1000) |
| `sponsored` | boolean | Sponsored search result |
| `badge` | string | Badge on the search result |
| `badges` | array | Badges on the product page |
| `isPrime` | boolean | Prime logo on the search result |
| `thumbnail` | string | Search result image |
| `bestSellersRank` | array | Best Sellers Rank in each category |
| `categories` | array | Category breadcrumb, broad to narrow |
| `features` | array | "About this item" bullet points |
| `description` | string | Product description |
| `attributes` | object | Product details and technical specifications as label: value |
| `variationAttributes` | array | Dimensions the variants differ on |
| `variants` | array | Variant ASINs with their attribute values |
| `images` | array | Full-size product images |
| `reviewsAiSummary` | string | Amazon's AI-generated summary of the reviews ("Customers say") |
| `reviewAspects` | array | Review aspects Amazon highlights, with mention counts |
| `visibleReviews` | array | Reviews shown on the product page without signing in (none on amazon.com, up to about 13 on amazon.de): id, url, rating, title, text, author, dateText, date (ISO), country, language, verifiedPurchase, isVine, helpfulVotes, variant, images |
| `pageComplete` | boolean | Product page rows: false when Amazon kept serving a lighter page without reviews, histogram or aspects after the actor changed IP twice |
| `detailsStatus` | string | With Include product page details: ok, or why the row has search fields only (blocked, not-found, failed, timeout) |
| `scrapedAt` | string | When the row was read (UTC) |

#### Example: a search row

A real row of a plain search, `espresso machine` on amazon.com (8 November 2026, ZIP code left empty so New York 10001):

```json
{
    "input": "espresso machine",
    "searchQuery": "espresso machine",
    "page": 1,
    "positionOnPage": 1,
    "position": 1,
    "asin": "B00CH9QWOU",
    "title": "Breville BES870XL Barista Express Espresso Machine, Brushed Stainless Steel",
    "url": "https://www.amazon.com/dp/B00CH9QWOU",
    "price": 499.95,
    "listPrice": 699.95,
    "currency": "USD",
    "rating": 4.4,
    "ratingsCount": 28021,
    "boughtPastMonth": 5000,
    "sponsored": false,
    "badge": "Limited time deal",
    "isPrime": false,
    "delivery": {"date": null, "price": null, "text": "Join Prime to get FREE delivery Mon, Nov 9 Or Non-members get FREE delivery Thu, Nov 12"},
    "deliverTo": "New York 10001",
    "marketplace": "amazon.com"
}
```

#### Example: a product page row

One item per product page, values shortened (27 October 2026):

```json
{
    "input": "B07S98411N",
    "asin": "B07S98411N",
    "url": "https://www.amazon.com/dp/B07S98411N",
    "marketplace": "amazon.com",
    "title": "Ninja Fresh Brew Coffee Maker, 12 Cup Glass Carafe, Stainless Steel, CE251",
    "brand": "Ninja",
    "price": 69.99,
    "listPrice": 89.99,
    "currency": "USD",
    "inStock": true,
    "availability": "In Stock",
    "deliverTo": "New York 10001",
    "delivery": {"date": "Saturday, October 31", "price": "FREE", "text": "FREE delivery Saturday, October 31"},
    "fastestDelivery": {"date": "Wednesday, October 28", "price": "FREE", "text": "Or Prime members get FREE delivery Wednesday, October 28"},
    "seller": "Amazon.com",
    "soldByAmazon": true,
    "rating": 4.4,
    "ratingsCount": 29346,
    "ratingHistogram": {"5": 75, "4": 10, "3": 5, "2": 3, "1": 7},
    "badges": ["Amazon's Choice"],
    "bestSellersRank": [{"rank": 471, "category": "Home & Kitchen"}],
    "reviewsAiSummary": "Customers love this coffee maker for its rich brew and great taste, ...",
    "reviewAspects": [{"aspect": "performance", "sentiment": "positive", "mentions": 4139, "positive": 3706, "negative": 433}],
    "variants": [{"asin": "B0H41R5GBG", "attributes": {"Capacity": "14.0 cups"}}]
}
```

A search row found by Full coverage also carries the `priceBand` it was found in. The `SUMMARY` record of the run's key-value store gives one line per input with its status and counts.

### Amazon prices by ZIP code and marketplace

- **ZIP code.** Prices, availability and delivery dates are those Amazon shows for the ZIP code you set. Compare `deliverTo` with the code you asked for: Amazon shortens some locations ("Anchorage 99501"). A code Amazon refuses ends the run in FAILED with a message that names the ZIP code (test with `00000`, run `U2kAloSJxh2o0bjEM`).
- **amazon.de.** Currency is forced to the marketplace's (EUR) and the default ZIP code is Berlin 10115. A test returned 11 rows with price, delivery and best sellers rank (run `vcLkVUj6hRqGWkYSK`). An ASIN that only exists on amazon.com comes back unavailable with a null price. `visibleReviews` carries the reviews shown on the product page without signing in, none on amazon.com. On amazon.de a test of 14 product pages returned all 14 complete, most with 13 reviews, every one with its date and country, including the "top reviews from other countries" block (run `uuvbaqav1K9K2mpz8`, 18 November 2026). The country comes in German, as Amazon writes it ("Deutschland", "Niederlanden").
- **Other marketplaces.** amazon.co.uk, amazon.fr and amazon.co.jp answer search pages with a JavaScript challenge (AWS WAF) that this actor does not run, so they are not offered. A run whose only input is a URL from one of them ends in FAILED with a message that names the URL.

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

You pay per unique product returned, plus a small start fee. The ZIP code and the proxies are included.

| Event | Free | Bronze | Silver | Gold and above |
|---|---|---|---|---|
| Product from a search or category, per 1,000 | $0.75 | $0.65 | $0.55 | $0.40 |
| Detailed product (product page read), per 1,000 | $1.50 | $1.30 | $1.10 | $0.75 |
| Actor start, per GB of memory (1 GB by default) | $0.002 | $0.002 | $0.002 | $0.002 |

A product URL or ASIN is always a detailed product. A search with details on charges each product as a detailed product instead of a product, not both. A product that does not exist is not charged.

Examples: 100 products from a search cost about $0.08 on the Free plan. 1,000 ASINs with full product pages cost $1.50, or $0.75 on Gold. A full coverage run on a broad search is the expensive case: the 113,802 `coffee maker` products above would cost about $85 on the Free plan. Bound it with **Max products per search** or a maximum charge per run: at a $0.10 limit a full coverage run returned 150 products and ended as `partial` with a budget stop reason (run `frBfg6H0ZL6855x1i`), and at $0.01 a run returned 12 products and stopped (run `3xDV5jRESgmKmbCZq`). Without either, one search can run past 100,000 rows, about $100 at the Free price, and the run log says so before it starts.

### Scrape Amazon with Python, JavaScript or cURL

These examples use the actor `alexmorain/amazon-product-scraper`. Replace the token with your own and keep it in an environment variable.

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")

run = client.actor("alexmorain/amazon-product-scraper").call(run_input={
    "searchQueries": ["espresso machine"],
    "zipCode": "90210",
    "maxItemsPerSearch": 200,
})

for product in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(product["asin"], product["price"], product["deliverTo"], product["rating"])
```

#### JavaScript

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });

const run = await client.actor('alexmorain/amazon-product-scraper').call({
    productUrls: ['B07S98411N', 'B00005NCWQ'],
    zipCode: '99501',
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items.map((p) => [p.asin, p.price, p.fastestDelivery]));
```

#### cURL

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/alexmorain~amazon-product-scraper/run-sync-get-dataset-items?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"productUrls": ["B07S98411N"], "zipCode": "10001"}'
```

A synchronous call times out after five minutes: use it for short runs. For a whole search, start the run with `POST /v2/acts/alexmorain~amazon-product-scraper/runs` and read the dataset when it ends.

### Tips and limits, written plainly

- **Full coverage reads priced products only.** Products without a price (unavailable ones) appear only in the first 7 pages, because the bands filter on price.
- **Speed.** Product pages run at about 2.7 per second: 2,500 ASINs took 16 minutes at $0.04 per 1,000 of platform cost in our test (run `fA4gXBIjpKLbjg8UU`). The prefill run (20 products) took 53 to 81 seconds on the latest build. A whole broad search can take hours, so raise the run timeout or cap the products.
- **Stopped early?** When a run hits its timeout or your maximum charge, the products already read are kept and the input is marked `partial` in SUMMARY.
- **Retries.** A request that stays silent is doubled on a free lane, and an Amazon "Continue shopping" checkpoint is passed automatically. Amazon sometimes serves a lighter product page without reviews, histogram or aspects, and the lighter version sticks to the IP: the actor reads it again from another IP, up to twice, at no extra cost to you. If it is still light, the row is delivered with `pageComplete: false` so you can tell a gap from a product without reviews. On 34 amazon.de product pages tested on 18 November 2026, 34 came back complete.
- **No reviews text on amazon.com.** Amazon asks shoppers to sign in to read reviews, and this actor does not sign in. You still get the AI review summary, the aspects with their counts and the star histogram.
- **ASIN redirects.** Amazon redirects an old ASIN to its successor: `asin` carries the ASIN of the page served and `requestedAsin` the one you asked for. Amazon can also serve an unrelated product for an ASIN that does not exist.
- **No monitoring mode.** There is no new-only or price-change watch in this actor. To track prices, schedule the same input and compare datasets.

### Amazon scraper FAQ

#### Can I scrape Amazon prices for a specific ZIP code?

Yes. Set the delivery ZIP code and read `deliverTo` on each row to see the location Amazon applied. It is included in the price of the product.

#### How to scrape more than 7 pages of Amazon search results?

Amazon serves 7 pages per search whatever the number it announces. Turn on **Full coverage**: the search is split into price bands, each with its own 7 pages. `coffee maker` returned 113,802 unique products instead of 281.

#### Can I scrape Amazon best sellers rank?

The `bestSellersRank` field holds the rank in each category for products read from their page. Best sellers list pages are not supported as input.

#### An ASIN returned another product

Amazon redirects an old ASIN to its successor. The row carries the ASIN of the page served in `asin` and the one you asked for in `requestedAsin`.

#### Can I scrape Amazon reviews?

On amazon.de, yes for the reviews Amazon shows on the product page: turn on Include product page details and each product row carries up to about 13 reviews in `visibleReviews`. On amazon.com, Amazon asks shoppers to sign in to read any review, on the product page and on the reviews pages, and this actor does not sign in. You still get the star histogram, the AI review summary and the aspects with their positive and negative counts on both marketplaces.

#### Is it legal to scrape Amazon?

This is not legal advice. This actor reads public product pages and search results, the same pages any shopper sees without signing in. Whether collecting them is allowed depends on what you do with it, where you are and Amazon's terms of use, which limit automated access. Our actors do not extract private user data such as email addresses or gender. Your results could contain personal data, such as reviewer names on amazon.de. Personal data is protected by the GDPR in the European Union and by other regulations around the world. Do not scrape personal data unless you have a legitimate reason, and if you are unsure whether yours is legitimate, consult a lawyer. This actor is not affiliated with or endorsed by Amazon.

### Support

Something wrong or missing? Open an issue on the Issues tab with the run id and the input. If the actor saved you time, a short review helps others find it.

### Guide and use cases

Use cases for outbound and automation, the output fields, pricing and common questions are on the [Amazon Product Scraper page](https://alexis.morain.fr/en/scrapers/amazon-product-scraper/) of my site. The [E-commerce family page](https://alexis.morain.fr/en/scrapers/families/ecommerce/) puts it side by side with the other scrapers of the same family.

# Actor input Schema

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

One per line, as you would type them in the Amazon search box. Each search returns up to <b>Max products per search</b> unique products on the marketplace chosen below.

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

One per line: a product URL (<code>https://www.amazon.com/dp/B07S98411N</code>, amazon.com or amazon.de) or a bare ASIN (<code>B07S98411N</code>, read on the marketplace chosen below). Each product page is read in full. A product that no longer exists is reported in the log and not charged.

## `categoryUrls` (type: `array`):

One per line: a category page (<code>https://www.amazon.com/b?node=289745</code>) or a search result page with its filters (<code>https://www.amazon.com/s?k=kettle\&rh=n%3A289745</code>). The marketplace (amazon.com or amazon.de) is read from the URL. Best sellers pages are not supported yet.

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

Used for search terms and bare ASINs. URLs keep their own marketplace. Other Amazon marketplaces are not supported yet: their search pages answer with a JavaScript challenge that this Actor does not run.

## `zipCode` (type: `string`):

Prices, availability and delivery dates are those Amazon shows for this postcode, for example <code>90210</code> or <code>99501</code> on amazon.com. Included in the price, no extra charge. Leave empty for the marketplace's capital (New York 10001 on amazon.com, 10115 Berlin on amazon.de). Each product row says the location actually applied in <code>deliverTo</code>, and the run fails rather than return prices for another place if Amazon refuses the postcode.

## `maxItemsPerSearch` (type: `integer`):

Stop each search term or category after this many unique products. <code>0</code> means no limit. A product is counted and charged once per search, even when it shows up on several pages.

## `fullCoverage` (type: `boolean`):

Amazon serves 7 pages per search whatever the number of results it announces, about 300 products for <code>coffee maker</code> out of "over 40,000". With this on, the search is split into price bands, each with its own 7 pages, and bands that are still full are split again. Measured on <code>coffee maker</code>: 113,802 unique products in 40 minutes instead of 281. Most of the extra products are the long tail Amazon attaches to the query (carafes, filters, spare parts), so keep <b>Max products per search</b> set unless you want all of it. Products are deduplicated, so a product found in two bands is charged once. Products without a price only appear in the first 7 pages.

## `includeDetails` (type: `boolean`):

For search results, also read each product's page: delivery date and price for your postcode, seller and who ships it, best sellers rank, star histogram, AI review summary, review aspects (each with positive and negative mention counts), top reviews shown on the page (about 10 to 13 on amazon.de, none on amazon.com where Amazon requires sign-in), features, attributes, variants and all images. Charged as a detailed product instead of a product. Product URLs and ASINs always come with these fields.

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

Sponsored products are part of what a shopper sees and are flagged with <code>sponsored: true</code>. Turn off to keep organic results only.

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

Leave as is. Product pages go through Apify datacenter proxies with one IP per session; search pages fall back to residential IPs when Amazon refuses datacenter ones, at the Actor's own cost. The price per product is the same whatever you choose.

## Actor input object example

```json
{
  "searchQueries": [
    "coffee maker"
  ],
  "marketplace": "com",
  "maxItemsPerSearch": 20,
  "fullCoverage": false,
  "includeDetails": false,
  "includeSponsored": true,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

All products in the default dataset.

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

Status of each search, category or product: products returned, unique products found beyond the 7-page limit, pages read, price bands, delivery location applied.

# 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": [
        "coffee maker"
    ],
    "maxItemsPerSearch": 20,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("alexmorain/amazon-product-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": ["coffee maker"],
    "maxItemsPerSearch": 20,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("alexmorain/amazon-product-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": [
    "coffee maker"
  ],
  "maxItemsPerSearch": 20,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call alexmorain/amazon-product-scraper --silent --output-dataset

```

## MCP server setup

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