# Amazon Search Scraper: Products, Prices & Rank (`deepmine/amazon-search-scraper`) Actor

Amazon search scraper for keyword and category results on any marketplace: position, organic rank, sponsored flag, title, ASIN, price, list price, rating, reviews, Prime, coupons, deals, badges and delivery. Every keyword's rank kept, each product charged once. No login.

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

## Pricing

from $0.49 / 1,000 search results

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 Search Scraper: Products, Prices & Rank

An Amazon search scraper for keyword and category results on any Amazon marketplace. Each search gives its products
in the order Amazon shows them, with the facts kept apart: position across pages, position on the page, organic rank
and a sponsored flag, plus title, ASIN, price, list price, rating, reviews, "bought in past month", Prime, coupons,
deals, badges and the delivery lines. Every keyword's rank of every product is kept, and a product two keywords
return is charged once. No login, no cookies, no browser.

| position | organicRank | isSponsored | title | price | stars | reviewsCount | coupon |
|---|---|---|---|---|---|---|---|
| 1 | 1 | false | Apple AirPods Pro 3 Wireless Earbuds with Active Noise Cance… | $179.00 | 4.4 | 16,114 | |
| 2 | 2 | false | JBL Vibe Beam - True Wireless Earbuds - Black JBL Deep Bass S… | $27.95 | 4.2 | 40,893 | |
| 8 | 8 | false | GNMN Active Noise Cancelling Ear Buds Wireless Earbuds 96hrs… | $75.98 | 4.9 | 78 | Save 50% with coupon |
| 17 | | true | Wireless Earbuds, Bluetooth 5.4 Headphones Bass Stereo Ear B… | $19.99 | 5.0 | 47 | |
| 18 | | true | Active Noise Cancelling Ear Buds Wireless Earbuds 90 Hrs Pla… | $49.99 | 5.0 | 28 | |

<sub>Collected from two saved amazon.com result pages for "wireless earbuds" (2026-10-07, local test run on the
engine's saved pages; platform rows to follow).</sub>

**$0.49 per 1,000 results** on the Starter plan ($0.58 on the Free plan; $0.49 Scale, Business, Platinum and
Diamond). Ranking rows are free. The prefilled run (100 results: 50 for "wireless earbuds" and 50 for "phone case" on
amazon.com) costs about $0.05 on Starter. With **📢 Include sponsored results** on, each product also costs the
sponsored-results add-on, **$0.79 per 1,000 results** on every plan.

### What you can scrape

- **Keywords or URLs**: type what you'd search on Amazon, or paste search pages (`amazon.com/s?k=...`) and category
  pages (`amazon.com/b?node=...`) straight from your browser. Every parameter of a pasted URL is kept: the filters,
  department and sort you set on Amazon stay set.
- **Any marketplace**: amazon.com, .co.uk, .de, .fr, .it, .es, .ca, .com.mx, .co.jp, .in, .com.au and 12 more.
  Prices keep their marketplace's currency, decimal commas included.
- **Ranks that mean something**: `position` counts every product slot of the search, sponsored included, across
  pages; `pagePosition` is the slot's place on its page; `organicRank` counts only the non-sponsored results (null on
  an ad). They're counted before any filter, so a filter never renumbers what Amazon showed.
- **Sponsored results as shoppers see them**: Amazon shows sponsored slots to most home (residential) visitors and
  rarely to datacenter IPs. Turn on **📢 Include sponsored results (uses residential, extra charge)** and every
  results page is read over residential IPs in the marketplace's country, so you see the ads a shopper would: they're
  flagged `isSponsored` and `position` counts them. Amazon doesn't put ads on every page, even for residential
  visitors: when a page has none, its rows have `isSponsored` false. Off (the default), pages are read on datacenter:
  usually no ads, clean organic ranks, no add-on. **📢 Keep sponsored rows** off leaves ads out of the rows while
  they still count in `position`.
- **Filters**: **↕️ Sort by** and the price range go into Amazon's search URL; **⭐ Minimum rating** and
  **✅ Prime only** are applied to the results Amazon returns. The run summary counts what each filter left out.
- **Deals on the card**: coupons ("Save 50% with coupon"), deal badges ("Limited time deal"), promotion lines
  ("Exclusive Prime price"), Best Seller and Overall Pick badges, "More Buying Choices" and the delivery promise.
- **Keyword tracking**: a product several keywords return is one product row (charged once), and the free
  **🔢 Rankings** dataset keeps its rank for every keyword, organic and sponsored separately.

