# Amazon Product Search Scraper: Results as JSON (`tollprobe/amazon-products-scraper`) Actor

Scrape Amazon product search results for any keyword as JSON: ASIN, title, price shown, rating, review count and product URL. No seller or reviewer fields. Pay per product returned, with a cost cap per run.

- **URL**: https://apify.com/tollprobe/amazon-products-scraper.md
- **Developed by:** [tollprobe](https://apify.com/tollprobe) (community)
- **Categories:** E-commerce
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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 Search Scraper reads the public search results that Amazon shows for a keyword, without logging in, and returns the products as JSON: ASIN, title, price shown, rating, number of ratings and product address. You pay per product returned, and you set a cost cap per run.

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

### Amazon product search results as JSON

You give the Actor the words you would type in the Amazon search box. It reads the result pages for that search and saves one item per product to the run's dataset. You can start it from the Apify Console or call it through the Apify API, and download the dataset in the formats the platform offers for datasets.

#### What you get

- `asin`
- `title`
- `price` (the price as displayed on the result card, currency symbol included, or null when the card shows none)
- `priceAmount` (the number in the price shown, or null)
- `rating` (stars out of 5, or null)
- `reviewsCount` (number of ratings shown, or null)
- `url` (address of the product page)

A product whose card shows no price is still returned, with `price` and `priceAmount` set to null, and still charged: the price is one field among several. How often a card shows no price depends on the address the Actor reads from. Measured: when the Actor reads from an exit outside the United States, the page shows "See options" in place of the price on part of the products (25 of 56 cards in one measured run), and those products come back with `price` null; from the United States, every card measured showed a price. Set `apifyProxyCountry` to `US` in `proxyConfiguration` to read from the United States. The run summary counts the cards without a price and says why.

#### What it does not return

- Anything about a seller: no seller name, no storefront, no offer by third parties.
- Anything about the people who review: no reviewer name, no review text.
- Any field that is not listed above.

It reads search results only. It does not open a product page, so it does not return a description, a list of images or the full list of reviews.

### How to scrape Amazon product search results

1. Open the Actor on Apify and go to the Input tab.
2. Type the keywords in `query`, for example `standing desk`.
3. Set `maxItems` (default 20, up to 100) and, if you want to read from the United States, add a proxy configuration with `apifyProxyCountry` set to `US`.
4. Click Start. When the run ends, open the Output tab, or read the dataset through the API.

#### Input

| Field | Meaning |
|---|---|
| `query` | Keywords as typed in the Amazon search box, required |
| `maxItems` | Maximum products returned. Default 20, up to 100 |
| `maxCostUsd` | Cost cap per run in USD, start event included. Default 0.55, enough for 100 products |
| `proxyConfiguration` | Optional Apify proxy settings. Unset by default |

### Pricing and cost cap

You are charged per product returned, after the product is saved to the dataset, plus a small start event for each run.

| Event | Price on every plan |
|---|---|
| Product returned | $0.004 |
| Actor start | $0.00005 |

Examples of cost for one run:

| Products returned | Cost |
|---|---|
| 20 (the default) | 20 × $0.004 + $0.00005 = $0.08005 |
| 100 (the maximum) | 100 × $0.004 + $0.00005 = $0.40005 |

`maxCostUsd` stops the run when the cost of the products returned, start event included, reaches it. It is computed at the product price, which is the same on every plan. Products already returned are kept, and the run status says it stopped at the cost cap. The run also stops if the platform charge limit for the run is reached.

### Input and output example

Input:

```json
{
  "query": "standing desk",
  "maxItems": 3,
  "proxyConfiguration": { "useApifyProxy": true, "apifyProxyCountry": "US" }
}
```

Output, from a run of this Actor with that input:

```json
[
  {
    "asin": "B0F8MHPVPH",
    "title": "FEZIBO Standing Desk 48 × 24 Inch Electric Height Adjustable, Maple",
    "price": "$99.99",
    "priceAmount": 99.99,
    "rating": 4.5,
    "reviewsCount": 4921,
    "url": "https://www.amazon.com/dp/B0F8MHPVPH"
  },
  {
    "asin": "B0HKSPH28T",
    "title": "ModernMate 63\" L Shaped Executive Standing Desk, Privacy Panel & Bookshelf",
    "price": "$699.99",
    "priceAmount": 699.99,
    "rating": 4.8,
    "reviewsCount": 223,
    "url": "https://www.amazon.com/dp/B0HKSPH28T"
  }
]
```

Two of the three items of that run are shown. The prices, ratings and counts are those Amazon displayed at the time of the run and change from one run to the next.

#### Run summary

The key-value store holds `RUN_SUMMARY`: the run status, the number of products, and counts only (requests, statuses, bytes, cards read, cards with a price, a rating and a review count, why a price is missing, sponsored cards). No page content and no product content.

### How the Actor reads Amazon

One request every 5 seconds, with a declared `User-Agent` that names this Actor. A result page lists between about 40 and 57 products; the Actor reads the next page when the first is used up. No login, no cookie, no account, no challenge solving, no disguise. If the site refuses two requests in a row (for example status 429, 503 or 403, a robot-check page or a sign-in page), the run stops there and keeps what it already returned: it does not retry around the refusal.

### Other Actors by Tollprobe

The input fields, the output fields, the price per product and a cost example for this Actor are also on its page at [tollprobe.com](https://tollprobe.com/actors/amazon-products-scraper); all the Actors by Tollprobe are listed at [tollprobe.com/actors](https://tollprobe.com/actors).

- [LinkedIn Jobs Scraper](https://apify.com/tollprobe/linkedin-jobs-scraper): public job offers from LinkedIn as JSON, billed per offer.

### FAQ

#### Is this the Amazon product search API?

No. It is an Actor that reads the public search result pages and is called through the Apify API. It is not an API provided by Amazon.

#### Can I scrape Amazon product data by ASIN or from a product page?

Not with this Actor. It takes keywords and reads search results. The `asin` field is returned for each product it finds.

#### Does it return reviews or seller information?

No. It returns the number of ratings and the average rating shown on the result card, and nothing about sellers or about the people who review.

#### How many products can I get in one run?

Up to 100 with `maxItems`. A run stops earlier if it reaches `maxCostUsd`, if the platform charge limit is reached, or if the site refuses two requests in a row.

#### Why is `price` null on some products?

The result card showed no price. Reading from the United States, with `apifyProxyCountry` set to `US`, showed a price on every card measured; see "What you get" above.

#### Is it legal to scrape Amazon?

Not legal advice. The site's terms apply to what you do with its content, and you are responsible for complying with them.

#### Where do I report a problem?

Use the Issues tab of this Actor on Apify.

# Actor input Schema

## `query` (type: `string`):

Keywords as typed in the Amazon search box, for example: standing desk.

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

Maximum number of products returned. Up to 100.

## `maxCostUsd` (type: `number`):

The run stops when the cost of the products returned, start event included, reaches this amount. Products already returned are kept.

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

Optional. Leave unset to read from the Actor's own address.

## Actor input object example

```json
{
  "query": "standing desk",
  "maxItems": 20,
  "maxCostUsd": 0.55
}
```

# Actor output Schema

## `products` (type: `string`):

One item per product returned: ASIN, title, price shown, price amount, rating, reviews count, product address.

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

Counts only: status, number of items, and request statistics.

# 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 = {
    "query": "standing desk"
};

// Run the Actor and wait for it to finish
const run = await client.actor("tollprobe/amazon-products-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 = { "query": "standing desk" }

# Run the Actor and wait for it to finish
run = client.actor("tollprobe/amazon-products-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 '{
  "query": "standing desk"
}' |
apify call tollprobe/amazon-products-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,tollprobe/amazon-products-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/CQq23YEfpfrtCTXoc/builds/6knmDehKkyHQDeoYr/openapi.json