# Amazon Scraper — Product & Price Search (US, UK, DE, SG, more) (`herus13/amazon-scraper`) Actor

Search Amazon and scrape products — title, price, original price, rating, reviews, Prime, image, and URL (ASIN). Output shares a schema with our Shopee & Lazada scrapers for cross-marketplace price comparison. CSV/JSON/Excel export.

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

## Pricing

from $5.00 / 1,000 products

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js/docs.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/integrations/mcp.md).

If your project is in a different language, use 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 Scraper

**Amazon Scraper** is an Apify actor that searches [Amazon](https://www.amazon.com) by keyword and returns structured product + price data — ASIN, title, price, original price, currency, rating, review count, Prime, image, and product URL. Output shares a schema with our **Shopee** and **Lazada** scrapers, so you can normalize all three marketplaces into one dataset for **price comparison and affiliate**. Export to JSON, CSV, or Excel.

Supported marketplaces: US, UK, Germany, Singapore, Australia, India, Japan.

### Table of contents

- [What it does](#what-it-does)
- [How to scrape Amazon](#how-to-scrape-amazon)
- [Input](#input)
- [Output](#output)
- [Pricing](#pricing)
- [Recommended proxies](#recommended-proxies)
- [Why this scraper](#why-this-scraper)
- [FAQ](#faq)
- [Rate this actor](#rate-this-actor)
- [Related actors](#related-actors)

### What it does

- 🔎 **Keyword search → products** on any supported Amazon marketplace.
- 💲 **Price + original price** with the marketplace's currency.
- ⭐ **Signals** — rating, review count, Prime, image, ASIN.
- 🧩 **Shopee/Lazada-aligned schema** — same field names for cross-marketplace price comparison.
- 🛡️ **Anti-bot handled** — real stealth browser + proxy rotation clears Amazon's reputation gating and price-strip soft-block; blocks degrade gracefully, never crash the run.

### How to scrape Amazon

1. Enter one or more **Search terms**.
2. Pick a **Marketplace**.
3. Set **Max results**.
4. **Enable a residential proxy in that country** (required — see Recommended proxies).
5. Run. Each product is one dataset row.

**Example input:**

```json
{
  "search_terms": ["laptop stand"],
  "region": "com",
  "max_results": 100,
  "proxy": { "useApifyProxy": true, "apifyProxyGroups": ["RESIDENTIAL"], "apifyProxyCountry": "US" }
}
````

### Input

| Field | Type | Required | Description |
| --- | --- | --- | --- |
| `search_terms` | array | ✅ | Keywords to search. |
| `region` | string | — | `com`, `co.uk`, `de`, `sg`, `com.au`, `in`, `co.jp` (default `com`). |
| `max_results` | integer | — | Max products across all terms (default 48). |
| `proxy` | object | — | Proxy config. A **residential proxy in the marketplace's country is required** — Amazon blocks datacenter IPs and serves price-stripped pages. |

### Output

One row per product. Field names overlap the Shopee & Lazada scrapers (`product_id`, `title`, `price`, `currency`, `rating`, `review_count`, `product_url`, `region`) so all three merge into one comparison table. `product_id` is the ASIN.

```json
{
  "product_id": "B0ABCDEFGH",
  "title": "Anker Laptop Stand Adjustable",
  "price": 29.99,
  "price_original": 49.99,
  "currency": "USD",
  "rating": 4.7,
  "review_count": 12345,
  "is_prime": true,
  "thumbnail_url": "https://m.media-amazon.com/images/I/aaa.jpg",
  "product_url": "https://www.amazon.com/dp/B0ABCDEFGH",
  "region": "com",
  "scraped_at": "2026-07-19T10:00:00+00:00",
  "error": null
}
```

| Field | Type | Description |
| --- | --- | --- |
| `product_id` | string | ASIN. |
| `title` | string | Product name. |
| `price` / `price_original` | number / null | Current / struck-out original price. |
| `currency` | string | Marketplace currency. |
| `rating` | number / null | 0–5. |
| `review_count` | integer / null | Number of ratings. |
| `is_prime` | boolean / null | Prime badge present. |
| `thumbnail_url` / `product_url` | string | Image and product page. |
| `region` / `scraped_at` | string | Marketplace code and UTC timestamp. |

### Pricing

Pay-per-event:

| Event | Price |
| --- | --- |
| Actor start | $0.005 per run |
| Product | $0.002 per product scraped |

> Provisional until finalized in the Apify Console. You supply your own proxy; proxy traffic is billed by your proxy provider (or Apify Proxy usage).

### Recommended proxies

Amazon **blocks datacenter IPs** (intermittent blocks + price-stripped pages), so a residential proxy in the marketplace's country is required. Apify Residential Proxy works; for a low-cost residential pool we recommend [DataImpulse](https://dataimpulse.com/?aff=404588\&utm_source=apify) (referral link).

### Why this scraper

- **Comparison-ready.** Shares a normalized schema with our Shopee & Lazada scrapers — merge marketplaces into one price table without remapping fields.
- **Anti-bot handled.** A real stealth browser clears reputation gating; the price-strip soft-block is detected and retried on a fresh IP rather than shipping price-less rows.
- **Multi-marketplace.** Seven Amazon sites with correct currency each.

### FAQ

**Do I need a proxy?** Yes — Amazon blocks datacenter IPs. Use a residential proxy in the marketplace's country.

**Which marketplaces are supported?** US, UK, Germany, Singapore, Australia, India, Japan.

**Can I compare prices with Shopee and Lazada?** Yes — output field names match those scrapers, so all three feed one comparison dataset.

**Is scraping Amazon legal?** Scraping publicly available product data is generally permissible, but you are responsible for complying with Amazon's terms and applicable law, and for how you use the data. This actor scrapes only public search results — no login or paywall bypass.

### Rate this actor

Using Amazon Scraper? Please leave a ⭐ rating and a short review — it helps others find it and guides what we improve.

### Related actors

- [Shopee Shop Scraper](https://apify.com/herus13/shopee-shop-scraper) · [Lazada Scraper](https://apify.com/herus13/lazada-scraper) — the SEA companions for price comparison.
- More scrapers by this author: [apify.com/herus13](https://apify.com/herus13)

# Actor input Schema

## `search_terms` (type: `array`):

Keywords to search on Amazon, e.g. <code>laptop stand</code>. Each term is paginated until Max results.

## `region` (type: `string`):

Which Amazon marketplace to search.

## `max_results` (type: `integer`):

Maximum number of products to return across all search terms.

## `proxy` (type: `object`):

<b>Required for reliable runs.</b> Amazon blocks datacenter IPs (intermittent blocks + price-stripped pages). Use a <b>residential proxy in the marketplace's country</b>. Without one an Apify datacenter IP is likely to return 0 results or missing prices.

## Actor input object example

```json
{
  "search_terms": [
    "laptop stand"
  ],
  "region": "com",
  "max_results": 48
}
```

# Actor output Schema

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

Products from search — ASIN, title, price, original price, currency, rating, review count, Prime, image, product URL, region, scraped\_at.

# 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 = {
    "search_terms": [
        "laptop stand"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("herus13/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 = { "search_terms": ["laptop stand"] }

# Run the Actor and wait for it to finish
run = client.actor("herus13/amazon-scraper").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 '{
  "search_terms": [
    "laptop stand"
  ]
}' |
apify call herus13/amazon-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Amazon Scraper — Product & Price Search (US, UK, DE, SG, more)",
        "description": "Search Amazon and scrape products — title, price, original price, rating, reviews, Prime, image, and URL (ASIN). Output shares a schema with our Shopee & Lazada scrapers for cross-marketplace price comparison. CSV/JSON/Excel export.",
        "version": "0.1",
        "x-build-id": "oSnu8VjMBJFb0rNj4"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/herus13~amazon-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-herus13-amazon-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/herus13~amazon-scraper/runs": {
            "post": {
                "operationId": "runs-sync-herus13-amazon-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/herus13~amazon-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-herus13-amazon-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "search_terms"
                ],
                "properties": {
                    "search_terms": {
                        "title": "Search terms",
                        "type": "array",
                        "description": "Keywords to search on Amazon, e.g. <code>laptop stand</code>. Each term is paginated until Max results.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "region": {
                        "title": "Marketplace",
                        "enum": [
                            "com",
                            "co.uk",
                            "de",
                            "sg",
                            "com.au",
                            "in",
                            "co.jp"
                        ],
                        "type": "string",
                        "description": "Which Amazon marketplace to search.",
                        "default": "com"
                    },
                    "max_results": {
                        "title": "Max results",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Maximum number of products to return across all search terms.",
                        "default": 48
                    },
                    "proxy": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "<b>Required for reliable runs.</b> Amazon blocks datacenter IPs (intermittent blocks + price-stripped pages). Use a <b>residential proxy in the marketplace's country</b>. Without one an Apify datacenter IP is likely to return 0 results or missing prices."
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```