### How to use it

1. Type **🔍 Search keywords** (one per line) or paste **🔗 Search or category URLs**.
2. Pick the **🌍 Marketplace** for the keywords (URLs keep their own).
3. Set **📊 Results per search** (100 when left empty).
4. Want the ads shoppers see? Turn on **📢 Include sponsored results** (+$0.79 per 1,000 products): datacenter
   pages, the default, rarely show any.
5. Press **Start**. Rows stream into the dataset in search order, search by search.

The Amazon Scraper's keys work too: `categoryOrProductUrls`, `startUrls`, `maxItemsPerStartUrl` and
`maxSearchPagesPerStartUrl` (given with this form's cap as well, the lower cap wins). This listing reads the search results only and never opens product pages: for full
product details, seller offers or variants use our Amazon Scraper; for ranked lists, our Amazon Best Sellers Scraper.

### Pricing

You pay per product in the dataset, once per product per run however many searches return it, at your Apify plan's
price (see the Pricing tab). Ranking rows, searches that fail or come back empty and the run summary are never
charged. A run stops at your spending limit without reading pages it can't deliver.

**📢 Include sponsored results** adds one flat add-on event per product in the dataset (see the Pricing tab), on top
of its result price; it's never charged with the option off. The add-on pays for reading the results pages over
residential IPs, so with the option on it's charged for every product, sponsored or organic, including on pages where
Amazon showed no ads. Your spending limit covers both, so a capped run stops early enough to pay for each product's
add-on. Residential traffic is ours to pay, within a per-run allowance that
the add-on funds: past it, the run stops (its run summary says `residentialAllowance`) rather than going on without
the ads.

### Output

**🔍 Search results** (the default dataset): one row per product, the same keys on every row; anything a card doesn't
show is null.

```json
{
  "position": 8,
  "pagePosition": 8,
  "pageNumber": 1,
  "organicRank": 8,
  "isSponsored": false,
  "thumbnailImage": "https://m.media-amazon.com/images/I/717VeiPNjDL._AC_UY218_.jpg",
  "title": "GNMN Active Noise Cancelling Ear Buds Wireless Earbuds 96hrs Playback Bluetooth Headphones Dual Battery Display Stereo Bass Earphones with Earhooks Microphone IPX7 Waterproof for Sports/Runing/Workout",
  "asin": "B0HBQD3ZGP",
  "url": "https://www.amazon.com/dp/B0HBQD3ZGP",
  "price": "$75.98",
  "priceValue": 75.98,
  "currency": "USD",
  "listPrice": "$179.99",
  "listPriceValue": 179.99,
  "discountPercent": 58,
  "stars": 4.9,
  "reviewsCount": 78,
  "monthlyPurchaseVolume": "1K+ bought in past month",
  "monthlyPurchases": 1000,
  "isPrime": null,
  "isBestSeller": false,
  "isAmazonChoice": false,
  "amazonChoiceText": null,
  "badge": null,
  "badges": ["Sustainability: Recycled materials +2 more"],
  "coupon": "Save 50% with coupon",
  "deal": "Deal ends in 10:37:29",
  "promotions": ["Deal ends in 10:37:29"],
  "delivery": "FREE delivery Mon, Oct 12",
  "fastestDelivery": null,
  "inStockText": null,
  "moreBuyingChoices": null,
  "variantAsins": ["B0HBQD3ZGP", "B0HJLRTKC7"],
  "variantDetails": ["B0HBQD3ZGP: Black", "B0HJLRTKC7: Blue"],
  "variantHint": null,
  "query": "wireless earbuds",
  "searchUrl": "https://www.amazon.com/s?k=wireless+earbuds",
  "sortBy": null,
  "totalResults": 27693,
  "marketplace": "amazon.com",
  "unNormalizedProductUrl": "https://www.amazon.com/GNMN-Cancelling-Headphones-Microphone-Waterproof/dp/B0HBQD3ZGP/ref=sr_1_8?...",
  "input": "wireless earbuds",
  "scrapedAt": "2026-10-15T23:23:51Z"
}
```

| Key | What it is |
|---|---|
| `position` | The slot's place in the search's results, sponsored included, counted across pages |
| `pagePosition` | The slot's place on its page (1 = first result card) |
| `pageNumber` | The results page |
| `organicRank` | The slot's place among non-sponsored results, across pages (null on an ad) |
| `isSponsored` | A sponsored (ad) result. Datacenter pages (the default) rarely show ads: turn on **📢 Include sponsored results** to get the sponsored slots shoppers see (+$0.79 per 1,000 products) |
| `thumbnailImage`, `title`, `asin`, `url` | Picture, title, Amazon's product id, product page |
| `price`, `priceValue`, `currency` | Price as shown, as a number, ISO currency |
| `listPrice`, `listPriceValue`, `discountPercent` | The crossed-out list price; how far below it the price is (%) |
| `stars`, `reviewsCount` | Rating out of 5, number of ratings |
| `monthlyPurchaseVolume`, `monthlyPurchases` | "1K+ bought in past month" and that number |
| `isPrime` | The card offers Prime delivery. Logged out, Amazon shows it as "Join Prime to get FREE delivery"; a results page with no Prime sign at all gives null (unknown, never a guess) |
| `isBestSeller`, `isAmazonChoice`, `amazonChoiceText` | Best Seller badge; Overall Pick / Amazon's Choice badge and its text |
| `badge`, `badges` | The corner badge; every badge and teaser ("Top Reviewed for …", sustainability) |
| `coupon`, `deal`, `promotions` | The coupon; the deal badge; every deal or promotion line under the price |
| `delivery`, `fastestDelivery`, `inStockText` | The card's delivery lines (for Amazon's default location, or your postcode); its stock line when it shows one |
| `moreBuyingChoices` | The lowest other offer and the offer count ("$165.00 (7+ used & new offers)") |
| `variantAsins`, `variantDetails`, `variantHint` | The colour swatches: their ASINs, 'ASIN: colour name', and '+N other colors/patterns' |
| `query`, `searchUrl`, `sortBy`, `totalResults` | The keyword, the search URL as read, Amazon's sort (s=), Amazon's result count |
| `marketplace`, `unNormalizedProductUrl`, `input`, `scrapedAt` | Amazon site, the card's own link, what you gave, when |

