# Amazon Search Results Scraper: Full Product Records (`amazonscrapers/amazon-search-results-scraper`) Actor

Search Amazon and get the complete product record behind every result, not the thin summary the search page shows. 64 fields per product including units bought last month, every bestseller rank, specifications and variants. 19 marketplaces.

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

## Pricing

from $4.00 / 1,000 products with a prices

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/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 results scraper: 64 fields per result, not search snippets

Type what a shopper would type. Get back every result with the complete product
record behind it, not the thin summary Amazon prints on the search page.

Amazon's search results carry a name, a price and a star rating. That is enough
to render a list and not enough to decide anything. This Actor walks the results,
then opens each product and reads it properly: sixty-four fields, including the
ones that only exist one level down.

### What only exists one level down

These are the fields a search-page scraper structurally cannot give you, because
they are not on the search page at any price.

**Units, not just rank.** `boughtInPastMonth` is Amazon's own figure, printed on
the product page and nowhere on the search page.

**Every bestseller rank.** `bestsellerRanks`, one per category level, with the
category names.

**The physical product.** `weight`, `dimensions`, `gtin`, `modelNumber`,
`material`, and the full `specifications` table merged from all eight of Amazon's
detail tables.

**The family.** `variantAsins`, `variantAttributes`, `variantCount`. A search
result that looks like one product is often fourteen.

**The real price picture.** `listPrice`, `savingsAmount`, `discountPercent`,
`coupon`, `dealBadge`, `pricePerUnit`. The search page shows one number; the
product page shows what that number means.

**Delivery and terms.** `deliveryInfo`, `returnPolicy`, `isPrime`,
`otherSellersCount`.

**The media.** `images`, `imageCount`, `videoCount`, `hasAPlusContent`,
`description`, `features`. What the listing actually looks like, which is the
thing you are competing against.

### Every field it returns

All sixty-four, with the third column marking which ones Amazon already puts on
the search page and which ones only exist on the product page. Fifty-one of the
sixty-four are in that second group, and they are the reason this Actor opens
every result instead of scraping the list.

#### Price and offer

| Field | What it holds | Where it lives |
| --- | --- | --- |
| `price` | Current price from Amazon's own buy box data **(this is what you are charged for)** | search page too |
| `listPrice` | The struck-through price, when Amazon shows one | **product page only** |
| `savingsAmount` | How much is off in money | **product page only** |
| `discountPercent` | How much is off as a percentage | **product page only** |
| `currency` | Three-letter code, from the page itself | search page too |
| `pricePerUnit` | Price per count, ounce, litre, whatever Amazon uses | **product page only** |
| `priceSource` | Where the price came from, so you can audit it | **product page only** |
| `isDiscounted` | Whether it is currently below list price | **product page only** |
| `coupon` | The clip-coupon text, when there is one | **product page only** |
| `dealBadge` | Lightning deal, limited time deal, and similar | search page too |
| `hasSubscribeAndSave` | Whether a subscription price exists | **product page only** |
| `hasUsedOffer` | Whether a used copy is offered | **product page only** |
| `isRefurbished` | Renewed and refurbished listings | **product page only** |
| `otherSellersCount` | How many other sellers offer it | **product page only** |

#### Demand and rank

| Field | What it holds | Where it lives |
| --- | --- | --- |
| `boughtInPastMonth` | Units bought last month as a number | **product page only** |
| `boughtInPastMonthText` | Amazon's own wording, such as 10K+ bought in past month | search page too |
| `estimatedMonthlySales` | Units, derived from the line above | **product page only** |
| `estimatedMonthlyRevenue` | Units times price | **product page only** |
| `bestsellerRanks` | Every rank with its category, not just the first | **product page only** |
| `isBestSeller` | The orange best seller badge | **product page only** |
| `isAmazonChoice` | The Amazon's Choice badge | **product page only** |
| `rating` | Average stars, read in every shop language | search page too |
| `reviewCount` | How many ratings, as a number | search page too |

#### Stock and delivery

| Field | What it holds | Where it lives |
| --- | --- | --- |
| `inStock` | True, false, or null when Amazon does not say | **product page only** |
| `availability` | Amazon's own availability sentence | **product page only** |
| `stockLeft` | Only three left in stock, when shown | **product page only** |
| `deliveryInfo` | The delivery date Amazon promises | **product page only** |
| `returnPolicy` | The return terms in full | **product page only** |
| `isPrime` | Prime delivery on this offer | search page too |

