# Amazon Product Scraper · Flat Fee (`steadyfetch/amazon-product-scraper`) Actor

One flat fee per product — price, buy box, stock, rating, reviews, variants, ranks, images and specs in one row. Blocked or missing ASINs are never charged.

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

## Pricing

from $1.50 / 1,000 products

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

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

## How to integrate an Actor?

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

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

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

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

# README

## Amazon Product Scraper · Flat Fee

**One flat fee per product. Price, buy box, stock, rating, reviews, variants, bestseller ranks, images and the full specifications table all arrive in one row — there is no second event to pay for. Blocked or missing ASINs are never charged.**

Give it an ASIN or an Amazon product URL. Get the finished product object back.

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

### Output

One row per product. This is a real row from a verified run (ASIN `B0DN4BG1RW` on `amazon.com`), trimmed with `…` where a field is long:

```json
{
  "asin": "B0DN4BG1RW",
  "marketplace": "amazon.com",
  "url": "https://www.amazon.com/dp/B0DN4BG1RW",
  "title": "JBL Vibe Beam 2 - Noise Cancelling Earbuds - White",
  "brand": "JBL",
  "price": 39.94,
  "currency": "USD",
  "listPrice": 64.95,
  "inStock": true,
  "availability": "In Stock",
  "buyBoxSeller": "a s k",
  "buyBoxSellerId": "A2L0UV81X3JLZ5",
  "fulfilledByAmazon": true,
  "rating": 4.1,
  "reviewCount": 6717,
  "boughtInPastMonth": 2000,
  "images": ["https://m.media-amazon.com/images/I/41CpD7mn8tL._AC_SL1200_.jpg", "…"],
  "features": ["Bluetooth 5.3 …"],
  "variants": [{ "asin": "B0DBLMLM81", "attributes": { "color_name": "Blue" } }],
  "variantCount": 4,
  "categoryPath": ["Electronics", "Headphones, Earbuds & Accessories"],
  "bestSellersRank": [{ "rank": 63, "category": "Electronics" }],
  "specs": { "Brand Name": "JBL", "Model Number": "JBLVBEAM2WHT" },
  "deliveryTo": "US",
  "scrapedAt": "2026-08-27T00:00:00.000Z",
  "charged": true,
  "status": "ok"
}
```

Prices and review counts are parsed in the page's own locale, so `4,4 von 5 Sternen` is a rating of 4.4 and `(4.295)` on amazon.de is four thousand reviews, not four.

**`price` can legitimately be `null`, and you should expect it.** Amazon does not always put a price on the page it serves. Some listings replace it with "add this item to your cart to see the price", and some have no live offer at all. On the European marketplaces, where Amazon withholds the buy box from cheap routes far more often than on amazon.com, a product that comes back price-less is retried once through an extra geo-pinned route, so European rows now carry the real local price — `49,00 €` on amazon.fr, `475,00 kr` on amazon.se, `139,00 zł` on amazon.pl — instead of `null`. When every route fails, the row still ships with `price: null` and `priceNote` says what the page showed instead. It is measured behaviour, printed here rather than hidden — the row is charged because it is a real product row, so you should know this before you run a price-only job.

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

