# Amazon Search Scraper By Country & Currency (`simpleapi/amazon-search-scraper`) Actor

Amazon Search Scraper extracts products from Amazon search results, including titles, prices, ratings, reviews, images, sellers, and availability. Ideal for market research, price tracking, competitor analysis, and automating structured Amazon product data collection at scale.

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

## Pricing

from $2.99 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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 — Products, Prices by Country and Currency

Run one Amazon search across up to **seven Amazon marketplaces in a single run** and get back a
typed, normalized JSON row for every product — each one tagged with its `marketplace`, `country`
and `currency`, and priced the way that marketplace actually writes it (`19,99` stays `19.99`,
`1.299,00 €` stays `1299.0`). Fields include `asin`, `productDescription`, `priceLocal`,
`priceText`, `retailPrice`, `productRating`, `countReview`, `searchResultPosition` and `dpUrl`.
The Actor also rolls every ASIN it finds on two or more marketplaces into its own comparison row
with the price per marketplace and the spread between them — useful for procurement teams,
cross-border resellers and pricing analysts who currently run one Amazon scraper per country and
merge the exports by hand. Point it at a keyword or a pasted Amazon search URL and the marketplace
fan-out and the comparison roll-up both happen inside the one run.

***

### What is Amazon Search Scraper By Country & Currency?

It is an Apify Actor that runs a keyword search — or a pasted Amazon search-results URL — against
one or more Amazon marketplace domains and returns every product tile as a JSON row, plus an
optional cross-market comparison row for any ASIN shared by two or more of the marketplaces you
picked. No Amazon account, Amazon Associates enrollment or Amazon API key is needed — the Actor
reads the same public search-results pages a browser would.

Key features:

- 🌍 **Seven-marketplace fan-out per run** — amazon.com, amazon.co.uk, amazon.de, amazon.fr,
  amazon.it, amazon.es, amazon.ca, each requested in its own language with its own network route.
- 🔎 **Two ways to target results** — a plain keyword (`queries`), or a pasted Amazon search URL
  that keeps its own marketplace, category (`i` parameter) and department (`rh` browse node).
- 💱 **Locale-aware money parsing** — each marketplace's own decimal separator is read correctly,
  and `currency` is cross-checked against the symbol the page actually rendered, never guessed.
- ⚖️ **Cross-market comparison rows** — every ASIN found on two or more selected marketplaces
  gets a `type: "comparison"` row with `priceByMarket`, `cheapestMarketplace` and `priceSpreadPct`.
- 📊 **Six real Amazon sort orders** — Featured, Best sellers, Price low→high, Price high→low,
  Average customer review, Newest arrivals — the same tokens Amazon's own sort control uses.
- 📦 **Export formats** — the Apify platform's standard dataset exports: JSON, CSV, Excel, XML,
  and RSS, from the Console or the API, on both the main dataset and the mirrored comparison one.

***

### What data can I extract with Amazon Search Scraper By Country & Currency?

Every run returns two row shapes in the same dataset, distinguished by `type` and `isChild`:
per-product search rows, and (when comparison is on) roll-up rows across marketplaces.