**🔢 Rankings** (dataset alias `rankings`, free): one row per search and product, organic and sponsored apart, for
every product in the results dataset: `position`, `pagePosition`, `pageNumber`, `organicRank`, `isSponsored`,
`thumbnailImage`, `title`, `asin`, `priceValue`, `currency`, `query`, `searchUrl`, `isProductRowSearch` (this
search delivered the product row), `productSearchUrl` and `productPosition` (the search and position the product row
came from), `productUrl`, `marketplace`, `input`, `scrapedAt`. A product page 1 and page 2 both show (Amazon moves
results between pages) keeps its first position.

The **🧾 Run summary** (OUTPUT record) has, per search: products delivered, product slots read, organic slots read,
what each filter left out, Amazon's result count, products already delivered by an earlier search, pages read and
how many of them carried sponsored results, how many were read over residential IPs (`residentialPages`,
`residentialWireBytes`), and any page that failed.

### Good to know

- Results per search counts new products: a product an earlier search already delivered isn't charged again, so
  the second search goes on to fill its count. Its rank is still in Rankings.
- A product Amazon shows twice in one search (an ad and an organic result) is one row, from the slot read first; both
  slots are in Rankings.
- Prices, delivery dates and Prime depend on the delivery location: set **📍 Delivery postcode** for yours.
- A search Amazon refuses on every try is listed as failed in the run summary and charged nothing; the other searches
  go on. So is a page that comes back as something other than search results (a block page, a cut-off answer) after
  it's read again: it's never taken for an empty search.
- A search Amazon has no results for comes back empty: the few unrelated sponsored products Amazon shows on that
  page aren't rows.
- Sponsored rows appear where Amazon shows ads. On datacenter IPs (the default) Amazon rarely shows any: in our test
  runs about 1 page in 20 had ads. Over residential IPs (**📢 Include sponsored results**) ads usually sit on page 1,
  and not always: in our test runs page 1 had 12 ads on 4 of 5 searches and none on the fifth; the page 2s had none.
  The run summary says how many pages carried sponsored results, and a run whose pages showed none (option off)
  says so in its status line.
- A resurrected (or migrated) run goes on where it stopped: products it already delivered aren't charged again and
  count against your spending limit, and each search goes on after the last result it ranked, so no rank is given
  twice.

### Your feedback

Missing a field, or a marketplace that reads oddly? Open an issue on the Actor's page. Happy with the data? A short
review on the Actor's page helps other users find it.

# Actor input Schema

## `keywords` (type: `array`):

What you'd type in Amazon's search box, one search per line (wireless earbuds, phone case...). Read on the marketplace below.

## `searchUrls` (type: `array`):

