# Amazon Product Search Scraper (`karamelo/amazon-product-search-scraper`) Actor

Search Amazon by keyword or paste a search/category URL across 18 marketplaces and get product listings enriched with full detail-page data: feature bullets, description, all images, brand, best-sellers rank, buybox seller, breadcrumbs, variations, rating and reviews.

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

## Pricing

from $1.10 / 1,000 search items

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

### What is Amazon Product Search Scraper?

Amazon Product Search Scraper extracts products and search rankings from Amazon across 18 international marketplaces without requiring an Amazon account. Search by keyword or paste existing Amazon search or category URLs to collect ASINs, titles, prices, original list prices, ratings, review counts, page positions, organic rankings, and sponsored placement indicators. Enable detail page enrichment to add brand names, Best Sellers Rank (BSR), category paths, feature bullets, high-resolution images, availability, buy-box seller, and technical specifications directly to each dataset item.

E-commerce managers, Amazon sellers, market researchers, and AI agents use this tool to monitor organic search performance, track competitor share of voice, verify buy-box status, and feed structured catalog data into analytical dashboards.

### Quick start

1. Open the **Amazon Product Search Scraper** on Apify Console.
2. In the input configuration, enter your keyword in `searchQuery` (e.g., `wireless earbuds`).
3. Select your marketplace in `country` (defaults to `US`).
4. Set a conservative `maxResults` cap (e.g., `20`).
5. Click **Start** to run the scraper.
6. Inspect and download the extracted products as JSON, CSV, or Excel from the **Dataset** tab.

```json
{
  "searchQuery": "wireless earbuds",
  "country": "US",
  "maxResults": 20,
  "enrichDetails": true
}
```

### What data you receive

Each dataset row represents one Amazon product result matching your search criteria. When `enrichDetails` is enabled, the row is enriched with full detail-page data.

#### Sample output record

```json
{
  "recordType": "product",
  "asin": "B0BQPNMXQV",
  "title": "JBL Vibe Beam - True Wireless Earbuds - Black",
  "url": "https://www.amazon.com/dp/B0BQPNMXQV",
  "marketplace": "US",
  "searchQuery": "wireless earbuds",
  "searchUrl": "https://www.amazon.com/s?k=wireless+earbuds",
  "sourceType": "keyword",
  "page": 1,
  "positionOnPage": 1,
  "organicRank": 1,
  "globalPosition": 1,
  "isSponsored": false,
  "price": 29.95,
  "listPrice": 49.95,
  "currency": "USD",
  "discountPercent": 40,
  "rating": 4.2,
  "reviewCount": 41298,
  "boughtInPastMonth": "10K+ bought in past month",
  "isPrime": true,
  "thumbnail": "https://m.media-amazon.com/images/I/41+1Csr1pSL._AC_UY218_.jpg",
  "badgeText": "Overall Pick",
  "deliveryText": "FREE delivery Tomorrow",
  "couponText": "Save 10% with coupon",
  "availabilityText": null,
  "detailScraped": true,
  "brand": "JBL",
  "featureBullets": [
    "JBL Deep Bass Sound with 8mm drivers",
    "Comfortable stick-closed ergonomic fit",
    "Up to 32 hours of battery life with speed charging"
  ],
  "description": "Bring your sound everywhere with rich bass and long battery life.",
  "images": [
    "https://m.media-amazon.com/images/I/81hSCa-nltL._AC_SL1500_.jpg",
    "https://m.media-amazon.com/images/I/41+1Csr1pSL._AC_SL1000_.jpg"
  ],
  "imageCount": 2,
  "breadcrumbs": [
    "Electronics",
    "Headphones & Earbuds",
    "Earbud Headphones"
  ],
  "category": "Earbud Headphones",
  "bestSellersRank": [
    { "rank": 17, "category": "Electronics" },
    { "rank": 3, "category": "Earbud & In-Ear Headphones" }
  ],
  "availability": "In Stock",
  "soldBy": "Amazon.com",
  "shipsFrom": "Amazon",
  "brandStoreUrl": "https://www.amazon.com/stores/JBL/page/17575AD5",
  "hasAplusContent": true,
  "variations": [],
  "productDetails": {
    "Brand Name": "JBL",
    "Model Name": "JBL Vibe Beam",
    "Connectivity Technology": "Bluetooth 5.2"
  },
  "scrapedAt": "2026-10-30T12:00:00.000Z"
}
```

