# Amazon Search Results Scraper (`apt_marble/amazon-search-results-scraper`) Actor

Collect Amazon search results for any keyword, with sponsored placements flagged and organic rank reported separately. Filter by price, stars and Prime before collecting, pick your Amazon marketplace, and optionally attach the complete product record to every result.

- **URL**: https://apify.com/apt\_marble/amazon-search-results-scraper.md
- **Developed by:** [Hamza](https://apify.com/apt_marble) (community)
- **Categories:** E-commerce, SEO tools
- **Stats:** 1 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.60 / 1,000 search result scrapeds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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 Search Results Scraper

Search Amazon the way a shopper does, and get the whole results list back as
clean structured data. Give the actor one or more search terms and it returns
every product Amazon shows for them — title, ASIN, price, stars, rating count,
Prime status, badges and delivery promise — with paid placements clearly
flagged and organic rank counted separately from them. It is built for sellers
tracking where their listings actually appear, agencies auditing ad saturation,
and anyone doing product research who needs Amazon's own ordering rather than a
guess at it.

### What you can do with it

- **Track keyword rank.** See exactly where a product sits for a search term,
  both as Amazon displays it and as it ranks once ads are removed.
- **Audit sponsored saturation.** Count how much of a search term is paid
  placement, and which brands are buying it.
- **Research a niche fast.** Pull hundreds of products for a term with price,
  rating and review volume, ready for a spreadsheet or a model.
- **Watch competitors.** Re-run on a schedule and diff price, stars and rank
  over time.
- **Filter before you collect.** Restrict to a price band, a minimum star
  rating or Prime-eligible products so you only pay for the rows you want.
- **Go deeper on the winners.** Switch on full product details to attach the
  complete product record — every specification, every image, the full star
  breakdown and category rankings — to each result.

### What you get

One row per search result. Abridged sample:

```json
{
  "keyword": "protein powder",
  "marketplace": "us",
  "page": 1,
  "position": 49,
  "organicPosition": null,
  "isSponsored": true,
  "asin": "B008QHPVO4",
  "title": "Optimum Nutrition Gold Standard 100% Whey Protein Powder",
  "url": "https://www.amazon.com/dp/B008QHPVO4",
  "image": "https://m.media-amazon.com/images/I/71qVeA8rZ8L._AC_UL320_.jpg",
  "price": 54.99,
  "currency": "USD",
  "listPrice": 64.99,
  "typicalPrice": null,
  "rating": 4.6,
  "ratingsCount": 862,
  "boughtInPastMonth": "10K+",
  "isPrime": true,
  "isAmazonsChoice": false,
  "isBestSeller": false,
  "badge": "Best Seller",
  "deliveryText": "FREE delivery Thu, Aug 14",
  "variantCount": 12,
  "detailsIncluded": false,
  "scrapedAt": "2026-08-07T09:14:02.881Z"
}
```

With **Include full product details** switched on, the same row also carries
`brand`, `availability`, `inStock`, `buyBoxSeller`, `shipsFrom`,
`bestSellersRank`, `featureBullets`, `specifications`, `breadcrumbs`, `images`,
`starHistogram`, `description`, `dimensions`, `weight`, `hasCoupon` and
`dateFirstAvailable`, and `detailsIncluded` becomes `true`.

### Input reference

| Setting | Type | Default | Description |
| --- | --- | --- | --- |
| Search keywords | list of text | — (required) | Search terms. Each is searched separately and every row says which term found it. |
| Maximum results per keyword | integer | `100` | Stop after this many results for each search term. |
| Sort results by | select | `relevance` | How Amazon should order results: relevance, price low to high, price high to low, average customer rating, newest arrivals, or best selling. |
| Exclude sponsored placements | yes/no | `no` | Drop paid placements. When off they are kept and flagged. |
| Minimum price | integer | — | Only return products at or above this price, in the selected marketplace's own currency. |
| Maximum price | integer | — | Only return products at or below this price. |
| Minimum star rating | integer | — | Only return products rated at least this many stars (whole stars, 1 to 4). |
| Prime eligible only | yes/no | `no` | Only return products flagged as Prime eligible. |
| Include full product details | yes/no | `no` | Attach the complete product record to every result. Much slower and billed separately. |
| Amazon marketplace | select | `us` | Which country's Amazon site to read. Results come back in that marketplace's own currency. |
| Parallel targets | integer | `4` | How many search terms to work on at the same time. Higher is faster, but Amazon serves fewer complete results when pushed hard. Leave at 4 unless you have a reason. |

### Output fields

| Field | Type | Description |
| --- | --- | --- |
| `keyword` | string | The search term that found this result. |
| `marketplace` | string | The Amazon marketplace this result came from. |
| `page` | integer | Which block of results it appeared in. |
| `position` | integer | Position exactly as Amazon displayed it, ads included. |
| `organicPosition` | integer | null | Position with paid placements removed. `null` for a sponsored result. |
| `isSponsored` | boolean | Whether this is a paid placement. |
| `asin` | string | Amazon's product identifier. |
| `title` | string | Full product title, not the shortened version. |
| `url` | string | Clean link to the product, free of tracking. |
| `image` | string | Product image shown in the results. |
| `price` | number | null | Current price. `null` when Amazon shows no price for that product. |
| `currency` | string | null | Currency the price was published in, read from Amazon itself. |
| `listPrice` | number | null | Struck-through list price, when Amazon shows one. |
| `typicalPrice` | number | null | Amazon's "typical price" market average, kept separate from a real list price so no invented discount appears. |
| `rating` | number | null | Average star rating out of 5. |
| `ratingsCount` | integer | null | How many customers rated it — a much larger number than the count of written reviews. |
| `boughtInPastMonth` | string | null | Amazon's "N+ bought in past month" badge text. |
| `isPrime` | boolean | Prime eligibility as shown on the result. |
| `isAmazonsChoice` | boolean | Carries Amazon's Choice / Overall Pick badge. |
| `isBestSeller` | boolean | Carries the Best Seller badge. |
| `badge` | string | null | Any other badge text on the result. |
| `deliveryText` | string | null | The delivery promise Amazon printed. |
| `variantCount` | integer | null | How many size/colour options the listing offers. |
| `detailsIncluded` | boolean | Whether the complete product record was attached to this row. |
| `scrapedAt` | string | ISO timestamp of collection. |

### Pricing

Pay-per-event. You are billed for what you actually receive.

| You are charged | When |
| --- | --- |
| **$0.60 per 1,000 search results** | For every result written to the dataset. |
| **$1.00 per 1,000 full product records** | Only when *Include full product details* is on, and only for results whose complete product record was successfully attached. |

**Worked example.** Five search terms at 200 results each gives 1,000 rows and
costs **$0.60**. Turn on full product details and those same 1,000 rows carry
the complete product record for **$1.60** in total. Rows whose deeper record
could not be collected are still delivered, still flagged, and are not charged
the second event.

### Limits & what this actor cannot do

- Amazon publishes a limited set of public results for any one search term — a
  few hundred at most. A larger limit returns what Amazon actually makes
  available rather than an unlimited catalogue. Amazon's own printed result
  count is a rough estimate and is deliberately not reported as a total.
- Sponsored placements sit inside Amazon's own results. They are flagged so you
  can keep them or exclude them, but they cannot be made to disappear from the
  ordering Amazon actually served.
- Prices, ranks, ratings and stock are a snapshot at the moment of collection
  and keep changing afterwards.
- Prices and availability differ between Amazon marketplaces; results reflect
  the marketplace you select, in that marketplace's own currency.
- Amazon does not publish a price for every product in a results list. Those
  products come back with an empty price rather than a guess, and they are not
  returned at all when a price filter is set.
- Products that are removed, restricted or unavailable in the selected
  marketplace are reported as unavailable rather than returned empty.
- Customer questions and answers are not publicly listed and are not returned.
- Speed depends on the size of the job and on Amazon's own response times; no
  fixed throughput is promised.
- Amazon's terms govern automated access. You are responsible for using the
  data lawfully and in line with the source site's terms, and for handling any
  personal data in line with applicable privacy law.

### FAQ

**Do I need an Amazon account?**
No. The actor only reads what Amazon publishes to anyone.

**Does it need my login or password?**
No, and there is nowhere to enter one.

**Can I schedule it?**
Yes. Schedule it on Apify like any other actor and diff the output over time to
watch rank and price move.

**Is the data complete?**
It is complete for what Amazon publicly serves. Amazon caps how deep any one
search goes, so very large targets return the few hundred results Amazon
actually makes available rather than an entire catalogue.

**Why do some results have no price?**
Because Amazon showed none. That happens on real listings, and the actor
reports it honestly rather than substituting a delivery fee or a related
product's price.

**What is the difference between `position` and `organicPosition`?**
`position` is where Amazon displayed the result, ads included. `organicPosition`
counts only unpaid results, so it is the rank your listing holds on merit.
Sponsored results have no organic position.

# Actor input Schema

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

One or more search terms. Each is searched separately and every result says which keyword found it.

## `maxResultsPerKeyword` (type: `integer`):

Stop after this many results for each keyword.

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

How Amazon should order the results before they are collected.

## `excludeSponsored` (type: `boolean`):

Drop paid placements and keep only organic results. When off, sponsored results are kept and clearly flagged.

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

Only return products at or above this price, in the marketplace's own currency. Leave empty for no minimum.

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

Only return products at or below this price. Leave empty for no maximum.

## `minRating` (type: `integer`):

Only return products rated at least this many stars. Amazon offers whole-star steps only.

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

Only return products flagged as Prime eligible.

## `includeProductDetails` (type: `boolean`):

Open each search result to collect the complete product record — full specifications, every image, the full rating breakdown and category rankings. Much slower and billed separately; leave off for a fast list.

## `marketplace` (type: `string`):

Which country's Amazon site to read. Prices, availability and rankings differ between marketplaces, and results come back in that marketplace's own currency.

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

How many targets to work on at the same time. Higher is faster but Amazon serves fewer complete pages when pushed hard. Leave at 4 unless you have a reason.

## Actor input object example

```json
{
  "keywords": [
    "wireless earbuds",
    "standing desk"
  ],
  "maxResultsPerKeyword": 50,
  "sortBy": "relevance",
  "excludeSponsored": false,
  "primeOnly": false,
  "includeProductDetails": false,
  "marketplace": "us",
  "maxConcurrency": 4
}
```

# Actor output Schema

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

Every row this run produced.

## `runSummary` (type: `string`):

What this run collected, and anything it could not read.

# 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",
        "standing desk"
    ],
    "maxResultsPerKeyword": 50,
    "sortBy": "relevance",
    "excludeSponsored": false,
    "primeOnly": false,
    "includeProductDetails": false,
    "marketplace": "us",
    "maxConcurrency": 4
};

// Run the Actor and wait for it to finish
const run = await client.actor("apt_marble/amazon-search-results-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",
        "standing desk",
    ],
    "maxResultsPerKeyword": 50,
    "sortBy": "relevance",
    "excludeSponsored": False,
    "primeOnly": False,
    "includeProductDetails": False,
    "marketplace": "us",
    "maxConcurrency": 4,
}

# Run the Actor and wait for it to finish
run = client.actor("apt_marble/amazon-search-results-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",
    "standing desk"
  ],
  "maxResultsPerKeyword": 50,
  "sortBy": "relevance",
  "excludeSponsored": false,
  "primeOnly": false,
  "includeProductDetails": false,
  "marketplace": "us",
  "maxConcurrency": 4
}' |
apify call apt_marble/amazon-search-results-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,apt_marble/amazon-search-results-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/14v5PkjPvpRKe3lnV/builds/dwp39fsBTurQ5IwAb/openapi.json