# Amazon Product Scraper – Search & Export Products by Keyword (`endspec/amazon-instant-product-scraper`) Actor

Search Amazon by keyword and scrape product data: title, price, original price, star rating, rating count, Prime, best-seller and Amazon's Choice badges, image and product URL. Choose the marketplace (US, UK, DE, and more) and result count. No login, no API key. Pay only per product returned.

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

## Pricing

from $5.50 / 1,000 product returneds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## What's an Apify Actor?

Actors are 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 Product Scraper — Search & Export Products by Keyword

Search **Amazon** by any keyword and scrape product data at scale. This Amazon product scraper returns title, price, original price, star rating, number of ratings, Prime and best-seller badges, image and product URL — across the marketplace you choose (US, UK, DE, and more). No login, no cookies, no Amazon API key.

### Quick start (input → output)

**Input:**
```json
{ "query": "wireless earbuds", "country": "US", "limit": 40 }
````

**Output (one row per product):**

```json
{
  "asin": "B0H33SY8QC",
  "title": "XIAOWTEK Wireless Earbuds, Bluetooth 5.4, Noise Cancelling, IP7 Waterproof",
  "price": "$19.99",
  "originalPrice": "$29.99",
  "currency": "USD",
  "rating": 4.9,
  "ratingsCount": 543,
  "offersCount": 3,
  "isPrime": true,
  "isBestSeller": false,
  "isAmazonChoice": true,
  "salesVolume": "400+ bought in past month",
  "url": "https://www.amazon.com/dp/B0H33SY8QC",
  "photo": "https://m.media-amazon.com/images/I/61GatbX06lL._AC_UY654_.jpg"
}
```

### What this actor does

- Searches an Amazon marketplace by keyword and returns products page by page until your `limit` is reached (~16 products per page, handled automatically).
- Normalizes each product to a clean, documented shape — no marketplace clutter.

### Input parameters

| Field | Type | Required | Description |
|---|---|---|---|
| `query` | string | ✅ | What to search for (e.g. `wireless earbuds`). |
| `country` | string | — | Marketplace: `US` (default), `CA`, `UK`, `DE`, `FR`, `ES`, `IT`, `AU`, `IN`, `JP`, `BR`, `MX`. |
| `limit` | integer | — | Max products to return (default 20, max 200). |

**Important notes**

- Prices are returned as display strings (e.g. `"$19.99"`) with a separate `currency`.
- Some fields (`originalPrice`, `salesVolume`, `offersCount`) are present only when Amazon shows them.
- An empty search returns a single error row and is **not** charged.

#### More input examples

```json
{ "query": "yoga mat", "country": "UK", "limit": 50 }
```

```json
{ "query": "mechanical keyboard", "country": "DE", "limit": 100 }
```

### Output

#### Field reference

| Field | Description |
|---|---|
| `asin` | Amazon product ID. |
| `title`, `price`, `originalPrice`, `currency` | Listing basics. |
| `rating`, `ratingsCount`, `offersCount`, `minOfferPrice` | Ratings and offers. |
| `isPrime`, `isBestSeller`, `isAmazonChoice`, `hasVariations` | Badges/flags. |
| `salesVolume`, `delivery` | When shown by Amazon. |
| `url`, `photo` | Product URL and primary image. |

#### Output examples

**No results** (not charged):

```json
{ "status": "error", "error": "No products were found for this search. Try a different keyword or marketplace. You were not charged." }
```

**Bad input** (not charged):

```json
{ "status": "error", "error": "That search could not be processed. Please check your query and marketplace, then try again. You were not charged." }
```

**Service busy** (not charged):

```json
{ "status": "error", "error": "The product data service is temporarily unavailable — please retry shortly. You were not charged." }
```

### Use cases

- **E-commerce / retail:** price monitoring, competitor catalogs, assortment research.
- **Market research:** track ratings, review counts and best-seller signals for a niche.
- **Dropshipping / affiliates:** build product lists with images and URLs.

### Best practices

- Be specific with `query` for tighter, more relevant results.
- Set `limit` to what you actually need — you're billed per product returned.
- Pick the right `country` for pricing/availability that matches your market.

### Pricing

Pay-per-event: charged **once per product returned**. Empty searches and errors are **never** charged.

### Legality

Scrape only publicly available product data and comply with Amazon's Terms of Service and applicable law. Do not use the data to infringe rights or for prohibited purposes. You are responsible for your use of the exported data.

### FAQ

**Do I need an Amazon API key?** No.
**Which marketplaces?** US, CA, UK, DE, FR, ES, IT, AU, IN, JP, BR, MX.
**How many products can I get?** Up to 200 per run via `limit` (auto-paginated).
**Why is `price` a string?** It preserves Amazon's exact display value; use `currency` alongside it.

### Support

Email **contact@endspec.net** — we typically reply within one business day.

# Actor input Schema

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

What to search for on Amazon (e.g. "wireless earbuds", "yoga mat").

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

Country marketplace to search.

## `limit` (type: `integer`):

Maximum products to return. Results are paginated ~16 per page; the actor fetches enough pages to reach this number.

## Actor input object example

```json
{
  "query": "wireless earbuds",
  "country": "US",
  "limit": 20
}
```

# Actor output Schema

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

No description

# 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": "wireless earbuds"
};

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

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Amazon Product Scraper – Search & Export Products by Keyword",
        "description": "Search Amazon by keyword and scrape product data: title, price, original price, star rating, rating count, Prime, best-seller and Amazon's Choice badges, image and product URL. Choose the marketplace (US, UK, DE, and more) and result count. No login, no API key. Pay only per product returned.",
        "version": "0.1",
        "x-build-id": "IG5Jvk5bs6MlrgmtT"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/endspec~amazon-instant-product-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-endspec-amazon-instant-product-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/endspec~amazon-instant-product-scraper/runs": {
            "post": {
                "operationId": "runs-sync-endspec-amazon-instant-product-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/endspec~amazon-instant-product-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-endspec-amazon-instant-product-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": [
                    "query"
                ],
                "properties": {
                    "query": {
                        "title": "Search Query",
                        "type": "string",
                        "description": "What to search for on Amazon (e.g. \"wireless earbuds\", \"yoga mat\")."
                    },
                    "country": {
                        "title": "Amazon Marketplace",
                        "enum": [
                            "US",
                            "CA",
                            "UK",
                            "DE",
                            "FR",
                            "ES",
                            "IT",
                            "AU",
                            "IN",
                            "JP",
                            "BR",
                            "MX"
                        ],
                        "type": "string",
                        "description": "Country marketplace to search.",
                        "default": "US"
                    },
                    "limit": {
                        "title": "Max Products",
                        "minimum": 1,
                        "maximum": 200,
                        "type": "integer",
                        "description": "Maximum products to return. Results are paginated ~16 per page; the actor fetches enough pages to reach this number.",
                        "default": 20
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