#### Understanding ranking fields

- `positionOnPage`: The absolute position of the product card on the search result page (counting sponsored ad placements and organic products in display order).
- `organicRank`: The natural organic ranking position. Sponsored ad placements have `null` for this field.
- `globalPosition`: The order of the product within the total collected dataset across all paginated pages.
- `isSponsored`: A boolean indicating whether the placement is a paid sponsored ad placement (`true`) or an organic search result (`false`).

### Input configuration

| Parameter | Type | Default | Description |
|---|---|---|---|
| `searchQuery` | String | `"wireless earbuds"` | Primary search keyword to query on Amazon (e.g. `'wireless earbuds'`). |
| `searchQueries` | Array of strings | `[]` | List of search queries to execute in bulk in one job. |
| `startUrls` | Array of objects | `[]` | Amazon search result or category listing URLs. Regional marketplace is auto-detected. |
| `country` | String (enum) | `"US"` | Amazon marketplace code for keyword searches (e.g. `US`, `UK`, `DE`, `JP`). |
| `maxResults` | Integer | `50` | Maximum number of products to collect across the entire run (1 to 1,000). |
| `enrichDetails` | Boolean | `true` | When enabled, fetches each product's full page to extract bullets, specs, and BSR. |
| `sortBy` | String (enum) | `"relevance"` | Sort order: `relevance`, `priceAsc`, `priceDesc`, `avgCustomerReview`, or `newest`. |
| `includeSponsored` | Boolean | `true` | Include sponsored products flagged with `isSponsored: true`. Set to `false` for organic only. |
| `maxSearchPages` | Integer | `5` | Maximum number of search pagination pages to crawl per keyword or URL (1 to 20). |

### Supported marketplaces

Amazon Product Search Scraper supports 18 Amazon regional marketplaces:

| Country Code | Marketplace Domain | Currency |
|---|---|---|
| `US` | amazon.com | USD ($) |
| `UK` | amazon.co.uk | GBP (£) |
| `DE` | amazon.de | EUR (€) |
| `FR` | amazon.fr | EUR (€) |
| `CA` | amazon.ca | CAD ($) |
| `ES` | amazon.es | EUR (€) |
| `IT` | amazon.it | EUR (€) |
| `JP` | amazon.co.jp | JPY (¥) |
| `AU` | amazon.com.au | AUD ($) |
| `IN` | amazon.in | INR (₹) |
| `MX` | amazon.com.mx | MXN ($) |
| `BR` | amazon.com.br | BRL (R$) |
| `NL` | amazon.nl | EUR (€) |
| `SE` | amazon.se | SEK (kr) |
| `PL` | amazon.pl | PLN (zł) |
| `TR` | amazon.com.tr | TRY (₺) |
| `AE` | amazon.ae | AED |
| `SG` | amazon.sg | SGD ($) |

### Use cases and workflows

#### Share of search & competitor benchmarking

Brand owners track targeted search queries weekly to monitor how many top 10 positions their listings occupy versus competing brands, identifying when competitor sponsored ads overtake organic placements.

#### Price tracking and discount analysis

E-commerce analysts crawl category URLs across multiple marketplaces to monitor discounted items, list prices, and coupon availability during seasonal promotional events.

#### AI agent workflows and MCP integration

AI agents and automated pipelines query product data on demand using the Apify API or MCP server to provide shoppers with real-time price comparisons, Best Sellers Rank analysis, and brand discovery.

### Programmatic integration

You can run this Actor programmatically through the Apify API using the official client libraries.

#### Node.js (JavaScript / TypeScript)

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

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