| Field | Example value | Use case |
| --- | --- | --- |
| `type` | `"product"` / `"comparison"` | Filter row shape |
| `isChild` | `false` / `true` | Same filter, boolean form |
| `marketplace`, `marketplaceCode`, `domainCode` | `"amazon.de"`, `"de"`, `"de"` | Which Amazon site the row came from |
| `country` | `"DE"` | ISO country of that marketplace |
| `currency` | `"EUR"` | Listing currency, read from the rendered symbol |
| `keyword` | `"lego technic"` | The search term that produced this row |
| `asin` | `"B0DZZWMB2L"` | Amazon product identifier |
| `productDescription` | `"ASUS ROG Strix G16 Gaming Laptop"` | Product title |
| `priceLocal`, `price` | `1299.0` | Numeric selling price, in the marketplace's own currency |
| `priceText` | `"1.299,00 €"` | Price exactly as the marketplace printed it |
| `retailPrice` | `1499.0` | Struck-through list price, `null` when none is shown |
| `secondaryOffer` | `1249.5` | Lowest other-seller/used price on the tile, `null` when none |
| `productRating` | `"4,5 von 5 Sternen"` | Rendered rating text (locale-specific) |
| `countReview` | `539` | Review count, `null` when the tile carries none |
| `searchResultPosition` | `1` | Organic rank Amazon's own tile href carries |
| `page`, `currentPage` | `1` | Which results page the row came from |
| `resultCount`, `resultCountStatus` | `null`, `"not-published"` | Amazon's total-results figure, and whether the marketplace prints it |
| `salesVolume` | `"2K+ bought in past month"` | Recent-purchases line, when shown |
| `deliveryMessage` | `"FREE delivery Tue, Aug 18"` | Delivery line, as rendered |
| `dpUrl` | `"https://www.amazon.de/dp/B0DZZWMB2L"` | Absolute, clickable product URL |
| `imgUrl` | `"https://m.media-amazon.com/images/…"` | Product image URL |
| `prime`, `sponsored` | `true`, `false` | Prime badge / sponsored-placement flags, as rendered |
| `manufacturer`, `series`, `variations`, `productDetails` | `null`, `null`, `[]`, `[]` | Brand line, model series, colour/size swatches, bullet features — kept for compatibility with older inputs; a 2026 search tile rarely renders these, so they are frequently empty rather than guessed |
| `categories`, `nodeHierarchy`, `selectedCategory`, `browseNode` | `[]`, `null`, `"aps"`, `null` | Department facets and department path, populated only when the search is scoped to one |
| `similarKeywords` | `[{"keyword": "lego technic sets", "url": "…"}]` | Related-search suggestions with absolute URLs |
| `sortStrategy` | `"relevanceblender"` | The ordering actually applied to this page |
| `searchUrl` | `"https://www.amazon.de/s?k=…"` | The exact URL the Actor requested |
| `statusCode`, `statusMessage` | `200`, `"FOUND"` | Classic status keys, kept unchanged |
| `scrapedAt` | `"2026-08-08T12:00:00Z"` | UTC timestamp the row was collected |

#### 💱 Cross-market comparison fields

`type: "comparison"` rows carry a different set of fields, filled only on those rows: `marketsFound`
(list of domains), `marketCount`, `priceByMarket` (`{"amazon.com": 1393.65, "amazon.de": 1299.0}`),
`currencyByMarket`, `productUrlByMarket`, `sameCurrency`, `cheapestMarketplace`, `cheapestPrice`,
`cheapestCurrency`, `highestMarketplace`, `highestPrice`, and `priceSpreadPct` — the percentage gap
between the cheapest and highest listed price for that ASIN, rounded to two decimals. Matching is
by ASIN: the same physical product is sometimes listed under a different ASIN in a different
country, so this only covers listings genuinely shared between the marketplaces you picked — the
run log prints the real matched percentage for every run.

#### 🌍 Marketplace and currency targeting fields

`marketplace`, `country` and `currency` are what let a downstream table or spreadsheet be filtered
or grouped per country without any lookup step. `categories`, `browseNode` and `nodeHierarchy`
narrow within one marketplace when the input carries a category-scoped Amazon URL rather than a
plain keyword — they stay empty for a plain keyword search, since Amazon doesn't scope those to a
department on its own.

***

### How does Amazon Search Scraper By Country & Currency differ from the official Amazon API?