#### Identity and catalogue

| Field | What it holds | Where it lives |
| --- | --- | --- |
| `asin` | The product id | search page too |
| `parentAsin` | The parent listing, for variant families | **product page only** |
| `title` | Full product title, shortened only past 1000 characters | search page too |
| `brand` | Brand name | **product page only** |
| `manufacturer` | Manufacturer, when different from brand | **product page only** |
| `modelNumber` | Model number | **product page only** |
| `partNumber` | Manufacturer part number | **product page only** |
| `gtin` | GTIN, EAN or UPC | **product page only** |
| `marketplace` | Which shop this row came from | search page too |
| `url` | The page this was read from | search page too |
| `scrapedAt` | Timestamp of the read | search page too |

#### Description, media and variants

| Field | What it holds | Where it lives |
| --- | --- | --- |
| `description` | The product description under the fold, as plain text | **product page only** |
| `features` | The bullet points at the top | **product page only** |
| `image` | Main image at the largest size Amazon offers | search page too |
| `images` | Every gallery image, largest version first | **product page only** |
| `imageCount` | How many images there are | **product page only** |
| `videoCount` | How many videos are on the page | **product page only** |
| `hasAPlusContent` | Whether the brand added enhanced content | **product page only** |
| `variantAsins` | Sibling products in the variant family | **product page only** |
| `variantCount` | How many variants there are | **product page only** |
| `variantAttributes` | What varies, such as size and colour | **product page only** |
| `category` | The most specific category | **product page only** |
| `categories` | The full breadcrumb path | **product page only** |

#### Specifications, pulled apart

| Field | What it holds | Where it lives |
| --- | --- | --- |
| `specifications` | Every row of every detail table, merged | **product page only** |
| `productFacts` | Amazon's newer facts panel | **product page only** |
| `weight` | Weight with its unit | **product page only** |
| `dimensions` | Package or product dimensions | **product page only** |
| `colour` | Colour | **product page only** |
| `material` | Material | **product page only** |
| `unitCount` | How many units in the pack | **product page only** |
| `firstAvailable` | Date first available on Amazon | **product page only** |
| `countryOfOrigin` | Country of origin | **product page only** |
| `warranty` | Warranty description | **product page only** |
| `importantInformation` | Safety and legal text, when present | **product page only** |
| `isClimatePledgeFriendly` | The Climate Pledge Friendly badge | **product page only** |

### A real row

```
asin                     B0BZYCJK89
title                    Owala FreeSip Stainless Steel Water Bottle 24 oz
brand                    Owala
price                    27.99
currency                 USD
priceSource              buybox-data
listPrice                34.99
discountPercent          20
otherSellersCount        3
boughtInPastMonth        30000
estimatedMonthlyRevenue  839700
bestsellerRanks          #1 in Water Bottles, #12 in Sports Water Bottles
rating                   4.7
reviewCount              89412
weight                   1.02 pounds
dimensions               3.5 x 3.5 x 10 inches
material                 Stainless Steel
variantCount             34
variantAttributes        ["size", "color"]
imageCount               7
hasAPlusContent          true
inStock                  true
deliveryInfo             Tomorrow, August 27
scrapedAt                2026-08-26T09:14:22.031Z
```

Everything below `rating` in that list is invisible on the search page. That is
the whole difference between this Actor and a search scraper.

### What to put in

**A search term** such as `standing desk converter`. Several at once is fine, and
each row carries the marketplace it came from so you can keep them apart.

**A filtered search URL.** Build the search in your own browser with the filters
you want, paste the address, and this Actor continues from there. That is usually
easier than reproducing Amazon's filter syntax by hand, and Amazon's own filters
are better than anything this Actor could reimplement.

**Category and bestseller links** work as well, and so do plain ASINs.

### Search rank and what it is worth

Rows from the results grid carry `searchPosition`, which is where the product sat
on that grid, counting from one. Rows also come back in the order Amazon returned
them, so the dataset reads the way the page did.

Not every row has one. A search page also shows products outside the grid, in
carousels and in strips like "products related to this search", and this Actor
delivers those too. They have no position on the grid, so they carry no
`searchPosition` and no `isSponsored`. Measured on a real run of 30 August 2026:
six of ten rows came from the grid and carried both fields, four did not. Check
whether the field is there before you rank on it.

