# Amazon Product Scraper | $0.50 per 1K Results (`tovuk/amazon-product-scraper`) Actor

Scrape Amazon products by keyword, URL, ASIN, category, or seller across 20 marketplaces. Extract prices, ratings, reviews, sellers, images, variants, availability, and bestseller ranks. Run in Console or by API, schedule Tasks, and pay $0.50 per 1,000 results on paid plans.

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

## Pricing

from $0.50 / 1,000 amazon product results

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/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

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

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

Amazon Product Scraper is a structured Amazon data scraper for search, product, category-chart, bestseller, seller, review, offer, and question pages. Paid-plan prices start at `$0.50` per 1,000 Dataset results, with no start fee, usage surcharge, or add-on event. Results are normalized products when Amazon exposes a usable record, or one transparent diagnostic item when a handled run produces no product.

Use the Amazon product scraper from the Apify Console, through the Amazon scraper API, from Python or JavaScript, or as a scheduled Task. You do not need to provide a proxy, cookie, captcha service, Amazon account, or third-party API key. Start with one query, URL, or Amazon Standard Identification Number (ASIN), then increase the bounded run limits after checking the first dataset.

### Why use this Amazon data scraper?

- Compare product prices, discounts, stock signals, shipping text, and visible sellers
- Monitor search position, sponsored placement, bestseller rank, badges, and category visibility
- Enrich product catalogs with ASINs, identifiers, specifications, variants, images, and descriptions
- Analyze ratings, review counts, visible review samples, questions, and customer-photo signals
- Build marketplace research datasets across 20 Amazon domains with consistent normalized fields
- Feed spreadsheets, databases, dashboards, alerts, scheduled workflows, and AI agents

The Actor keeps search, product, review, offer, seller, bestseller, ASIN, and question workflows in one tested output contract. For a single workflow and a more specific Store listing, use one of the focused Amazon Actors linked in the related-Actors section after completing your first run.

### How to scrape Amazon product data

1. Open the **Input** tab.
2. Enter one search query, supported Amazon URL, or ASIN.
3. Keep `maxItems` at 10 and `maxPages` at 1 for the first run.
4. Click **Start**, inspect the Dataset, and open the Actor outputs for the run summary or diagnostic.
5. Confirm the fields and marketplace, then increase limits or save the input as a Task.

### Amazon product scraper input example

Use this input for a low-cost first run:

```json
{
  "query": "usb c cable",
  "marketplace": "amazon.com",
  "maxItems": 10,
  "maxPages": 1
}
```

The Actor infers a search operation, requests up to 10 products, and writes all available product fields to the default Dataset. If a handled run produces no product, it writes one billed `recordType: "diagnostic"` Dataset item explaining the cause, next action, retryability, and relevant Actor documentation. `DIAGNOSTIC` preserves the exact immutable diagnostic publication body, and a terminal `RUN_SUMMARY` confirms the settled Dataset outcome. If Dataset visibility or publication state is temporarily undecidable, the Actor writes only provisional, non-billed recovery evidence and deliberately withholds a terminal summary and any further Dataset write.

An actual run of the input above returned this Dataset item on July 24, 2026. Amazon listings change over time, so treat the values as a continuous input-to-output example rather than a guaranteed current offer:

```json
{
  "recordType": "product",
  "marketplace": "amazon",
  "operation": "search",
  "title": "Anker USB C to USB C Cable, 60W Fast Charging Cable (2-Pack, 6 ft, Black) | For iPhone 17 Series, iPad mini 6, and More",
  "asin": "B088NRLMPV",
  "searchPage": 1,
  "resultPosition": 1,
  "priceText": "$9.99",
  "rating": 4.7,
  "reviewCount": 85571,
  "extractedAt": "2026-07-24T11:45:21.067Z"
}
```

### What you can collect

Available fields depend on the page, marketplace, delivery context, and content Amazon renders during the run.