Amazon search pages (amazon.com/s?k=...) or category pages (amazon.com/b?node=...), copied from your browser with any filters or sort you set there: every parameter of the URL is kept. Any marketplace.

## `domain` (type: `string`):

The Amazon site keywords are searched on. URLs keep their own site. Pick one, or type a host such as amazon.de or www.amazon.de.

## `maxItemsPerQuery` (type: `integer`):

Each search stops after this many products (empty: 100). A product two searches return is one product, charged once (the second search goes on to fill its count); every search keeps its rank of it in the Rankings dataset.

## `sponsoredResults` (type: `boolean`):

Datacenter pages (the default) rarely show ads: turn this on to get the sponsored slots shoppers see (+$0.79 per 1,000 products). Amazon shows sponsored slots to most home (residential) visitors and rarely to the datacenter IPs this Actor reads with by default. On: every results page is read over residential IPs, so ads are flagged isSponsored and counted in positions as a shopper sees them; when Amazon shows a page without ads, its rows have isSponsored false. The add-on (see Pricing) pays for the residential pages, so it's charged for every product while this is on, ads or not. Off: no add-on.

## `sort` (type: `string`):

Amazon's sort order (added to the search URL unless the URL sets its own).

## `minPrice` (type: `integer`):

Only products at or above this price, in the marketplace's currency (whole units). Products without a shown price are left out when a price filter is set.

## `maxPrice` (type: `integer`):

Only products at or below this price, in the marketplace's currency (whole units).

## `minRating` (type: `string`):

Only products rated at least this many stars. Products without a rating are left out.

## `primeOnly` (type: `boolean`):

Only products whose result card offers Prime delivery. A results page that shows no Prime signs gives none.

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

On: sponsored (ad) results are rows too, flagged isSponsored. Off: only organic results. Positions and organic ranks are the same either way.

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

Read prices and delivery for this postcode, e.g. 10001 (amazon.com) or 10115 (amazon.de). Empty = each marketplace's capital; amazon.com uses the proxy's US location. The run stops if Amazon rejects it.

## `countryCode` (type: `string`):

Two-letter country to deliver to, for international shipping prices, e.g. DE on amazon.com. Empty = the marketplace's own country. Not used with a postcode.

## `maxPagesPerQuery` (type: `integer`):

Each search reads at most this many results pages, about 16-48 products each (empty: 20).

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

Leave as is: Apify datacenter proxies work for Amazon. Residential is replaced by datacenter (for results pages with sponsored slots, turn on Include sponsored results).

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

Same as Search or category URLs (for API callers used to startUrls).

## `categoryOrProductUrls` (type: `array`):

Same as Search or category URLs (the Amazon Scraper's key).

## `maxItemsPerStartUrl` (type: `integer`):

Same as Results per search (the Amazon Scraper's key). Both given: the lower one.

## `maxSearchPagesPerStartUrl` (type: `integer`):

Same as Max pages per search (the Amazon Scraper's key). Both given: the lower one.

## `scrapeProductDetails` (type: `boolean`):

Kept for saved Amazon Scraper inputs: product pages aren't read here (the run log says so); use the Amazon Scraper for full details.

## `maxConcurrency` (type: `integer`):

Engine setting.

## `language` (type: `string`):

Kept for saved inputs: rows are read from Amazon's English pages where the marketplace has them.

## `useCaptchaSolver` (type: `boolean`):

Kept for saved inputs: not needed (a refused page is retried on a new IP).

## Actor input object example

```json
{
  "keywords": [
    "wireless earbuds",
    "phone case"
  ],
  "domain": "www.amazon.com",
  "maxItemsPerQuery": 50,
  "sponsoredResults": false,
  "sort": "relevance",
  "primeOnly": false,
  "includeSponsored": true,
  "proxyConfiguration": {
    "useApifyProxy": true
  },
  "maxConcurrency": 12
}
```

# Actor output Schema

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

No description

## `rankingsUrl` (type: `string`):

No description

## `summary` (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 = {
    "keywords": [
        "wireless earbuds",
        "phone case"
    ],
    "maxItemsPerQuery": 50,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("deepmine/amazon-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 = {
    "keywords": [
        "wireless earbuds",
        "phone case",
    ],
    "maxItemsPerQuery": 50,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("deepmine/amazon-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 '{
  "keywords": [
    "wireless earbuds",
    "phone case"
  ],
  "maxItemsPerQuery": 50,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call deepmine/amazon-search-scraper --silent --output-dataset

```

## MCP server setup

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