Worth knowing: that order is personalised and varies by exit address and by time
of day. Two runs an hour apart can differ. If search position is the thing you
care about, run it repeatedly and treat the pattern as the signal rather than any
single run. Every row carries `scrapedAt` so you can.

**Advertisements are marked.** Grid rows also carry `isSponsored`. This page used
to say that sponsored placements could not be told apart reliably, and that was
wrong: measured on real search pages from amazon.com and amazon.de on 30
August 2026, Amazon marks them in three ways that do not depend on language, and
those are what this Actor reads.

That matters more than it sounds for keyword research. On one real page measured
that day, four of the first five results were advertisements. Treating that as
organic ranking would have been badly misleading, and until this change it was
exactly what you would have got.

Sponsored placements are still included rather than dropped, because for most
questions you want the page as a shopper saw it. Filter on `isSponsored` when you
want organic ranking on its own.

If placements themselves are what you are after rather than full product rows,
the **Amazon Sponsored Products Tracker** does that job at a tenth of the price,
because it never opens a product page.

### It will not guess a price

Amazon puts up to nine price-shaped numbers on a product page. Measured on this
engine: prices read from the markup were correct zero times out of six, prices
from the buy box data Amazon itself uses were correct nine out of nine.

So the price comes from that data and nowhere else. When it is absent you get no
price rather than a wrong one, and the row still arrives with everything else.
`priceSource` records where each price came from.

**You are not charged for a row without a price.** On a broad search that matters:
searches return plenty of subscription pages, apps and listings Amazon does not
price, and you should not pay for those.

### Settings worth knowing about

| Setting | What it does |
| --- | --- |
| `marketplace` | One of nineteen, from `com` to `co.jp`. |
| `proxyCountry` | Leave empty and it follows the marketplace. On a search Actor this also changes which results you get, since Amazon personalises by location. |
| `maxItems` | Hard ceiling across the whole run. Worth setting on a broad search. |
| `maxItemsPerList` | How many results to take per search term. Prefilled at ten so your first click is quick. |
| `maxListPages` | How deep to walk each search. Amazon caps its own search at roughly seven pages. |
| `lanes` | How many products are read at once. Eight by default. Sixteen roughly halves the run time and costs a few prices. |
| `maxAttempts` | Attempts per product, each from a different address. Twelve by default. |
| `residentialFallback` | Off by default. On product pages it buys almost nothing: measured 2026-08-26, it cost roughly six times as much and returned two more products out of sixty. On the search and category pages this Actor starts from, it is a different story. Measured 2026-08-30, during hours when Amazon refused every listing page with a two kilobyte stub, twenty datacenter retries returned nothing and residential returned a full page in eight attempts. Turn it on if a run comes back empty. |
| `economical` | Off by default. On a sixty-four field read it costs you the fields that sit late in the page. |

### How it works, in plain terms

Two jobs in one run. First it walks the search pages and collects the ASINs.
Then it opens every product and reads it properly.

Amazon refuses roughly six requests in ten to an address it has not seen before,
and it refuses search pages as readily as product pages. So every page and every
product gets up to twelve attempts, each from a different exit address, and the
same address is never used twice in a row. Addresses that work are remembered for
the run and tried first. When refusals climb the runner slows down instead of
pushing harder. Anything still refused goes into a second pass at half speed
using the addresses that proved themselves.

The search page needs that protection most: a refused search page costs you every
product behind it. On 26 August 2026 a run came back with zero products because
Amazon answered a listing link with four kilobytes and no error code, which the
engine read as an empty result set. It now recognises a refusal without an error
code and retries it.

### Reading the run log

```
Done: 17 charged (+3 delivered without a price, free), 0 refused by Amazon, 0 other. 1709 KB per charged result, 198 attempts in total.
Exit addresses: 166 used, 2 proven good, 12 burned.
Attempts by outcome: {"refused by Amazon":126,"page did not carry the field this Actor needs":51,"network error":4,"ok":17}
```

`charged` is what you pay for. The bracketed number arrived with all its other
fields and cost you nothing.

If a run ever delivers rows and charges for none of them, the log says so in
capitals at the bottom.

### Reliability, measured

Three consecutive runs of twelve products on 26 August 2026, at the default
settings:

```
run 1   12 of 12 delivered, 9 with a price
run 2   12 of 12 delivered, 12 with a price
run 3   12 of 12 delivered, 8 with a price
```

And one run of sixty products the same day: 58 delivered,
50 with a price, in 12.6 minutes.