- Product identity: title, ASIN, product and parent IDs, brand, manufacturer, model and part numbers, SKU, GTIN, MPN, URL, and source URL
- Search and category-chart data: search page, result position, sponsored position, category path, breadcrumbs, browse-node IDs, badges, and structured bestseller ranks
- Pricing and fulfillment: price, list price, sale price, discount, currency, condition, availability, stock, quantity, shipping, Prime eligibility, and delivery context
- Seller and offer data: seller name and ID, seller URL, ships-from, sold-by, fulfillment, offer count, visible price range, and structured offer details
- Product content: description, feature bullets, specifications, package quantity, color, size, style, variation theme, variants, primary image, image gallery, videos, keywords, and tags
- Customer signals: rating, rating count and distribution, review count, visible review samples, question count, visible question samples, and customer photos
- Extraction metadata: language, region, detail-enrichment provenance, requested features, extraction quality, and per-feature coverage

The Actor preserves additional normalized fields when the output contract gains new data. It does not discard rich fields unless you set `outputFields`.

### Choose a target

Provide at least one target field. Unknown fields are rejected before a data request starts.

| Field | Limit | Use |
| --- | ---: | --- |
| `query` | 1 | Run one Amazon search |
| `searchQueries` | 50 | Run several search phrases |
| `startUrls` | 200 | Provide supported Amazon page URLs for one compatible operation |
| `productUrls` | 200 | Collect product-page records |
| `asins` | 200 | Resolve ten-character ASINs in the selected marketplace |
| `categoryUrls` | 100 | Collect bestseller or category-chart pages; use `startUrls` for search-category URLs |
| `categoryIds` | 100 | Build bestseller targets from category IDs |
| `sellerUrls` | 100 | Collect seller or storefront pages |

Each URL can contain up to 2,048 characters. The Actor accepts HTTPS URLs only from supported Amazon domains; private URLs are rejected.

### Select an operation

Leave `operation` set to `auto` to infer one compatible operation for the whole run. Every supplied target must match that inferred operation. Split incompatible page types into separate runs. An explicit operation does not transform one page type into another, so every supplied target must match the selected operation.

| Operation | Matching target and output |
| --- | --- |
| `search` | Search query or search URL; normalized product-result records |
| `product` | Product URL or ASIN; visible product details |
| `reviews` | Review page; product record with visible review samples and counts |
| `offers` | Offer page; product record with visible offer, seller, price, and shipping fields |
| `seller` | Seller or storefront URL; visible storefront and product fields |
| `bestsellers` | Bestseller or category-chart URL, or category ID; ranked product records |
| `asins` | ASIN list; normalized product records |
| `questions` | Question page; product record with visible question samples and counts |

Review, offer, seller, and question data are embedded in normalized product-centric records. The Actor does not promise one complete dataset row for every individual review, offer, seller, or answer.

### Set marketplace and delivery context

The Actor supports 20 Amazon marketplaces:

`amazon.ae`, `amazon.ca`, `amazon.co.jp`, `amazon.co.uk`, `amazon.com`, `amazon.com.au`, `amazon.com.be`, `amazon.com.br`, `amazon.com.mx`, `amazon.com.tr`, `amazon.de`, `amazon.es`, `amazon.fr`, `amazon.in`, `amazon.it`, `amazon.nl`, `amazon.pl`, `amazon.sa`, `amazon.se`, and `amazon.sg`.

Use one marketplace per run. The selected marketplace, every supplied Amazon URL, and every result identity URL must resolve to that same marketplace or one of its subdomains. URL-free runs default to `amazon.com`. You can also provide:

| Field | Purpose |
| --- | --- |
| `deliveryLocation` | City, ZIP code, or postal code for delivery-localized content |
| `proxyCountryCode` | Country hint for managed retrieval, without proxy credentials |
| `proxyCity` | International city hint for managed retrieval |
| `language` | Language or locale hint such as `en-US` or `de-DE` |