Amazon's own product-data API is being retired: as observed on Amazon's own documentation on
2026-08-15, `webservices.amazon.com/paapi5` now redirects to a deprecation notice stating **"The
Amazon Product Advertising API 5.0 (PA-API 5) has been deprecated and is being replaced by the
Creators API"** ([affiliate-program.amazon.com/creatorsapi/docs/en-us/paapiv5-deprecation](https://affiliate-program.amazon.com/creatorsapi/docs/en-us/paapiv5-deprecation)).
Its replacement, the Creators API, requires enrollment in the Amazon Associates program **for your
target marketplace**, plus **at least 10 qualifying sales within the past 30 days**, registration
through Associates Central, and generated API credentials — as documented on
[affiliate-program.amazon.com/creatorsapi/docs/en-us/introduction](https://affiliate-program.amazon.com/creatorsapi/docs/en-us/introduction),
checked 2026-08-15.

| Feature | Amazon Creators API (successor to PA-API 5.0) | Amazon Search Scraper By Country & Currency |
| --- | --- | --- |
| Account requirement | Amazon Associates account, per target marketplace | Apify account only |
| Ongoing eligibility | ≥10 qualifying sales in the trailing 30 days | None |
| Multi-marketplace in one call | Documentation describes "your target marketplace" (singular) per enrollment | Up to 7 marketplaces fanned out in a single run |
| Cross-market price comparison | Not documented as a built-in operation | Built in — `compareAcrossMarkets` rolls up shared ASINs automatically |
| Setup requirement | Associates enrollment, credential generation, per-marketplace registration | Apify Console or API call, no registration elsewhere |
| Output shape | Structured JSON via `SearchItems`/`GetItems` operations | Structured JSON dataset row per product, exportable as JSON/CSV/Excel/XML |

#### Why does Amazon gate its own product API behind an Associates account?

Amazon's Associates program exists to reward referral traffic that converts into purchases, so its
API access is conditioned on maintaining qualifying sales volume rather than on the caller's data
needs — a research team, a procurement desk or a pricing analyst with no storefront to refer
traffic from cannot qualify, regardless of how much genuine demand they have for the data. Amazon
Search Scraper By Country & Currency reads the same public search-results pages a shopper's browser
loads and requires no referral relationship with Amazon at all.

The Creators API is the right choice for an existing Associate who already qualifies and wants
official, Amazon-supported access to a single target marketplace. This Actor is the more direct
route when the goal is one-off or recurring search data across several countries, with no Associates
account, no qualifying-sales requirement, and no per-marketplace enrollment step.

***

### How to use data extracted from Amazon?

#### 🛒 Cross-border pricing and procurement

Set `marketplaces` to the countries you buy or sell in, turn on `compareAcrossMarkets`, and read
`priceByMarket`, `cheapestMarketplace` and `priceSpreadPct` off the comparison rows to see, per
ASIN, which country lists it cheapest and by how much — before committing to a purchase order or a
sourcing decision.

#### 🔁 Agencies and repeated monitoring

Run the same `queries` list on a schedule against the same `marketplaces` selection, and diff
`priceLocal` and `retailPrice` across runs per `asin` to flag price changes for clients across
their target countries, without re-writing the query set each time.

#### 📊 Market research and intelligence

Run one keyword against all seven marketplaces with a high `productsPerMarketplace`, then group
the product rows by `marketplace` and look at `resultCount` and `searchResultPosition` distribution
to gauge how deep a term's catalogue is per country before entering a new market.

#### 🤖 AI agents and automated pipelines

Because the Actor is a standard Apify Actor with a JSON input and a JSON dataset output, an agent
framework can call it as a tool — pass a keyword and a marketplace list, get back typed rows with
`asin`, `priceLocal` and `currency` ready to feed into a pricing-comparison or sourcing-recommendation
step without any HTML parsing on the agent's side.

***

### 🔼 Input sample

No input parameter is required — `queries` defaults to nothing collected, `marketplaces` falls back
to classic single-marketplace behaviour, and every other field carries its own default.

| Parameter | Required | Type | Description | Example value |
| --- | --- | --- | --- | --- |
| `queries` | No | array of string | One or more search terms. Each is run on every marketplace selected below. A pasted marketplace URL keeps its own marketplace in addition to the ones selected, and its category or department is respected. Prefill: `["lego technic"]` | `["laptop", "wireless headphones"]` |
| `marketplaces` | No | array of string (enum: `com`, `co.uk`, `de`, `fr`, `it`, `es`, `ca`) | Amazon marketplaces to search. Every search term runs on each of them; every product row carries `marketplace`, `country` and `currency`. Leave empty for the classic fallback: a plain term goes to amazon.com, a pasted URL goes to its own marketplace. Prefill: `["com", "de", "co.uk"]` | `["com", "de", "fr"]` |
| `productsPerMarketplace` | No | integer (min `1`, max `10000`) | How many products to collect per search term, per marketplace. Pages are walked until this number is reached or the marketplace runs out of results. Prefill: `15` | `25` |
| `compareAcrossMarkets` | No | boolean | When on, every ASIN found on two or more marketplaces gets an extra `type: "comparison"` row. Matching is by ASIN. Prefill: `true` | `true` |
| `minMarketsForComparison` | No | integer (min `2`, max `7`) | An ASIN must carry a price on at least this many marketplaces before it gets a comparison row. Prefill: `2` | `3` |
| `mirrorComparisonDataset` | No | boolean | When on, comparison rows are additionally written to a separate dataset named `<run id>-comparison`. Prefill: `true` | `true` |
| `resultOrder` | No | string (enum: `relevanceblender`, `exact-aware-popularity-rank`, `price-asc-rank`, `price-desc-rank`, `review-rank`, `date-desc-rank`) | The ordering Amazon applies before results are read — all six are orderings Amazon's own sort control offers. Prefill: `relevanceblender` | `price-asc-rank` |
| `urls` | No | array of string | Classic key. Used when `queries` is left empty, with the same meaning. | `["https://www.amazon.de/s?k=gaming+stuhl"]` |
| `maxResults` | No | integer (min `1`, max `10000`) | Classic key. Used as the per-marketplace limit when `productsPerMarketplace` is left empty. | `10` |
| `sortBy` | No | string (enum: `relevanceblender`, `recent`, `exact-aware-popularity-rank`, `price-asc-rank`, `price-desc-rank`, `review-rank`, `date-desc-rank`) | Classic key. Used when `resultOrder` is left empty. The classic `recent` value now really does return newest arrivals. | `recent` |
| `proxyConfiguration` | No | object (proxy editor) | Leave the default and each marketplace is reached over a route matched to that marketplace's own country, which is what makes local prices and local currency come back correctly. Prefill: `{"useApifyProxy": true, "apifyProxyGroups": ["RESIDENTIAL"]}` | `{"useApifyProxy": true, "apifyProxyGroups": ["RESIDENTIAL"]}` |

```json
{
  "queries": ["lego technic"],
  "marketplaces": ["com", "de", "co.uk"],
  "productsPerMarketplace": 15,
  "compareAcrossMarkets": true,
  "minMarketsForComparison": 2,
  "mirrorComparisonDataset": true,
  "resultOrder": "relevanceblender"
}
```

**Common pitfall:** leaving `marketplaces` empty is not the same as picking all seven — it triggers
the classic fallback instead, where a plain keyword only ever reaches amazon.com and a pasted URL
only reaches its own marketplace. To fan a keyword out across several countries, `marketplaces`
must be set explicitly.

***

### 🔽 Output sample

Every row is typed, normalized JSON with a stable schema across marketplaces — the same field
names whether the row came from amazon.com or amazon.de. Export as JSON, CSV, Excel, XML or RSS
from the Apify Console or API, on the main dataset and, when `mirrorComparisonDataset` is on, the
separate `<run id>-comparison` dataset as well.

```json
{
  "type": "product",
  "isChild": false,
  "marketplace": "amazon.de",
  "marketplaceCode": "de",
  "country": "DE",
  "currency": "EUR",
  "keyword": "laptop",
  "statusCode": 200,
  "statusMessage": "FOUND",
  "domainCode": "de",
  "page": 1,
  "currentPage": 1,
  "selectedCategory": "aps",
  "browseNode": null,
  "nodeHierarchy": null,
  "resultCount": null,
  "resultCountStatus": "not-published",
  "categories": [],
  "similarKeywords": [],
  "sortStrategy": "relevanceblender",
  "searchResultPosition": 1,
  "searchUrl": "https://www.amazon.de/s?k=laptop&s=relevanceblender&page=1&ref=sr_pg_1",
  "scrapedAt": "2026-08-08T12:00:00Z",
  "asin": "B0DZZWMB2L",
  "productDescription": "ASUS ROG Strix G16 Gaming Laptop",
  "imgUrl": "https://m.media-amazon.com/images/I/71xyz.jpg",
  "price": 1299.0,
  "priceLocal": 1299.0,
  "priceText": "1.299,00 €",
  "retailPrice": 1499.0,
  "productRating": "4,5 von 5 Sternen",
  "countReview": 539,
  "dpUrl": "https://www.amazon.de/ASUS-ROG-Strix-Gaming-Laptop/dp/B0DZZWMB2L",
  "prime": true,
  "sponsored": false,
  "salesVolume": "1K+ bought in past month",
  "deliveryMessage": "FREE delivery Tue, Aug 18",
  "manufacturer": null,
  "series": null,
  "variations": [],
  "productDetails": [],
  "secondaryOffer": null
}
```

```json
{
  "type": "comparison",
  "isChild": true,
  "keyword": "laptop",
  "asin": "B0DZZWMB2L",
  "productDescription": "ASUS ROG Strix G16 Gaming Laptop",
  "marketsFound": ["amazon.co.uk", "amazon.com", "amazon.de"],
  "marketCount": 3,
  "priceByMarket": { "amazon.com": 1393.65, "amazon.de": 1299.0, "amazon.co.uk": 1199.0 },
  "currencyByMarket": { "amazon.com": "USD", "amazon.de": "EUR", "amazon.co.uk": "GBP" },
  "productUrlByMarket": { "amazon.com": "https://www.amazon.com/dp/B0DZZWMB2L", "amazon.de": "https://www.amazon.de/dp/B0DZZWMB2L", "amazon.co.uk": "https://www.amazon.co.uk/dp/B0DZZWMB2L" },
  "sameCurrency": false,
  "cheapestMarketplace": "amazon.co.uk",
  "cheapestPrice": 1199.0,
  "cheapestCurrency": "GBP",
  "highestMarketplace": "amazon.com",
  "highestPrice": 1393.65,
  "priceSpreadPct": 16.23,
  "scrapedAt": "2026-08-08T12:00:00Z"
}
```

***

### How do you filter and target specific products?

This Actor's targeting is built around **marketplace selection and query shape**, not geographic
radius or price bands. Four real controls:

1. **Keyword vs pasted search URL.** A plain `queries` entry (`"laptop"`) is broad and runs on
   every marketplace you select. A pasted Amazon search URL (`https://www.amazon.de/s?k=…&i=…&rh=n:…`)
   is more precise: it keeps its own marketplace and respects the category (`i`) and department
   browse node (`rh`) Amazon already scoped it to, so use it when you need one department rather
   than a whole catalogue.
2. **Marketplace selection.** `marketplaces` is the scope-precision control here — pick the exact
   country set you need pricing for. Leaving it empty is not "all seven"; it triggers the classic
   single-marketplace fallback described above.
3. **Comparison coverage threshold.** `minMarketsForComparison` (2–7) is the closest thing to a
   quality threshold this Actor exposes: raise it above `2` to keep only ASINs listed widely rather
   than on just one pair of marketplaces. There is no per-product rating or review-count filter at
   scrape time — `productRating` and `countReview` come back on every row for filtering downstream.
4. **Volume and ordering.** `productsPerMarketplace` (1–10,000) caps how many products are pulled
   per term per marketplace, and `resultOrder` decides which slice of the catalogue that cap lands
   on — `price-asc-rank` for the cheapest items first, `date-desc-rank` for newest arrivals.

```json
{ "queries": ["wireless headphones"], "marketplaces": ["com", "de", "fr", "it", "es"], "productsPerMarketplace": 20 }
```

```json
{ "queries": ["https://www.amazon.co.uk/s?k=gaming+chair&rh=n:11052591"], "marketplaces": ["co.uk"] }
```

```json
{ "queries": ["usb c cable"], "marketplaces": ["com", "de"], "resultOrder": "price-asc-rank", "minMarketsForComparison": 2 }
```

***

### ▶️ Want to try other Amazon scrapers?

| Scraper | What it extracts |
| --- | --- |
| Amazon Product Details Scraper (Bestsellers & New Releases) | Full product detail pages, bestseller and new-release lists |
| Amazon Price Tracker — Title, Image & Product Updates | Repeated price/title/image checks on a fixed list of ASINs or URLs |
| Amazon DE Sellers Leads Scraper — Product Price & Ratings | Amazon.de seller and listing leads with price and rating data |

| Comparable marketplace scrapers | What it extracts |
| --- | --- |
| eBay Product Listing Scraper With Sold Price Data | eBay listings with sold-price history |
| Walmart Reviews Scraper With Seller & Variant Details | Walmart product reviews with seller and variant data |
| Shopify Products Scraper With Variant & SKU Rows | Shopify storefront products with variant and SKU-level rows |

***

### How to extract Amazon data programmatically

The Actor runs like any Apify Actor: one authenticated call with a JSON input body, structured JSON
back from the run's dataset — no scraping code, headless browser or proxy pool to maintain yourself.

#### 🐍 Python example

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")

run_input = {
    "queries": ["laptop"],
    "marketplaces": ["com", "de", "co.uk"],
    "productsPerMarketplace": 20,
    "compareAcrossMarkets": True,
}

run = client.actor("YOUR_USERNAME/amazon-search-scraper-by-country-currency").call(run_input=run_input)

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    if item["type"] == "product":
        print(item["asin"], item["marketplace"], item["priceLocal"], item["currency"])
```

#### 📤 Export to spreadsheets or CRM

Every dataset exports directly to CSV or Excel from the Apify Console or the `GET
/v2/datasets/{id}/items` API endpoint. Map `asin` to a product key column, `productDescription` to
a title column, `priceLocal`/`currency` to price columns, and `dpUrl` to a link column when
importing into a spreadsheet, BI tool or CRM.

***

### ⚖️ Is it legal to scrape Amazon?

Scraping publicly listed product data — the same prices, titles and images any shopper's browser
loads on a public search-results page — is generally lawful; these listings exist to be found and
compared by shoppers, and this Actor collects nothing that sits behind a login. This Actor returns
**product and marketplace data**, not personal data about identifiable individuals, so GDPR does
not attach to its output. The applicable framework is Amazon's own Terms of Service, which govern
automated access to amazon.com, and database-rights law where it applies to the compiled catalogue
data. Consult legal counsel for commercial applications involving bulk storage of this data.

***

### ❓ FAQ

#### How do I know if a product listing is still active or in stock?

The Actor reports the search results exactly as Amazon rendered them at request time; there is no
persisted "delisted" flag. A row with `priceText` set but `priceLocal` as `null` usually means the
tile carried no purchasable price at that moment (for example a title bundled with a membership
rather than sold outright) — re-run the search to check current availability rather than treating
a past run's rows as live inventory.

#### Can I get cross-marketplace price comparison along with the product rows?

Yes — turn on `compareAcrossMarkets` (on by default) and every ASIN found on `minMarketsForComparison`
or more of your selected marketplaces gets an extra `type: "comparison"` row in the same dataset,
carrying `priceByMarket`, `cheapestMarketplace` and `priceSpreadPct`. Set `mirrorComparisonDataset`
to also write those rows to their own `<run id>-comparison` dataset.

#### How accurate is the price and rating data?

The Actor returns data exactly as it appears on the public Amazon search page at request time.
Accuracy depends on how current Amazon's own listing is at that moment — prices and stock change
without notice, so re-scrape close to the point of use rather than relying on a stored run.

#### How many products can I get per run?

`productsPerMarketplace` (and its classic alias `maxResults`) accepts `1`–`10000`. ⚠️ In practice
the Actor also stops a keyword on one marketplace once it has walked 20 result pages
(`page_ceiling` in the source) or reached Amazon's own last page, whichever comes first — a hard
cap the input schema does not itself expose. Most searches will hit that page ceiling, or run out
of Amazon's own results, well before 10,000 products are collected.

#### How do I compare a product's price across specific marketplaces only?

Set `marketplaces` to exactly the countries you want compared and leave `compareAcrossMarkets` on.
Raise `minMarketsForComparison` (2–7) if you only want ASINs that are listed on most of your
selected countries, not just a shared pair.

#### Does Amazon Search Scraper By Country & Currency work with Claude, ChatGPT, and AI agent frameworks?

It is not published with an MCP server. It is callable as a standard Apify Actor by any agent
framework that can make an authenticated HTTP call or use the `apify_client` SDK — pass a JSON
input, read back a JSON dataset.

#### How does it compare to other Amazon scrapers?

No competitor listings were analyzed for this edition of the README, so no competitor claim is
made here. What this Actor's own architecture does is fan a single keyword out across up to seven
Amazon marketplaces and roll up the shared ASINs into comparison rows inside one run — a workflow
that otherwise needs a separate run per marketplace and a manual merge step.

#### Can I use it without an Amazon API key or developer account?

Yes. You only need an Apify account to run it — no Amazon Associates enrollment, no qualifying
sales, and no Amazon API credentials of any kind.

***

### Conclusion

Amazon Search Scraper By Country & Currency turns one keyword or search URL into typed product
rows across up to seven Amazon marketplaces, and rolls the shared ASINs into ready-made price
comparison rows inside the same run — no Amazon Associates account, no per-marketplace API
credentials, and no manual merge of seven separate exports. Start a run from the Apify Console or
call it with `apify_client` to get structured JSON, CSV or Excel back on your own schedule.

# Actor input Schema

## `queries` (type: `array`):

One or more search terms. Each term is searched on every marketplace selected below.

Examples:
• `laptop`
• `wireless headphones`
• `https://www.amazon.de/s?k=gaming+stuhl`

A pasted marketplace URL keeps its own marketplace in addition to the ones you select, and its category or department is respected.

## `marketplaces` (type: `array`):

Select one or more marketplaces. Every search term is run on each of them and each product row carries `marketplace`, `country` and `currency`.

Leave this empty to fall back to the classic behaviour: a plain search term goes to amazon.com and a pasted URL goes to its own marketplace.

## `productsPerMarketplace` (type: `integer`):

How many products to collect for each search term on each marketplace.

Example: 2 search terms x 3 marketplaces x 15 = up to 90 product rows. Pages are walked until this number is reached or the marketplace runs out of results.

A larger number also gives the cross-market comparison more ASINs to match on.

## `compareAcrossMarkets` (type: `boolean`):

When on, every ASIN found on two or more marketplaces gets an extra row (`type: comparison`) carrying `marketsFound`, `priceByMarket`, `currencyByMarket`, `cheapestMarketplace`, `cheapestPrice`, `highestPrice` and `priceSpreadPct`.

Matching is by ASIN. Amazon ASINs are not identical worldwide for every product, so only the genuinely shared listings are matched - the run log prints the real matched percentage.

## `minMarketsForComparison` (type: `integer`):

An ASIN must carry a price on at least this many marketplaces before it gets a comparison row.

2 = every shared listing. Raise it to 3 or more to keep only the products listed widely.

## `mirrorComparisonDataset` (type: `boolean`):

When on, the comparison rows are additionally written to a separate dataset named `<run id>-comparison`, so they can be exported on their own without filtering the product rows out.

## `resultOrder` (type: `string`):

The ordering Amazon applies before the results are read. All six options are the orderings Amazon's own sort control offers.

## `urls` (type: `array`):

The classic search-term key. Used when `queries` above is left empty, with exactly the same meaning.

## `maxResults` (type: `integer`):

The classic product-limit key. Used as the per-marketplace limit when `productsPerMarketplace` above is left empty.

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

The classic ordering key. Used when `resultOrder` above is left empty. The classic `recent` value now really does return newest arrivals.

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

Leave the default and each marketplace is reached over a route matched to that marketplace's own country, which is what makes local prices and local currency come back correctly.

Set your own selection here to override that for the whole run.

## Actor input object example

```json
{
  "queries": [
    "lego technic"
  ],
  "marketplaces": [
    "com",
    "de",
    "co.uk"
  ],
  "productsPerMarketplace": 15,
  "compareAcrossMarkets": true,
  "minMarketsForComparison": 2,
  "mirrorComparisonDataset": true,
  "resultOrder": "relevanceblender",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

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

All scraped items in the Actor's default dataset.

## `outputSummary` (type: `string`):

Queries searched, marketplaces searched (and which returned results), per-marketplace product counts, total product/comparison row counts, comparison match percentage and the run's scrape timestamp. Written once as OUTPUT\_SUMMARY after the run finishes.

## `output` (type: `string`):

Written as an empty array only when no usable search query was found in the input; the run then ends without collecting data.

# 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 = {
    "queries": [
        "lego technic"
    ],
    "marketplaces": [
        "com",
        "de",
        "co.uk"
    ],
    "productsPerMarketplace": 15,
    "compareAcrossMarkets": true,
    "minMarketsForComparison": 2,
    "mirrorComparisonDataset": true,
    "resultOrder": "relevanceblender",
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("simpleapi/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 = {
    "queries": ["lego technic"],
    "marketplaces": [
        "com",
        "de",
        "co.uk",
    ],
    "productsPerMarketplace": 15,
    "compareAcrossMarkets": True,
    "minMarketsForComparison": 2,
    "mirrorComparisonDataset": True,
    "resultOrder": "relevanceblender",
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("simpleapi/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 '{
  "queries": [
    "lego technic"
  ],
  "marketplaces": [
    "com",
    "de",
    "co.uk"
  ],
  "productsPerMarketplace": 15,
  "compareAcrossMarkets": true,
  "minMarketsForComparison": 2,
  "mirrorComparisonDataset": true,
  "resultOrder": "relevanceblender",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call simpleapi/amazon-search-scraper --silent --output-dataset

```

## MCP server setup

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