One thing is worth reading out of that, and it is not the one you would expect.
The sixty product run delivered 58, which sounds worse than the 36 of 36 above
until you notice what it was asked for: a category page, and Amazon only offered
58 products on it that day. A list Actor is bounded by what the list holds, so
"delivered" here means "everything that was there", not "everything we wanted".

The second is the residential switch, and the honest version is less dramatic
than it sounds. Measured 26 August on the same sixty products, twice: with the
switch off, fifty-one came back with the field this Actor charges on, for $0.0205
of platform usage. With it on, fifty-three came back, for $0.1192. Two more
products for roughly six times the cost.

That is why it is off by default. It is in your input form, so if a marketplace
is refusing almost everything you can turn it on and pay for the difference.

### What you can build with it

**A map of who owns a keyword.** One run per keyword you care about, then compare who
ranks, what they charge and how many reviews they have. That is a competitive
brief rather than a list.

**A listing benchmark.** `imageCount`, `videoCount`, `hasAPlusContent` and the
length of `features` across the top twenty for your keyword tell you what a
listing has to look like to rank there.

**A price band study.** The spread of `price` and `pricePerUnit` across a search
tells you where customer expectation sits before you set yours.

**A share-of-search tracker.** Run the same keyword daily into one dataset and
count how many of the top twenty belong to each brand.

**A product discovery pass.** Search a problem rather than a product, then sort
by `estimatedMonthlyRevenue` to see what people are actually buying to solve it.

### Working it into your stack

Every run writes to a dataset you can download as CSV, JSON, Excel or XML, or
pull through the API. Sixty-four fields is a wide table; most people pick a
subset in the dataset view and export that.

Schedules take a cron expression. For a share-of-search tracker, a daily schedule
into one named dataset is the whole implementation.

### Marketplaces

Nineteen, from amazon.com to amazon.co.jp, read in their own language. A German
rating saying "4,5 von 5 Sternen" and a Japanese one putting the number last both
come back as 4.5.

Prices do not travel everywhere. Measured on 2026-08-24:

| Marketplace | Products priced |
| --- | --- |
| amazon.com | 57 of 60 |
| amazon.ca | 5 of 5 |
| amazon.co.uk | 5 of 6 |
| amazon.fr | 4 of 5 |
| amazon.it | 1 of 5 |
| amazon.es | 1 of 5 |
| amazon.de | 0 of 8 |
| amazon.com.au | 0 of 5 |

Everything else arrives on all of them, and rows without a price are free.

### Pricing

Four dollars per thousand products with a price, plus three cents to start a run.

A search of two hundred results costs about eighty-three cents. You are not
charged for rows without a price or for products that never arrived, and platform
usage is included.

### The rest of this family

Eleven Actors on one engine. If sixty-four fields is more than you need for a
search, the focused ones cost the same four dollars and return less noise. The
full product scraper is the one exception at eight dollars, because it does the
same sixty-four field read without the search step:

- **Amazon Bestsellers Scraper** for the same depth on a category instead of a
  search term.
- **Amazon Niche Research** when the question is whether a market is worth
  entering.
- **Amazon Price Tracker** on the ASINs a search turns up.
- **Amazon Product Scraper** when you already have the ASINs and do not need the
  search step.

### Questions people ask

**How many results per search.** Amazon caps its own search at roughly seven
pages. Set the maximum per search to what you want and the page limit to how deep
to walk.

**Why do two runs return a different order.** Because Amazon personalises search
results by location and time. The set is usually stable; the order is not.

**Can I use my own filtered search.** Yes, paste the URL. Building the filter in
a browser is easier than encoding it by hand.

**Are sponsored results included.** Yes. Amazon does not mark them reliably
enough to filter without guessing, and dropping a real product by mistake is
worse.

**Can I search several keywords in one run.** Yes. Every row carries the search
it came from, so they stay separable.

**How long does it take.** Sixty products take about 13 minutes, including
walking the search pages.

### What it does not collect

No review text, no reviewer names, no customer questions, no seller names. You
get the aggregate rating and the count, which are facts about a product rather
than about a person.

### Legal note

This Actor reads public pages and takes product facts. Business information about
items, not information about people.

You are responsible for what you do with the output. Check Amazon's terms for
your own use case.

# Actor input Schema

## `search` (type: `array`):