Use a city or postal code instead of a personal street address.

### Filter Amazon products and review samples

The Actor applies filters after parsing Amazon records. This avoids returning a row merely because its source card was fetched. An active filter can return fewer than `maxItems` when Amazon exposes too few matching records.

| Field | Effect |
| --- | --- |
| `minRating` | Keep products at or above a rating from 0 to 5 |
| `minReviews` | Keep products at or above a parsed review count |
| `titleIncludeKeywords` | Keep titles containing at least one term |
| `titleExcludeKeywords` | Remove titles containing any term |
| `excludeSponsored` | Remove rows identified by a sponsored badge or ad position |
| `maxReviews` | Limit nested `reviewSamples` after filtering; 0 keeps every available sample |
| `reviewRatings` | Keep nested review samples in selected 1-to-5-star buckets |
| `reviewKeywords` | Keep nested review samples containing at least one term |
| `reviewsStartDate` | Keep nested review samples on or after an inclusive `YYYY-MM-DD` date |
| `reviewsEndDate` | Keep nested review samples on or before an inclusive `YYYY-MM-DD` date |
| `reviewSort` | Order nested review samples by relevance, date, or rating |

Title and review-keyword matches are case-insensitive. Review controls filter the samples Amazon exposes on the fetched page; they do not create a separate complete row for every review.

### Control run size

| Field | Range | Default |
| --- | ---: | ---: |
| `maxItems` | 0 for no item ceiling; 1 to 1,000,000,000 for an explicit ceiling | 10 |
| `maxPages` | 1 to 1,000,000,000 | 1 |
| `continuationCursor` | Signed opaque cursor from a previous `CONTINUATION` record | Empty |
| `enablePagination` | Boolean | `true` |
| `maxConcurrency` | 1 to 4 | 4 |
| `timeoutSecs` | 30 to 3,600 | 240 |

`maxItems` is the optional product-record ceiling. Set it to `0` when pages, targets, timeout, and the Apify spending limit should be the only run bounds. The final product count can be lower when a page has fewer records, Amazon limits pagination, a filter removes records, or the spending limit is reached. Large runs can take several minutes, so increase `timeoutSecs` and the Apify run timeout together. A direct target that produces no usable record completes with one billed actionable diagnostic item instead of disappearing or inventing a product.

If you override the Apify run timeout, keep it at least 60 seconds above `timeoutSecs` so the Actor can persist its final summary and any diagnostic.

For large search, seller, and bestseller jobs, the Actor splits source work into bounded internal requests of at most one source page and 1,000 service results. It follows the service's opaque source cursor across those chunks, including page 1,001 and later, without page arithmetic. It streams, validates, globally deduplicates, and repositions each completed request in the same Dataset instead of retaining the full run in memory. These internal safety boundaries are not user-facing result or page ceilings. The Actor also stops before publishing rows that exceed the run spending limit.

Before starting the request, the Actor normalizes and deduplicates exact target values so repeated ASINs, queries, identifiers, or URLs do not create duplicate service work.

`CONTINUATION` is written before request creation, after the returned request ID is known, before every result-page read, and after every durable result page. It records the request phase, first and last request IDs, request count, separate result and source cursors, aggregate fetched and published counts, target progress, and source-plan completion. `continuationCursor` is an authenticated opaque cursor for a fresh run; copy it exactly and keep the same targets, filters, marketplace, operation, and output fields. Never edit or decode an opaque cursor, and never use the raw internal request ID as an input.

When present, terminal `RUN_SUMMARY` is authoritative over provisional recovery records. It distinguishes fetched products, published products, published diagnostics, and total billed Dataset items. It identifies whether a diagnostic is present and repeats its safe code, message, next action, retryability, and documentation link. It also reports request identity, requested and effective product limits, result pages, elapsed time, and a `continuationStatus` of `complete`, `item-limit`, `spending-limit`, `interrupted`, or `not-started`. An unresolved Dataset-visibility or publication decision intentionally has no terminal `RUN_SUMMARY`: `RECOVERY_STATUS` carries visibility-only evidence, while `PUBLICATION_RECOVERY` preserves the exact unbilled diagnostic body awaiting fenced recovery.