const run = await client.actor('karamelo/amazon-product-search-scraper').call({
    searchQuery: 'wireless earbuds',
    country: 'US',
    maxResults: 20,
    enrichDetails: false,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(`Extracted ${items.length} products:`);
for (const item of items) {
    console.log(`[#${item.organicRank ?? 'Ad'}] ${item.title} - $${item.price}`);
}
```

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient(token="YOUR_APIFY_TOKEN")

run_input = {
    "searchQuery": "wireless earbuds",
    "country": "US",
    "maxResults": 20,
    "enrichDetails": False,
}

run = client.actor("karamelo/amazon-product-search-scraper").call(run_input=run_input)

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(f"[{item.get('asin')}] {item.get('title')} - {item.get('price')}")
```

### Troubleshooting and tips

| Observable issue | Potential cause | Recommended adjustment |
|---|---|---|
| Zero products returned | Strict query filter or keyword not matching items | Verify the search term directly on Amazon and check spelling. |
| Missing detail page fields | `enrichDetails` was set to `false` | Enable `enrichDetails: true` in your run configuration. |
| Specific product URL skipped | Single `/dp/` product URLs provided in `startUrls` | Use search or category URLs; this Actor is designed for search results. |
| Country currency mismatch | Keyword searched on different marketplace domain | Set the `country` parameter to your target marketplace code. |

### FAQ

#### What is the difference between positionOnPage and organicRank?

`positionOnPage` reflects the overall visual order of items on the search page, including sponsored advertisements. `organicRank` counts natural organic listings only, ignoring sponsored ads.

#### Can I scrape multiple search queries in a single job?

Yes. Provide an array of strings in `searchQueries` (e.g. `["gaming mouse", "mechanical keyboard"]`). Results from all queries are stored in the same output dataset.

#### Do I need to be logged into an Amazon account?

No. The scraper reads public Amazon search result listings and detail pages without requiring customer credentials.

#### Does the scraper support international Amazon sites?

Yes, 18 regional marketplaces are supported. Specify the two-letter country code in the `country` parameter or pass a regional Amazon URL into `startUrls`.

# Actor input Schema

## `searchQuery` (type: `string`):

Primary search keyword to query on Amazon (e.g. 'wireless earbuds'). Retrieves matching products from search results. For multiple keywords or direct URLs, use 'searchQueries' or 'startUrls'.

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

List of search queries to execute in one job. Each query is searched independently and all discovered products are aggregated into the dataset.

## `startUrls` (type: `array`):

Amazon search result or category listing URLs to scrape directly. The marketplace domain is automatically determined from each URL. Individual product detail URLs (/dp/) should not be passed here.

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

Regional Amazon marketplace for keyword searches (e.g. 'US' for amazon.com, 'DE' for amazon.de). Configures the regional domain and currency. Ignored when using startUrls.

## `maxResults` (type: `integer`):

Maximum number of product items to collect across the entire run. Crawling terminates once this target count is reached.

## `enrichDetails` (type: `boolean`):

When enabled, visits each product's detail page to gather comprehensive attributes including descriptions, feature bullets, high-res images, and BSR ranking.

## `sortBy` (type: `string`):

Search result ordering applied to keyword searches: relevance, customer reviews, price ascending/descending, or newest arrivals.

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

Whether to collect sponsored ad listings alongside organic product results. Sponsored items are tagged with isSponsored: true.

## `maxSearchPages` (type: `integer`):

Maximum number of search pagination pages to crawl per keyword or start URL.

## Actor input object example

```json
{
  "searchQuery": "wireless earbuds",
  "searchQueries": [
    "gaming mouse",
    "mechanical keyboard"
  ],
  "startUrls": [
    {
      "url": "https://www.amazon.com/s?k=running+shoes"
    }
  ],
  "country": "US",
  "maxResults": 1,
  "enrichDetails": true,
  "sortBy": "relevance",
  "includeSponsored": true,
  "maxSearchPages": 1
}
```

# Actor output Schema

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

All product records found across the search or category pages, enriched with detail page attributes when enrichDetails is enabled. Download as JSON, CSV, Excel, HTML, or XML.

# 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 = {
    "searchQuery": "wireless earbuds",
    "startUrls": [
        {
            "url": "https://www.amazon.com/s?k=wireless+earbuds"
        }
    ],
    "maxResults": 1,
    "enrichDetails": true,
    "maxSearchPages": 1
};

// Run the Actor and wait for it to finish
const run = await client.actor("karamelo/amazon-product-search-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 = {
    "searchQuery": "wireless earbuds",
    "startUrls": [{ "url": "https://www.amazon.com/s?k=wireless+earbuds" }],
    "maxResults": 1,
    "enrichDetails": True,
    "maxSearchPages": 1,
}

# Run the Actor and wait for it to finish
run = client.actor("karamelo/amazon-product-search-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 '{
  "searchQuery": "wireless earbuds",
  "startUrls": [
    {
      "url": "https://www.amazon.com/s?k=wireless+earbuds"
    }
  ],
  "maxResults": 1,
  "enrichDetails": true,
  "maxSearchPages": 1
}' |
apify call karamelo/amazon-product-search-scraper --silent --output-dataset

```

## MCP server setup

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