# Amazon Search Scraper · Flat Fee (`steadyfetch/amazon-search-scraper`) Actor

One flat fee per product, full detail on every search result, no add-on events. Blocked or empty searches are never charged. Type a keyword, get products.

- **URL**: https://apify.com/steadyfetch/amazon-search-scraper.md
- **Developed by:** [Steadyfetch Team](https://apify.com/steadyfetch) (community)
- **Categories:** E-commerce, Automation, MCP servers
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.50 / 1,000 products

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?

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 Scraper · Flat Fee

**Type an Amazon search keyword and get the full product row for every result — price, buy box, stock, rating, reviews, variants, bestseller ranks, images and the full specifications table, all in one row. One flat fee per product. There is no second event to pay for, and blocked or empty searches are never charged.**

Give it a keyword like `wireless earbuds`. Get finished product objects back — not a list of links you then have to feed somewhere else.

> **Unofficial.** This actor is not affiliated with, endorsed by, or sponsored by Amazon. "Amazon" and all related marks are trademarks of Amazon.com, Inc. or its affiliates. It reads only the public search pages an ordinary browser sees, and never signs in.

### Output

One row per product: every field the product page carries, plus the search context. This is a real row from a verified run, trimmed with `…` where a field is long:

```json
{
  "keyword": "wireless earbuds",
  "searchRank": 1,
  "isSponsored": false,
  "searchPage": 1,
  "asin": "B0DN4BG1RW",
  "marketplace": "amazon.com",
  "url": "https://www.amazon.com/dp/B0DN4BG1RW",
  "title": "JBL Vibe Beam 2 - Noise Cancelling Earbuds - White",
  "brand": "JBL",
  "price": 39.94,
  "currency": "USD",
  "listPrice": 64.95,
  "inStock": true,
  "buyBoxSeller": "Amazon.com",
  "rating": 4.1,
  "reviewCount": 6717,
  "boughtInPastMonth": 2000,
  "images": ["https://m.media-amazon.com/images/I/41CpD7mn8tL._AC_SL1200_.jpg", "…"],
  "variants": [{ "asin": "B0DBLMLM81", "attributes": { "color_name": "Blue" } }],
  "categoryPath": ["Electronics", "Headphones, Earbuds & Accessories"],
  "bestSellersRank": [{ "rank": 63, "category": "Electronics" }],
  "specs": { "Brand Name": "JBL", "…": "…" },
  "scrapedAt": "2026-08-27T00:00:00.000Z",
  "charged": true,
  "status": "ok"
}
```

`searchRank` is the product's position in Amazon's own result order, counting every result including sponsored ones — so it stays accurate even when you filter sponsored rows out. A product that matches several of your keywords is returned **once**, tagged with the first keyword that surfaced it, and charged once.

Prices and review counts are parsed in the page's own locale, so `4,4 von 5 Sternen` is a rating of 4.4 and `(4.295)` on amazon.de is four thousand reviews, not four. **`price` can legitimately be `null`** — Amazon does not always print one, and that row still carries the title, rating, ranks, images and specs, with `priceNote` saying what the page showed instead.

The last row of every run is a summary carrying `keywords`, `ok`, `keywordMisses`, `productMisses`, `chargedRows` and `unchargedRows` — so the invoice reconciles from the dataset itself, without opening the billing tab.

**See a whole real run before you spend anything:** [sample dataset](https://api.apify.com/v2/datasets/1SAiTgjbUdEo80ceo/items?clean=true\&format=json) — `wireless earbuds` on `amazon.com`, capped at two products, plus the summary row it ended with.

Every delivered row also carries two hidden fields, `#k` and `#ce`: the product's stable key and the exact events that row was charged. They stay out of the Output tab and out of a `clean` export; they are there so that if Apify moves your run to another server mid-way, or you resurrect a finished run, the run reads its own dataset back and never delivers or bills the same product twice.

### For AI agents & LLMs — copy this block

```
Actor: steadyfetch/amazon-search-scraper
Input: { "keywords": ["wireless earbuds", "coffee maker"], "maxProductsPerKeyword": 20 }
Output: one row per product; charged rows have status "ok" and charged true.
Pricing: one priced event ("product"), all-inclusive, no start fee, no add-ons.
Misses: no_results / blocked / not_found / unavailable_in_marketplace / not_a_product /
        parse_failed / source_unavailable all ship as rows with charged:false — read `status`.
Notes: omit a field you do not want — do not send null. Limits are hard limits.
```

Works over the Apify API, MCP, n8n and Make. Running it with an empty keyword list returns uncharged sample rows, so a workflow can be wired up and tested before it costs anything.

### What one product costs

One priced event, `Product`, and nothing else. No start fee, no per-keyword fee, no per-field fee, no "detail" upcharge. A sponsored result costs the same flat fee as any other — and if you turn sponsored results off, they are never even fetched. The store header reads **from $1.50/1,000 products**.

| Your Apify plan | Price per product | Per 1,000 products |
|---|---|---|
| Apify Free plan | $0.006 | $6.00 |
| Bronze | $0.0035 | $3.50 |
| Silver | $0.0022 | $2.20 |
| **Gold, Platinum, Diamond** | **$0.0015** | **$1.50** |

The header shows the Gold price. The whole ladder is printed here because an actor whose promise is billing honesty cannot have an undisclosed tier ladder.

**What can fail, and what a failure costs you: nothing.** The two misses you will actually see are `no_results` (the search ran fine and Amazon had nothing for that keyword) and `blocked` (a robot check in front of every route we tried). Both ship as real rows carrying `charged: false`, as do `not_found`, `unavailable_in_marketplace`, `not_a_product`, `parse_failed`, `source_unavailable` and `invalid_input`. A row is charged only if it is a product.

### Full product detail on every result — on purpose

This actor always returns the **full** product object for each result: the same row **Amazon Product Scraper · Flat Fee** returns, plus the keyword, the search rank, whether it was sponsored, and the result page it came from. There is deliberately no cheaper "listing rows only" mode — that would need a second price, and this family sells one thing at one price.

### What you give it

| Input | Example |
|---|---|
| `keywords` (one per line) | `wireless earbuds`, `coffee maker` |
| `marketplace` | `amazon.com` (default), `amazon.co.uk`, `amazon.de` |
| `maxProductsPerKeyword` | `40` (default) — taken in Amazon's own result order, across up to 3 result pages |
| `includeSponsored` | `true` (default); set `false` to skip ads — they are never fetched, so they cost nothing |
| `department` | `electronics` (optional) |
| `sortBy` | Featured (default), price, avg. review, newest |

**Marketplaces: `amazon.com`, `amazon.co.uk`, `amazon.de`.** Search is verified end to end on `amazon.com`; `amazon.co.uk` and `amazon.de` are best-effort. Only three because only three are tested; other Amazon domains are refused with a clear message rather than half-working.

### Error codes — what each uncharged row means

| `status` | What happened | Charged | Worth re-running |
|---|---|---|---|
| `ok` | Complete product row | yes | — |
| `no_results` | The search ran fine but Amazon returned no products for that keyword | no | no |
| `blocked` | Amazon asked us to prove we are not a robot, on every route we tried | no | yes |
| `not_found` | A result's product page — or the search address itself — answered "page not found" | no | no |
| `unavailable_in_marketplace` | A result's id was not served in that country's catalogue | no | no |
| `not_a_product` | A result is one of Amazon's own subscription plans, not a product listing — no price, no seller, no reviews of its own | no | no |
| `parse_failed` | Amazon served a page in a layout we do not recognise. That one is on us | no | no |
| `source_unavailable` | Amazon dropped or throttled the request | no | yes |
| `invalid_input` | A keyword line was blank — the row says so | no | no |
| `cap_reached` / `stopped_at_limit` | A limit you set stopped the run; earlier rows were delivered normally | no | see `resumeCursor` |

### Limits are exact

`Max products per keyword`, `Max products (whole run)`, `Max run seconds` and the run's own maximum total charge all stop the run *cleanly*: it still finishes as SUCCEEDED, the summary row names the one setting that stopped it, and `resumeCursor` lists the keywords still to do. Re-running a search fetches from the top, so raise the limit rather than re-running to page deeper.

### FAQ

**Is it legal to scrape Amazon search results?** Public search pages are public. This actor reads only what an ordinary browser sees, at a polite rate; it never signs in and never touches an account.

**Can I scrape Amazon search without an API key?** Yes — that is what this is. No Amazon account, no PA-API keys, no seller credentials.

**How do I get Amazon search data into n8n or Make?** Run this actor and read its dataset. One row per product, stable column names, `charged` on every row.

**What does it cost per 1,000 products?** From $1.50/1,000 on Gold and above; see the ladder above. Nothing else is billable.

**Why is a price null, or in the wrong currency?** Amazon did not print one, or served the page from an unexpected region — `priceNote` says which. The delivery location is pinned to the marketplace's own country to keep this rare.

### Honesty contract

Amazon changes its pages often. When a keyword can't be searched, or an item can't be fetched or parsed, we return it with an honest status and **never charge for it**.

This actor may fail when the platform changes things — failed items are never charged.

Issues are answered in about three hours during working hours. If a field ever comes back empty that should not be, open an issue with the keyword and it gets fixed.

### Steadyfetch Amazon suite

One actor per entry point, the same product row underneath. All-inclusive pay per event, no start fee,
charged only on delivery.

| What you paste | Actor |
|---|---|
| ASINs or product URLs | [**Amazon Product Scraper · Flat Fee**](https://apify.com/steadyfetch/amazon-product-scraper) |
| Search keywords | **this actor** |
| A Best Sellers category | **Amazon Bestsellers · Flat Fee** *(publishing soon — `steadyfetch/amazon-bestsellers-scraper`)* |
| A seller ID or storefront | **Amazon Seller Scraper · Flat Fee** *(publishing soon — `steadyfetch/amazon-seller-scraper`)* |

**The rest of the steadyfetch shelf** — same contract everywhere: all-inclusive pay per event,
no start fee, charged only on delivery.

| Family | Actors |
|---|---|
| Ad creative intelligence | [Facebook](https://apify.com/steadyfetch/facebook-ads-transcript-scraper) · [Google Ads video](https://apify.com/steadyfetch/google-ads-video-transcript-scraper) · [TikTok](https://apify.com/steadyfetch/tiktok-ads-transcript-scraper) · [LinkedIn](https://apify.com/steadyfetch/linkedin-ads-transcript-scraper) · [Google Ads text & OCR](https://apify.com/steadyfetch/google-ads-creative-text-scraper) |
| Trends & keywords | [Google Trends](https://apify.com/steadyfetch/google-trends-scraper) · [Trends Now](https://apify.com/steadyfetch/google-trends-now-scraper) · Breakout keywords · Autocomplete keywords · Keyword volume & CPC · [Social trends](https://apify.com/steadyfetch/social-trends-scraper) |
| YouTube transcripts | [YouTube videos](https://apify.com/steadyfetch/youtube-transcript-scraper) · [YouTube channels](https://apify.com/steadyfetch/youtube-channel-transcripts) |
| Instagram | [Reel transcripts](https://apify.com/steadyfetch/instagram-reel-transcript-scraper) · Profile posts |
| Jobs | Indeed · Career sites by domain · Glassdoor · Multi-board |
| **Amazon** | **Products · Search · Bestsellers · Sellers** |
| Any media file | [Speech to Text](https://apify.com/steadyfetch/media-transcriber) · any link or file |

Unlinked names are publishing shortly on the same account — search **steadyfetch** on Apify Store.

### Feedback & support

Open an issue on the actor's Issues tab with the keyword you used. Fields that come back empty when they should not are treated as bugs, not as expected behaviour.

# Actor input Schema

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

Amazon search terms, e.g. "wireless earbuds". Send the field as a list — an omitted field is fine, but do not send null.

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

Which Amazon store to search. Amazon runs a separate catalogue per country. Search is verified end to end on amazon.com; amazon.co.uk and amazon.de are best-effort.

## `maxProductsPerKeyword` (type: `integer`):

How many products to return for each keyword, taken in Amazon's own result order across up to 3 result pages.

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

Sponsored (ad) results are included and flagged with isSponsored. Turn this off to skip them — they are never fetched, so a skipped sponsored result costs nothing.

## `department` (type: `string`):

Narrow the search to a department, e.g. electronics or kitchen. Leave empty to search all departments.

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

How Amazon orders the results. Featured is Amazon's own default order.

## `maxItems` (type: `integer`):

Hard cap on delivered products across all keywords. 0 means no run-wide cap.

## `maxRunSeconds` (type: `integer`):

The run stops cleanly before this and reports what is left, instead of being killed by the platform timeout.

## `includeVariants` (type: `boolean`):

Every colour, size or flavour of each product, with its own ASIN. Turn off for a smaller row; the price does not change.

## `includeSpecs` (type: `boolean`):

The product-details table (brand, model, dimensions, materials and so on). Turn off for a smaller row; the price does not change.

## Actor input object example

```json
{
  "keywords": [
    "wireless earbuds",
    "coffee maker"
  ],
  "marketplace": "amazon.com",
  "maxProductsPerKeyword": 40,
  "includeSponsored": true,
  "sortBy": "relevance",
  "maxItems": 0,
  "maxRunSeconds": 3600,
  "includeVariants": true,
  "includeSpecs": true
}
```

# Actor output Schema

## `products` (type: `string`):

One row per product found for your keywords: the keyword, its search rank, whether it was sponsored, plus price, currency, list price, stock, buy-box seller, rating, reviews, bought-last-month, variants, bestseller ranks, category path, images, bullet points and the specifications table. Every row carries `charged` and `status`, so the invoice reconciles from the dataset itself.

## `unchargedRows` (type: `string`):

Keywords that returned nothing or were blocked, and individual products that could not be fetched. Each says which it was, whether re-running is worth it, and none of them were charged.

## `summary` (type: `string`):

Products delivered, keywords that returned nothing, products that could not be fetched, duplicates merged, what stopped the run, and the charged-event totals.

## `errors` (type: `string`):

Present only when Amazon blocked, throttled or dropped a request after every route was tried: the keyword or product and the reason. These are re-runnable, not permanent.

# 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",
        "coffee maker"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("steadyfetch/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",
        "coffee maker",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("steadyfetch/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",
    "coffee maker"
  ]
}' |
apify call steadyfetch/amazon-search-scraper --silent --output-dataset

```

## MCP server setup

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