The Actor automatically drains every stored-result cursor and launches the next bounded source request while the run has capacity. Request creation uses one deterministic, account-scoped idempotency key per logical source chunk, so retrying a lost POST response resolves to the original request. Deduplication by validated product URL spans all chunks, and result positions remain contiguous. If an API reader disconnects, the Apify run continues independently; retain the Apify run ID, reconnect later, and page through its stored default Dataset.

On an Apify migration or process restart, the Actor reads `CONTINUATION`, polls the exact in-flight request or replays the same idempotent create, scans the default Dataset, and reconciles product identities through the fenced backend ledger before publishing again. A Dataset row written just before interruption is therefore not published or billed a second time. The runtime also reserves 30 seconds before `ACTOR_TIMEOUT_AT` to persist its latest checkpoint, summary, or diagnostic. For a fresh run after an item, spending, or time boundary, copy the authenticated opaque `continuationCursor`; the Actor verifies its current version, cryptographic authenticity, and logical-input fingerprint before resuming.

### Limit dataset columns

The Dataset contract declares 96 properties. Product items use up to 88: 86 projectable Amazon fields plus Actor-owned `recordType` and `extractedAt`. Diagnostic items use eight additional diagnostic-only fields plus the shared `recordType`, `marketplace`, and optional `operation`. Leave `outputFields` empty to return every available product field. To reduce product width, select up to 86 supported result fields:

```json
{
  "query": "mechanical keyboard",
  "maxItems": 50,
  "maxPages": 2,
  "outputFields": [
    "title",
    "asin",
    "priceText",
    "rating",
    "reviewCount",
    "imageUrls"
  ]
}
```

Required identity, provenance, and Actor-owned fields stay present when applicable. The Actor always retains `recordType`, `marketplace`, `operation`, and `extractedAt`. Product rows also retain `sourceUrl` and `url` so every product remains identifiable.

### Use dataset views

The Dataset includes these views:

- **Overview** shows identity, rank, price, rating, stock, seller, image, URL, and extraction time
- **Diagnostics** shows stable cause, explanation, recommended action, retryability, context, and documentation
- **Pricing and availability** shows price, discount, stock, shipping, delivery, seller, fulfillment, and structured offer fields
- **Product details** shows descriptions, identifiers, catalog attributes, categories, ranks, specifications, variants, and media
- **Reviews and questions** shows ratings, rating distribution, counts, visible samples, and customer photos
- **Extraction quality** shows source and detail provenance, parser classification, requested features, and coverage

Open the Dataset tab to export JSON, CSV, Excel, XML, RSS, or JSONL. You can also read the Dataset through the Apify API, save inputs as Tasks, schedule recurring runs, trigger webhooks, and connect supported Apify integrations.

### Use the Amazon product data scraper API from Python

Install the official `apify-client` package, keep your API token in the `APIFY_TOKEN` environment variable, and call the same validated input used in the Console:

```python
import os

from apify_client import ApifyClient

client = ApifyClient(os.environ["APIFY_TOKEN"])
run = client.actor("tovuk/amazon-product-scraper").call(
    run_input={
        "query": "usb c cable",
        "marketplace": "amazon.com",
        "maxItems": 10,
        "maxPages": 1,
    }
)
items = list(client.dataset(run["defaultDatasetId"]).iterate_items())
```

The call waits for completion and then reads the default Dataset. For asynchronous systems, start a run through the REST API, retain its run ID, poll until the run reaches a terminal status, and then read `defaultDatasetId`.

### Related Amazon scrapers

Use a focused Actor when every run has one intent. Each listing shares this Actor's tested runtime and output contract while exposing a smaller input surface:

