# Amazon Search Results Scraper — Full Product Row, Flat Fee (`steadyfetch/amazon-search-scraper`) Actor

Amazon search: type a keyword and get full product detail for every result — price, buy box, stock, rating, reviews, variants, bestseller ranks, images and specs. From $3.00 per 1,000 products, one flat fee, no add-on events. Blocked or empty searches are never charged.

- **URL**: https://apify.com/steadyfetch/amazon-search-scraper.md
- **Developed by:** [Steadyfetch Team](https://apify.com/steadyfetch) (community)
- **Categories:** E-commerce, Automation, Developer tools
- **Features:** Limited permissions, Multi-tenant, Server interface
- **Stats:** 4 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 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?

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 Results Scraper — Full Product Row, 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.**

**Using an AI agent?** Pin this actor in Apify's MCP server with one link: `https://mcp.apify.com?tools=steadyfetch/amazon-search-scraper`

- **Actor id:** `steadyfetch/amazon-search-scraper`
- **Input:** `{ "keywords": ["wireless earbuds"] }` — the one field to set.
- **Cap the bill:** set `maxTotalChargeUsd` on the run (a run option, not Actor input), e.g. `0.50` — the run stops when it reaches it.
- **Price:** from **$3.00** per 1,000 products on Silver and above, $6.00 per 1,000 on the Apify Free plan — one priced event, `Product`, and nothing else. A sponsored result costs the same flat fee as any other, and turning sponsored results off means they are never even fetched. No start fee, and a blocked or empty search is never charged. Full ladder below.
- **How often it changes:** a search page reshuffles daily — new sellers enter, prices move, sponsored slots turn over hour to hour — so the same keyword read tomorrow is a different ranking, which is what makes this a scheduled job rather than a one-off. Every run fetches fresh, at the same flat fee per product.

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

**Just want to see it work?** Click **Start** with nothing set and the run searches `amazon.com` for `wireless earbuds` and returns up to 5 real products, charged like any run at your plan's per-product price. Set only settings — a different **Marketplace**, a **Sort by**, a **Department**, a limit — and leave **Keywords** empty, and that same sample search runs under your settings, charged like any run. Put your own keywords in **Keywords** for your own run.

![Amazon Search Scraper input form in the Apify console: the Keywords list prefilled with wireless earbuds and coffee maker](https://api.apify.com/v2/key-value-stores/wciMDNpNgBh87mGUp/records/amazon-search-scraper--input-form.png)

> **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

![Dataset table of a real run: five wireless-earbuds results ranked 1 to 5, each with brand, price, list price, stock, rating and review count](https://api.apify.com/v2/key-value-stores/wciMDNpNgBh87mGUp/records/amazon-search-scraper--dataset-table.png)

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": "Electronics Expo (Authorized Dealer)",
  "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. **The rows arrive in that order too**, keyword by keyword, with uncharged misses sitting at their own rank rather than at the end. 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 Sold-by cluster (`buyBoxSeller`, `buyBoxSellerId`, `fulfilledByAmazon`, `soldByAmazon`) works the same way: read from whichever layout Amazon serves, and when a served page names no seller at all, those four come back null and `buyBoxNote` says so on that row.

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/Qk0sWCTy6mRWBssZ9/items?clean=true\&format=json) — `coffee maker` on `amazon.com`, capped at two products, plus the summary row it ended with; a verified run of the current code, Sold-by cluster populated on both rows.

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 an optional field or send it as null — both mean "use the default", the
       "marketplace" and "sortBy" dropdowns included. A value they do not offer is not
       silently swapped for the default: the run returns one uncharged row naming the
       values that work. "keywords" is the one field that must carry a real value.
       Limits are hard limits.
```

Works over the Apify API, MCP, n8n and Make. A bare **Start** with nothing set runs the sample search described at the top of this page, charged like any run, so you can see the exact output shape before wiring your own list — and setting only settings, with no keywords, runs that sample under them, with one uncharged row naming what you set.

**MCP**: pinned with the one link at the top of this page — or ask Apify's MCP server for "amazon search".

### Use it as an API endpoint (Standby)

You can also call this actor like an API: send a keyword and get the full product row for each result back in the same response, with no run to start and no dataset to read. The address is `https://steadyfetch--amazon-search-scraper.apify.actor`, and the actor's **Endpoints** tab lets you try it from the browser.

```bash
curl -H "Authorization: Bearer <YOUR_APIFY_TOKEN>" \
  "https://steadyfetch--amazon-search-scraper.apify.actor/?keywords=wireless+earbuds&maxProductsPerKeyword=1"
```

Or POST the same input a run takes:

```bash
curl -X POST -H "Authorization: Bearer <YOUR_APIFY_TOKEN>" -H "Content-Type: application/json" \
  -d '{"keywords": ["coffee maker"], "maxProductsPerKeyword": 5, "sortBy": "avg-review"}' \
  "https://steadyfetch--amazon-search-scraper.apify.actor/"
```

The answer is JSON: `rows` (one per product, with the same fields as a row in a run's dataset, keyword and search rank included), `receipt` (the run's closing summary row), `delivered`, `charged`, and `notes` for anything you should know, in plain words. You are charged exactly as in a run — one `Product` per delivered product row — and a search with no results, a blocked search or a product that could not be read is never charged. If the charge for a request cannot be completed, its products are not sent.

Good to know: the endpoint answers up to 2 keywords and 10 products per request (1 keyword and 3 products on the Apify free plan). A bigger ask is answered at that cap, and a note in the answer says so; a longer list is a run's job. In a GET, send one `keywords=` per search (a comma or a space is part of the search). The endpoint keeps no memory between requests, exactly like a run: a search you run again is fetched fresh and charged again. It does not read a `datasetId` or a `resumeFromDatasetId` — it cannot see your Apify account. A request that runs out of time sends what it already has, uncharged for anything it did not reach.

### 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 $3.00/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.003 | $3.00 |
| **Gold, Platinum, Diamond** | **$0.003** | **$3.00** |

The header shows the Gold price, which Silver pays too. 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** 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, or held a link that is not an Amazon search this actor can run (a link to another website, a product link, or a search on another store or with filters it cannot apply) — 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` |
| `sample_note` | You set settings but no keywords, so the sample search ran under them — the row names what you set | no | — |
| `input_note` | A limit you set was outside what this actor can do in one run, so the run continued at the nearest value it can — the row names your ask and the ceiling. Also used when an Amazon search link in Keywords was read as its search words — the row names the words searched | no | — |

### Limits are exact

**Asking for more than the ceiling is not an error.** `Max products per keyword` goes up to 100 (three result pages), `Max products (whole run)` up to 5,000, and `Max run seconds` runs from 60 to 21,600 — ask outside any of them and the run continues at the nearest value it can, with one uncharged `input_note` row naming what you asked for and what bound. It is never refused and the run never fails to start.

`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 $3.00/1,000 on Silver 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.

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 ASIN Scraper — Full Product Row per ASIN, Flat Fee](https://apify.com/steadyfetch/amazon-product-scraper) |
| Search keywords | **this actor** |
| A Best Sellers category | [Amazon Best Sellers Scraper — Top 60 Ranks, Full Product Row](https://apify.com/steadyfetch/amazon-bestsellers-scraper) |
| A seller ID or storefront | [Amazon Sellers Scraper — Profile + Live Listings, Flat Fee](https://apify.com/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](https://apify.com/steadyfetch/breakout-keywords-scraper) · [Autocomplete keywords](https://apify.com/steadyfetch/google-keyword-suggest-scraper) · [Keyword volume & CPC](https://apify.com/steadyfetch/keyword-search-volume-scraper) · [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](https://apify.com/steadyfetch/instagram-profile-posts) |
| Jobs | [Indeed](https://apify.com/steadyfetch/indeed-jobs-scraper) · [Career sites by domain](https://apify.com/steadyfetch/company-jobs-by-domain) · [Glassdoor](https://apify.com/steadyfetch/glassdoor-jobs-scraper) · [Multi-board](https://apify.com/steadyfetch/multi-job-board-scraper) · [Google Jobs](https://apify.com/steadyfetch/google-jobs-scraper) |
| **Amazon** | [Products](https://apify.com/steadyfetch/amazon-product-scraper) · [Search](https://apify.com/steadyfetch/amazon-search-scraper) · [Bestsellers](https://apify.com/steadyfetch/amazon-bestsellers-scraper) · [Sellers](https://apify.com/steadyfetch/amazon-seller-scraper) |
| Any media file | [Speech to Text · any link or file](https://apify.com/steadyfetch/media-transcriber) |

### Feedback & support

Found an issue? Open it on the **Issues tab** — we usually reply within a couple of hours, always within a day. Include the keyword you used. Fields that come back empty when they should not are treated as bugs, not as expected behaviour. If it earned its keep, a rating helps other buyers find it, and saving the actor keeps it one click away.

# Changelog

This Actor's version history is a separate document: https://apify.com/steadyfetch/amazon-search-scraper/changelog.md

# Actor input Schema

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

Amazon search terms, e.g. \["wireless earbuds", "coffee maker"] — any number, one search each. A keyword Amazon returns nothing for, and a search a robot check blocked, are never charged: both come back as a row saying which. An ASIN or product link belongs in steadyfetch/amazon-product-scraper, a Best Sellers link in steadyfetch/amazon-bestsellers-scraper, a seller id or storefront in steadyfetch/amazon-seller-scraper. Send the field as a list — leaving it out is fine, but this one field cannot be null. Every optional field below accepts null — the Marketplace and Sort by dropdowns included — and null there simply means "use the default". A dropdown value that is not on its list is answered with one uncharged row naming the values that work, never quietly swapped for the default. Leave this untouched and click Start to run a 5-product sample search ("wireless earbuds" on amazon.com).

## `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. The domain, the country code or the country name all work — amazon.co.uk, GB and United Kingdom are the same store. Null or empty means amazon.com; a store that is not on this list is answered with one uncharged row naming the stores that are.

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

How many products to return for each keyword, taken in Amazon's own result order across up to 3 result pages. Up to 100 — ask for more and the run continues at 100, with one uncharged row saying so.

## `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. The value or the name of the order both work — price-asc and "Price: low to high" are the same sort. Null or empty means Featured; a sort that is not on this list is answered with one uncharged row naming the ones that are.

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

Hard cap on delivered products across all keywords. 0 means no run-wide cap. Up to 5,000 per run — ask for more and the run continues at 5,000, with one uncharged row saying so.

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

The run stops cleanly before this and reports what is left, instead of being killed by the platform timeout. Between 60 and 21,600 seconds — ask outside that and the run continues at the nearest of the two, with one uncharged row saying so.

## `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": 10,
  "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"
    ],
    "maxProductsPerKeyword": 10
};

// 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",
    ],
    "maxProductsPerKeyword": 10,
}

# 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"
  ],
  "maxProductsPerKeyword": 10
}' |
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/9ofpyhUk7X5f8FqtG/openapi.json