Anything that lists products: a plain search term ("tower fan"), an Amazon search URL, a category link, or a bestsellers page. Each one is crawled and every product found is scraped. Use this when you do not know the ASINs up front.

## `productUrls` (type: `array`):

Amazon product URLs or bare ASINs, one per line. Leave empty if you are using Search instead. Duplicates are removed so you are never charged twice.

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

Which Amazon site to read. The currency of the price follows the marketplace and the proxy country.

## `proxyCountry` (type: `string`):

Which country the requests should appear to come from. Leave empty and it follows the marketplace: amazon.de is read from Germany, amazon.co.uk from the UK. This matters more than it looks -- Amazon shows different prices, currencies and even availability depending on where you appear to be.

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

Hard ceiling on delivered products. 0 means no ceiling: the Actor keeps going until the lists run out or your limits stop it.

## `maxItemsPerList` (type: `integer`):

Products to take from each search term or category link. Up to 10000.

## `maxListPages` (type: `integer`):

Result pages to walk per list. Up to 100. Amazon itself stops earlier on most searches.

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

Datacenter proxies were enough in testing: 30 out of 30 products returned with zero blocks. They are the cheaper option and the default. Switch to residential if you start seeing blocked pages at higher volume. Running without any proxy stops after roughly 85-120 products, because Amazon closes the door on a single IP address for over an hour.

## `lanes` (type: `integer`):

How many products to read at the same time. Each lane uses its own exit address, so more lanes never means asking one address more often. Eight is the tested default and the most accurate. Sixteen finishes the same sixty products in about half the time, but measured on 2026-08-24 it returned six more products without a price, because Amazon strips the buy box sooner under pressure. Raise it when speed matters more than the last few prices.

## `maxAttempts` (type: `integer`):

How often to retry a product Amazon refuses, each time from a different exit IP. A refusal is a property of one address, not of the product, and a refused attempt costs about 4 KB. Twelve tries is cheap insurance against a run that comes back short.

## `residentialFallback` (type: `boolean`):

After half the attempts have failed, retry through residential addresses instead of datacenter ones. Measured 2026-08-26: residential transfer was 90 percent of the bill on a sixty product run ($0.150 of $0.167) while a run that never touched it delivered all sixty anyway. Leave it off unless you are losing products; turn it on when a marketplace refuses everything.

## `economical` (type: `boolean`):

Hang up on each product page once the price is in, instead of reading it to the end. Roughly three times less traffic and about three times faster. Measured cost: over 30 products this lost 2 ratings, 4 review counts and 1 brand, because Amazon sometimes puts the rating below the price. Prices were identical either way. Leave this off unless you only need prices and are paying per gigabyte.

## `minDelayMs` (type: `integer`):

Pause between products. Measured 2026-08-23: at 1-2 seconds this returned 10 of 15 products; at 8-15 seconds it returned 12 of 15 on the same list. Pace turned out to matter more than anything else. The market leader waits about 14 seconds per product.

## `maxDelayMs` (type: `integer`):

Upper bound for the pause between products. The actual pause is random between the minimum and this value, which looks less mechanical than a fixed interval.

## `retryPauseMs` (type: `integer`):

How long to wait before trying a refused product again. Kept short because the retry already switches to a different exit IP, and waiting longer only makes the run more expensive.

## Actor input object example

```json
{
  "search": [
    "standing desk converter"
  ],
  "productUrls": [],
  "marketplace": "com",
  "maxItems": 0,
  "maxItemsPerList": 10,
  "maxListPages": 5,
  "proxyConfiguration": {
    "useApifyProxy": true
  },
  "lanes": 8,
  "maxAttempts": 12,
  "residentialFallback": false,
  "economical": false,
  "minDelayMs": 8000,
  "maxDelayMs": 15000,
  "retryPauseMs": 300
}
```

# Actor output Schema

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

One row per search result with the full product record. Rows without a price are delivered in full and never charged for.

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

Counts per outcome, exit addresses used, bytes per charged result.

# 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 = {
    "search": [
        "standing desk converter"
    ],
    "productUrls": [],
    "maxItemsPerList": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("amazonscrapers/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 = {
    "search": ["standing desk converter"],
    "productUrls": [],
    "maxItemsPerList": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("amazonscrapers/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 '{
  "search": [
    "standing desk converter"
  ],
  "productUrls": [],
  "maxItemsPerList": 10
}' |
apify call amazonscrapers/amazon-search-results-scraper --silent --output-dataset

```

## MCP server setup

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