**A real dataset, not a mock-up:** [three products across amazon.com, amazon.co.uk and amazon.de plus the summary row](https://api.apify.com/v2/datasets/nsUs4330YEpuUtgyo/items?clean=true\&format=json) — the untouched output of one verified run.

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

```
Actor: steadyfetch/amazon-product-scraper
Input: { "products": ["B0DN4BG1RW", "https://www.amazon.de/dp/B0DBLN4C47"] }
Output: one row per product; charged rows have status "ok" and charged true.
Pricing: one priced event ("product"), all-inclusive, no start fee, no add-ons.
Misses: blocked / not_found / unavailable_in_marketplace / not_a_product / parse_failed /
        source_unavailable all ship as rows with charged:false — read `status`, never guess
        from an empty field.
Notes: omit a field you do not want — do not send null. Limits are hard limits.
       Resuming or resurrecting a run never re-sends or re-bills a product it already delivered.
```

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

### What one product costs

One priced event, `Product`, and nothing else. No start fee, no per-field fee, no delivery-location fee, no "detail" upcharge. The store header reads **from $1.50/1,000 products**.

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

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

**What can fail, and what a failure costs you: nothing.** The two misses you will actually see are `blocked` (Amazon put a robot check in front of every route we tried) and `not_found` (no product page at that id on that marketplace). Both ship as real rows carrying `charged: false`, as do `unavailable_in_marketplace`, `not_a_product`, `parse_failed`, `source_unavailable` and `invalid_input`. A row is charged only if it is a product.

### What you give it

| Input | Example |
|---|---|
| ASIN | `B0DN4BG1RW` |
| Product URL | `https://www.amazon.com/dp/B0DN4BG1RW` |
| `/gp/product/` URL | `https://www.amazon.co.uk/gp/product/B0DBLN4C47` |
| A URL you copied from a search result | `https://www.amazon.de/Sony-WF-C510/dp/B0DBLN4C47/ref=sr_1_1?keywords=sony` |
| An Amazon short link | `https://amzn.to/…`, `https://a.co/d/…` |

Casing does not matter and `www.` is optional — chat apps and link shorteners rewrite URLs, and all of those shapes still resolve.

**Marketplaces: `amazon.com` plus nine European stores — `amazon.co.uk`, `amazon.de`, `amazon.fr`, `amazon.it`, `amazon.es`, `amazon.nl`, `amazon.pl`, `amazon.se`, `amazon.com.be`.** Every one is tested against real captured pages, prices arrive in the store's own currency (`€`, `£`, `kr`, `zł`), and numbers are read in the store's own locale. Other Amazon domains are refused with a clear message rather than half-working. A full product URL always decides its own marketplace; the `Marketplace` setting is only for bare ASINs. European marketplaces lean on an extra recovery route for the price (see the `price` note above) — like everything else here it can fail on a bad hour, and failed items are never charged.

### Error codes — what each uncharged row means

| `status` | What happened | Charged | Worth re-running |
|---|---|---|---|
| `ok` | Complete product row | yes | — |
| `blocked` | Amazon asked us to prove we are not a robot, on every route we tried | no | yes |
| `not_found` | No product page at that id on that marketplace | no | no |
| `unavailable_in_marketplace` | Amazon did not serve that id in that country's catalogue — it usually exists in another one | no | no, try another marketplace |
| `not_a_product` | The id is one of Amazon's own subscription plans, not a product listing — some of them rank in Best Sellers, so a category walk will hand you one | no | no |
| `parse_failed` | Amazon served a page in a layout we do not recognise. That one is on us | no | no |
| `source_unavailable` | Amazon dropped or throttled the request | no | yes |
| `invalid_input` | The value was not an ASIN or an Amazon product URL — the row says exactly why | no | no |
| `cap_reached` / `stopped_at_limit` | A limit you set stopped the run; earlier rows were delivered normally | no | see `resumeCursor` |

**Deliverability, stated honestly:** measured 94–97% of requested products delivered under normal conditions, and lower on amazon.com when Amazon is having a bad hour. The rest come back as uncharged rows saying which kind of miss they were. We would rather print that number than imply 100%.

### Limits are exact

`Max products`, `Max run seconds` and the run's own maximum total charge all stop the run *cleanly*: it still finishes as SUCCEEDED, the summary row names the one setting that stopped it, and `resumeCursor` lists what was left so a second run continues instead of repeating. The product limit is claimed at the moment a row is written, so a cap of 10 delivers 10 rows and bills 10 events even with several fetches in flight.

They hold across a restart too. Long runs get moved between servers by the platform, and a run can be resurrected with one click. When that happens the run reads back what it already delivered and continues from there: **already-delivered products are never sent twice and never billed twice**, a cap of 10 stays a cap of 10 rather than becoming 20, and `Max run seconds` counts seconds of the *run*, not of each restart.

### FAQ

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

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

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

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

**Why is my price null?** Amazon did not display one — see `priceNote` on that row.

**Why did an ASIN come back as `unavailable_in_marketplace`?** It exists in a different country's catalogue. Pass the product URL for that marketplace, or change the `Marketplace` setting.

### Honesty contract

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

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

A product is charged once per run, and once only. That holds whether you sent it as an ASIN and again as a URL, or the run was migrated, restarted or resurrected part-way through.

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

### Steadyfetch Amazon suite

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

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

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

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

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

### Feedback & support

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

# Actor input Schema

## `products` (type: `array`):

ASINs (B0DN4BG1RW) or Amazon product URLs (https://www.amazon.com/dp/B0DN4BG1RW). Send the field as a list — an omitted field is fine, but do not send null.

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

Which Amazon store to look a bare ASIN up in. A full product URL always wins over this setting. Amazon runs a separate catalogue per country, so the same id can exist in one store and not another.

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

Hard cap on delivered products for this run. 0 means every product you listed.

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

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

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

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

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

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

## Actor input object example

```json
{
  "products": [
    "B0DN4BG1RW",
    "https://www.amazon.de/dp/B0DBLN4C47"
  ],
  "marketplace": "amazon.com",
  "maxItems": 0,
  "maxRunSeconds": 3600,
  "includeVariants": true,
  "includeSpecs": true
}
```

# Actor output Schema

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

One row per product: price, currency, list price, stock, buy-box seller, rating, reviews, bought-last-month, variants, bestseller ranks, category path, images, bullet points and the specifications table. Every row carries `charged` and `status`, so the invoice reconciles from the dataset itself.

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

Products that could not be delivered: blocked by Amazon, no product page, not in that marketplace's catalogue, one of Amazon's own subscription plans rather than a product, or a layout we could not read. Each says which it was, whether re-running is worth it, and none of them were charged.

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

Products delivered, uncharged misses by kind, duplicates merged, what stopped the run, and the charged-event totals.

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

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

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "products": [
        "B0DN4BG1RW",
        "https://www.amazon.de/dp/B0DBLN4C47"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("steadyfetch/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 = { "products": [
        "B0DN4BG1RW",
        "https://www.amazon.de/dp/B0DBLN4C47",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("steadyfetch/amazon-product-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 '{
  "products": [
    "B0DN4BG1RW",
    "https://www.amazon.de/dp/B0DBLN4C47"
  ]
}' |
apify call steadyfetch/amazon-product-scraper --silent --output-dataset

```

## MCP server setup

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