- [Amazon Search Scraper](https://apify.com/tovuk/amazon-search-scraper) for keyword and search-result product records
- [Amazon Bestsellers Scraper](https://apify.com/tovuk/amazon-bestsellers-scraper) for ranked products and category charts
- [Amazon ASIN Scraper](https://apify.com/tovuk/amazon-asins-scraper) for direct product lookup from ASIN lists
- [Amazon Seller Scraper](https://apify.com/tovuk/amazon-seller-scraper) for storefront and seller-page product records

The Amazon Reviews Scraper remains private until its complete review workflow passes the same live acceptance standard as the product Actors.

### Amazon product scraper FAQ

#### Can I scrape more than 1,000 Amazon products in one run?

Yes. Set `maxItems` to `0` for no separate item ceiling, then set `maxPages`, `timeoutSecs`, and the Apify maximum cost per run for the work you want. Large listing jobs use bounded internal requests and one deduplicated Dataset. Amazon can expose fewer matching products, and active filters or spending limits can lower the final count.

#### Can an API client or agent continue from where it stopped?

Yes. When only the API client disconnects, keep the Apify run ID, poll that run after reconnecting, then page through its default Dataset. Apify migrations and same-run process restarts recover automatically from durable checkpoints. To continue in a fresh run after an item, spending, or time boundary, copy `CONTINUATION.continuationCursor` into the new input without changing the logical target or output fields. A `complete` state means the explicit source plan finished; `item-limit` or `spending-limit` explains why it stopped earlier.

#### Can I use the Amazon product scraper from Python?

Yes. Use the Python example above with `apify-client`, or call the Actor REST API from any language. The Console, API, scheduled Tasks, and integrations all use the same validated input and Dataset contract.

#### Can I scrape Amazon products by ASIN, seller, category, or keyword?

Yes. Use `asins`, `sellerUrls`, `categoryUrls` or `categoryIds`, and `query` or `searchQueries`. Keep one compatible operation and marketplace in each run.

#### Does the Actor return Amazon reviews and offers?

Product records can include visible review samples, review counts, offer counts, sellers, prices, and shipping fields when Amazon exposes them. The product scraper does not promise one complete row for every review or marketplace offer.

### Pricing and spending limits

This Actor uses one [pay-per-event charge](https://docs.apify.com/actors/publishing/monetize/pay-per-event). One transparent record price covers all available fields. The current rates below apply until the scheduled pricing change on August 8, 2026 at 02:23 UTC. The live **Pricing** panel remains the authoritative source for your plan's price.

| Billing item | Price | When it applies |
| --- | ---: | --- |
| Actor start | `$0` | No start event is configured, so starting a run is free |
| Default Dataset item | Plan price below | One visible product record or one transparent handled diagnostic |
| Other events | `$0` | No query, page, field, review, offer, seller, or add-on events |
| Platform usage surcharge | `$0` | The Dataset-item price includes platform usage |

| Apify plan | Per Dataset item | 10 items | 100 items | 1,000 items |
| --- | ---: | ---: | ---: | ---: |
| Free | `$0.05000` | `$0.50000` | `$5.00` | `$50.00` |
| Bronze | `$0.00050` | `$0.00500` | `$0.050` | `$0.50` |
| Silver | `$0.00050` | `$0.00500` | `$0.050` | `$0.50` |
| Gold | `$0.00050` | `$0.00500` | `$0.050` | `$0.50` |
| Platinum | `$0.00050` | `$0.00500` | `$0.050` | `$0.50` |
| Diamond | `$0.00050` | `$0.00500` | `$0.050` | `$0.50` |

The Free-plan Dataset-item price is exactly 100 times the paid-plan Dataset-item price. Bronze, Silver, Gold, Platinum, and Diamond all use the same `$0.00050` rate, so upgrading to any paid plan unlocks the full 99% price reduction while the Free plan remains suitable for bounded evaluation runs.

The release configuration omits `apify-actor-start`. You pay no start fee, and the run does not receive the five-second compute coverage attached to Apify's synthetic start event.

One Dataset-item charge maps to one visible product record or one transparent diagnostic item. Apify automatically charges `apify-default-dataset-item` for each accepted row written to the default Dataset. The Actor does not issue a separate custom charge. Product items use `recordType: "product"`. When a handled invalid, empty, or recoverable run publishes no product and Dataset state is decidable, it writes exactly one `recordType: "diagnostic"` item and preserves the same immutable body under `DIAGNOSTIC` for direct access by users and agents.

Set a positive `maxItems` value to bound product results, or use `0` to rely on page, target, timeout, and spending bounds. A diagnostic can add one Dataset item beyond the product count. Set the [Apify maximum cost per run](https://docs.apify.com/actors/publishing/monetize/pay-per-event#respect-user-spending-limits) for an independent monetary cap. The Actor checks remaining capacity before service work and before every result page and stops when Apify reports that the spending limit was reached. If the platform reports zero remaining event capacity, it can prevent the diagnostic Dataset item too; KVS retains the safe outcome without claiming a billed row. Dataset-visibility uncertainty is a second honest zero-row exception: the Actor records provisional recovery evidence, issues no Dataset write, and waits for a later safe reconciliation before producing a terminal summary.

### Data coverage and limitations

- The Actor collects Amazon pages available without signing in
- Amazon can vary content by marketplace, location, language, session, and time
- A field can be `null`, empty, or absent when Amazon does not render it
- Search and chart pagination can end before the configured page limit
- Review and question modes return visible samples in product-centric records, not private account content or guaranteed complete histories
- Offer data reflects visible page content and does not guarantee every marketplace seller or buy-box change
- Numeric bestseller rank is returned only when the page exposes a supported rank signal
- One run captures current values; schedule repeated runs to build a time series
- The Actor does not provide historical prices from before your first run
- Amazon page changes and transient blocking can reduce output; handled failures complete with a retryable diagnostic

### Troubleshooting

#### Input is rejected

Provide at least one supported target and remove unknown fields. Check array limits, URL length, marketplace domain, ASIN shape, and operation-target compatibility.

Apify validates the declared input schema before starting the Actor. A structurally invalid API or Console input has no Actor run, Dataset, key-value store, or billable event, so follow the platform validation message and the generated Input/API documentation. An input that starts but fails semantic validation completes successfully with one billed diagnostic Dataset item, immutable `DIAGNOSTIC`, and terminal `RUN_SUMMARY` when event capacity remains and Dataset publication is decidable. An unresolved publication or visibility state stays provisional and never risks another billed write merely to produce a summary.

#### The run returns no products

Open the diagnostic Dataset item or the durable `DIAGNOSTIC` Actor output and read its `message`, `nextAction`, and `documentationUrl`. Confirm that the target opens without signing in for the selected marketplace, then retry with one query, `maxItems` set to 10, and `maxPages` set to 1.

#### Some fields are missing

Amazon did not expose every field on the source page. Check `extractionQuality`, `featureCoverage`, and `rawTextExcerpt` in the **Extraction quality** view.

#### Prices or delivery text use the wrong region

Align `marketplace`, `deliveryLocation`, `proxyCountryCode`, and `language`. Create separate Tasks for different marketplaces or delivery regions.

#### The run times out

Reduce the target count, `maxItems`, or `maxPages`. Increase `timeoutSecs` only after a smaller run succeeds.

#### A run reaches its spending limit

The Actor publishes only items that fit the remaining event budget and records the budget-limited state in `DIAGNOSTIC` and `RUN_SUMMARY`. When no product was published and capacity remains, the single diagnostic row is the billed result; it is explicitly typed and never pretends to be a product.

### Privacy and lawful use

Use this Actor only for lawful collection and processing of Amazon data available without signing in. Review Amazon's terms and the laws that apply to your use case.

Do not submit credentials, cookies, access tokens, private URLs, personal street addresses, or other private data. Configure Apify storage retention and delete stored inputs or datasets when your policy requires it.

**Unofficial Actor:** This independent Actor is not affiliated with, endorsed by, or sponsored by Amazon. Amazon is a trademark of Amazon.com, Inc. or its affiliates.

### Support

Open the Actor's **Issues** tab when you need help. Include the run ID, operation, marketplace, sanitized input, and a shareable Amazon target example.

Never post credentials, cookies, access tokens, private customer data, or full personal addresses in an issue.

# Actor input Schema

## `query` (type: `string`):

Enter one Amazon search phrase. Start here for a small first run.

## `searchQueries` (type: `array`):

Enter up to 50 Amazon search phrases. Each phrase can contain up to 512 characters.

## `startUrls` (type: `array`):

Add up to 200 Amazon search, product, category, bestseller, seller, review, offer, or question URLs.

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

Add up to 200 Amazon product-detail URLs.

## `asins` (type: `array`):

Add up to 200 ten-character Amazon Standard Identification Numbers.

## `categoryUrls` (type: `array`):

Add up to 100 Amazon category-chart, Best Sellers, New Releases, Movers and Shakers, Most Wished For, or Gift Ideas URLs. Put search-category URLs under Start URLs instead.

## `categoryIds` (type: `array`):

Add up to 100 Amazon bestseller category identifiers. Use category URLs when you already have full URLs.

## `sellerUrls` (type: `array`):

Add up to 100 Amazon seller or storefront URLs.

## `operation` (type: `string`):

Leave Auto selected to infer one compatible operation for the run. Every supplied target must match that operation; split incompatible page types into separate runs.

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

Choose the Amazon domain used to build query, ASIN, and category-ID targets. Explicit URLs must use a supported Amazon domain.

## `deliveryLocation` (type: `string`):

Optional city, ZIP code, or postal code for delivery-localized results. Do not enter a full personal address.

## `proxyCountryCode` (type: `string`):

Optional two-letter country hint for managed retrieval. This field does not accept proxy credentials or URLs.

## `proxyCity` (type: `string`):

Optional international city hint containing Unicode letters, marks, numbers, spaces, periods, apostrophes, hyphens, or underscores.

## `language` (type: `string`):

Optional language or locale hint, such as en-US, de-DE, or ja-JP.

## `minRating` (type: `number`):

Keep product rows whose parsed rating is at least this value. Rows without a parsed rating do not match an active minimum.

## `minReviews` (type: `integer`):

Keep product rows whose parsed review count is at least this value. Rows without a parsed review count do not match an active minimum.

## `titleIncludeKeywords` (type: `array`):

Keep product rows whose title contains at least one of up to 50 terms, matched case-insensitively.

## `titleExcludeKeywords` (type: `array`):

Remove product rows whose title contains any of up to 50 terms, matched case-insensitively.

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

Remove rows identified by a sponsored badge or ad position.

## `maxReviews` (type: `integer`):

Limit nested reviewSamples after review filters are applied. Use 0 or leave empty to keep every sample Amazon exposes on the fetched page.

## `reviewRatings` (type: `array`):

Keep nested reviewSamples in the selected integral star buckets. This filters available samples; it does not create separate full-review rows.

## `reviewKeywords` (type: `array`):

Keep nested reviewSamples containing at least one of up to 50 terms in their parsed text.

## `reviewsStartDate` (type: `string`):

Inclusive lower date bound for nested reviewSamples, in YYYY-MM-DD format.

## `reviewsEndDate` (type: `string`):

Inclusive upper date bound for nested reviewSamples, in YYYY-MM-DD format.

## `reviewSort` (type: `string`):

Sort available nested reviewSamples by source relevance, date, or rating.

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

Maximum product records requested for the run. Set 0 for no separate item ceiling; page, target, timeout, and spending controls still bound the run. The actual count can be lower when Amazon exposes fewer records. A handled zero-product outcome can add exactly one billed diagnostic Dataset item.

## `continuationCursor` (type: `string`):

Optional opaque cursor copied from CONTINUATION after an item, spending, or time boundary. Keep the same targets, filters, marketplace, operation, and output fields.

## `maxPages` (type: `integer`):

Maximum source pages requested per target. The Actor continues through opaque backend chunks, and Amazon can expose fewer pages than requested.

## `enablePagination` (type: `boolean`):

Allow traversal up to Maximum pages. Disable this to process only the first source page.

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

Maximum Amazon source pages requested concurrently. Lower this when a target is sensitive to parallel requests.

## `outputFields` (type: `array`):

Optional product-field projection. Select any of the 86 supported fields, or leave empty to preserve every available field. Required identity and Actor metadata fields are always retained.

## `timeoutSecs` (type: `integer`):

Maximum time to wait for the request and paginated results before failing with a sanitized error.

## Actor input object example

```json
{
  "query": "usb c cable",
  "searchQueries": [
    "usb c cable",
    "mechanical keyboard"
  ],
  "startUrls": [
    {
      "url": "https://www.amazon.com/s?k=usb+c+cable"
    }
  ],
  "productUrls": [
    "https://www.amazon.com/dp/B088NRLMPV"
  ],
  "asins": [
    "B088NRLMPV"
  ],
  "categoryUrls": [
    "https://www.amazon.com/gp/bestsellers/electronics"
  ],
  "categoryIds": [
    "electronics"
  ],
  "sellerUrls": [
    "https://www.amazon.com/s?me=A294P4X9EWVXLJ&marketplaceID=ATVPDKIKX0DER"
  ],
  "operation": "auto",
  "marketplace": "amazon.com",
  "excludeSponsored": false,
  "maxReviews": 0,
  "reviewsStartDate": "2026-01-01",
  "reviewsEndDate": "2026-12-31",
  "reviewSort": "relevance",
  "maxItems": 10,
  "maxPages": 1,
  "enablePagination": true,
  "maxConcurrency": 4,
  "outputFields": [
    "title",
    "asin",
    "priceText",
    "rating",
    "reviewCount",
    "imageUrls"
  ],
  "timeoutSecs": 240
}
```

# Actor output Schema

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

Normalized Amazon product records or one billed diagnostic item for a handled zero-product outcome.

## `diagnostic` (type: `string`):

Immutable diagnostic publication body, including its stable code, explanation, next action, retryability, and Actor documentation link. A terminal RUN\_SUMMARY confirms when the same body was settled in the billed Dataset.

## `publicationRecovery` (type: `string`):

Provisional, non-billed exact diagnostic body awaiting fenced ownership or publication recovery. It is not a terminal result and must not be copied into the Dataset without durable authorization.

## `recoveryStatus` (type: `string`):

Advisory, non-billed recovery evidence used while Dataset visibility is unavailable. A terminal RUN\_SUMMARY takes precedence if both records exist.

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

Authoritative terminal request, item, page, budget, continuation, and timing state. An unresolved recovery can intentionally have no RUN\_SUMMARY.

## `continuation` (type: `string`):

Latest restart-safe request phase, signed continuation cursor, opaque result and source cursors, completion state, and reconciled aggregate counts.

# 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 = {
    "query": "usb c cable"
};

// Run the Actor and wait for it to finish
const run = await client.actor("tovuk/amazon-product-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 = { "query": "usb c cable" }

# Run the Actor and wait for it to finish
run = client.actor("tovuk/amazon-product-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "query": "usb c cable"
}' |
apify call tovuk/amazon-product-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=tovuk/amazon-product-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/acts/y7ycSG6bW9ajJdVyB/builds/Esu7RfxE0X4WSECfQ/openapi.json