# Amazon ASIN Scraper (`fastdataapi/amazon-asin-scraper`) Actor Amazon ASIN Scraper — Extract Amazon product data using ASINs, including titles, prices, ratings, reviews, images, availability, brand names, and product URLs. Useful for product research, price tracking, competitor analysis, and e-commerce insights. - **URL**: https://apify.com/fastdataapi/amazon-asin-scraper.md - **Developed by:** [Fast Data API](https://apify.com/fastdataapi) (community) - **Stats:** 3 total users, 2 monthly users, 100.0% runs succeeded, 0 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? An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes. In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours, and optionally produces a well-defined JSON output, datasets with results, or files in key-value store. In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server. Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md. ## How to integrate an Actor? If asked about integration, you help developers integrate Actors into their projects. You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready. Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run. For examples already wired to this Actor's own input schema, see the [API](#api) section below. Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`). # README ### Amazon ASIN Scraper — Extract Products, Variants and Bestseller Ranks Available on the [Apify Store](https://apify.com/fastdataapi/amazon-asin-scraper) (Apify Actor ID: fastdataapi/amazon-asin-scraper). Paste a list of Amazon ASINs and this Actor returns one structured product record per ASIN — buy-box price, stock state, rating histogram, Best Sellers Rank, images, A+ content and variant ASINs, across 20 Amazon storefronts in local currency. No Amazon account, login or API key is required. Unlike scrapers that return raw HTML, it returns typed JSON — ready for your model, database or pipeline without a parsing step. This guide covers every input and output field and how teams use it for price monitoring and catalogue enrichment. ![Amazon ASIN Scraper output: price, stars, seller, ranks and variants as JSON](https://api.apify.com/v2/key-value-stores/Lg9lp51Levfro6SrV/records/i-amazon-asin-hero.webp) **Review text is not included.** Amazon serves no review bodies to logged-out requests — on the product page or on `/product-reviews/`. `reviewsCount`, `stars` and `starsBreakdown` are returned; review sentences are not. This is stated up front because it is the one gap worth knowing before you build a review-mining workflow on top of this Actor. *** ### 🧭 What Does Amazon ASIN Scraper Pay Per Events Do? Amazon ASIN Scraper Pay Per Events is an Apify Actor and Amazon ASIN data extractor that turns a list of Amazon ASINs into structured product data. An ASIN (Amazon Standard Identification Number) is the 10-character code every Amazon listing carries in its URL after `/dp/`; give the Actor a batch of them and it fetches each product page directly, parses Amazon's markup and inline JSON, and returns one dataset row per ASIN. **No Amazon account, login or API key is required** — every field comes from the public, logged-out product page. What it returns, per ASIN: - 💰 Buy-box price and list price, scoped to the listing's own price containers — never a neighbouring product's price - ⭐ Star rating plus the full 5★→1★ rating histogram (`starsBreakdown`) as fractions - 🏅 Best Sellers Rank per category, with the browse-node id and a link to that rank chart (`bestsellerRanks`) - 📦 Stock state, condition, delivery estimate and buy-box seller identity - 🖼️ Thumbnail, gallery and high-resolution image URLs, plus a video count - 🎨 A+ content modules and brand story cards (`aPlusContent`, `brandStory`) - 🔀 Sibling variant ASINs with their labels and thumbnails (`variantAsins`, `variantDetails`) *** ### Features & Capabilities The Actor's capabilities split into three groups: what it extracts per product, how that compares with other Amazon ASIN scrapers on the Apify Store, and where it fits alongside other Amazon-focused Actors in this collection. #### Core features - **59-field product record per ASIN** — pricing, ratings, ranking, media, content and fulfilment data in one row, documented in full below - **Listing-scoped price extraction** — `price` and `listPrice` are read only from the page sections that provably belong to the listing being scraped. There is no document-wide fallback, so a listing with no buy box of its own returns `price: null` instead of a neighbouring "customers also viewed" product's price - **Storefront-matched locale** — each `amazonDomain` request is matched to that storefront's own locale and currency settings, so `amazon.de` returns euros and `amazon.co.jp` returns yen instead of Amazon's own USD conversion - **Full rating histogram** — `starsBreakdown` gives all five buckets (`5star` … `1star`) as fractions, read from Amazon's current React-rendered histogram markup, not just the aggregate `stars` figure - **Rich content fields** — `aPlusContent` (modules, images, video, hotspots) and `brandStory` (carousel cards) are parsed as structured objects, not left as raw HTML - **Honest nulls** — a field Amazon does not render for a given listing comes back `null` (or an empty array/object) rather than a guessed or fabricated value. A handful of fields (on-page review text, Q\&A counts, the buy-box offer list, the price-range widget, the AI review-insights summary, manufacturer support copy) are carried in the schema for completeness but come back empty on almost every listing, because Amazon rarely or never renders that data to a logged-out request — see the field table below for which ones - **Uncharged failures** — an ASIN that fails to fetch still produces a dataset row (`{"asin": ..., "error": "fetch_failed"}`) so you can see which inputs did not come back, and that row is **not** billed #### How Amazon ASIN Scraper Pay Per Events compares to other Amazon scrapers Checked on the Apify Store on 26 July 2026: | Feature | This Actor | junglee/amazon-asins-scraper | jaybird/amazon-product-data-scraper | | --- | --- | --- | --- | | Output format | Typed JSON, CSV, Excel | JSON, XML, CSV, Excel, HTML | JSON, CSV, Excel | | Input | ASIN list | ASIN | Product URL list (up to 100/run) | | Rating histogram field | ✅ `starsBreakdown`, 5 buckets | ❌ not listed | ❌ not listed | | A+ content / brand story | ✅ `aPlusContent`, `brandStory` | ❌ not listed | ❌ not listed | | Storefronts | 20, locale-matched | Not documented | Any Amazon domain, currency not documented | | Pricing model | Pay per event | $40/month rental + platform usage | Pay per event, $1 / 1,000 products | | Failed items billed | No | Not documented | No | | Reachable via Apify MCP | ✅ | ✅ (documented MCP tab) | Not documented | If your use case is feeding structured data to an LLM, the output-format row is the decision-maker — HTML parsing inside an agent loop is a reliability failure mode, not a feature. junglee's own JSON sample shows a flattened `price.value` key rather than a nested object, which is worth checking against your parser if you compare the two. #### When another tool might suit you better If you need actual **review body text**, jaybird/amazon-product-data-scraper's listing advertises a `topReviews` field (title, rating, body, author, date) — this Actor does not attempt that extraction because Amazon does not serve review bodies to logged-out requests, and a workaround that requires login is outside its scope. If you need **cross-run Best Sellers Rank time-series tracking, rank-change webhooks or built-in AI competitive analysis**, harvestlab/amazon-scraper's listing documents exactly that as a dedicated feature set (`trackBestsellerRank`, `alertWebhookUrl`, five LLM providers); this Actor takes one snapshot per run and leaves diffing across runs to you (see the Strategy Guide below for the pattern). #### Amazon ASIN Scraper Pay Per Events within this Amazon data collection Amazon ASIN Scraper Pay Per Events covers individual product lookups by ASIN. For keyword- or URL-based product **discovery**, use Amazon Search Products Scraper. For deal and discount hunting, use Amazon Today's Deals Scraper By Discount, Price & Category. For ongoing buy-box, seller and MAP monitoring on a fixed ASIN list, use Amazon Buy Box, Seller & MAP Monitor — a narrower, faster companion to the full product record this Actor returns. *** ### Why do developers and data teams scrape Amazon? #### Sellers and repricers Third-party sellers and brand owners use it as an Amazon ASIN price checker for their own and competitors' ASINs on a schedule, pulling `price`, `listPrice`, `inStock` and `seller`, and react when `price` drops below a floor or `inStock` flips to `false`. `bestsellerRanks` adds category-rank context so a price change can be read alongside demand rather than in isolation. #### AI training data and RAG indexing `description`, `features`, `attributes` and `productOverview` are the fields carrying the most descriptive text per product and chunk cleanly for a vector store — a product-catalogue RAG index answering "what does this listing say about X" draws directly from them. For training data, `price`, `stars`, `starsBreakdown` and `bestsellerRanks` are the most structurally consistent numeric fields across records, useful for demand or pricing models. Every field returns as a typed primitive, object or array — no HTML to strip before indexing. #### Competitive and market intelligence Track a competitor's `bestsellerRanks[].rank` per category and `price` over repeated runs to see whether a rank move follows a price cut or a stock-out. `isAmazonChoice` and `amazonChoiceText` flag badge changes worth watching on contested categories. #### Research and academic use Public product-catalogue data — pricing distributions, rating histograms, category structure via `breadCrumbs` — supports market-structure and consumer-behaviour research. Scope stays to what Amazon renders publicly; no account or login is used to reach any field. #### Product and SaaS development `attributes`, `productOverview`, images and `bestsellerRanks` are the raw material for a catalogue-enrichment API, a price-comparison tool, or a monitoring dashboard built on top of Apify's scheduled runs and dataset API rather than your own scraping infrastructure. *** ### 🍚 Input Parameters ![Amazon ASIN Scraper input form with ASINs, domain, language and ZIP code](https://api.apify.com/v2/key-value-stores/Lg9lp51Levfro6SrV/records/i-amazon-asin-input.webp) All six input fields, exactly as defined in `.actor/actor.json`. Only `asins` is required. | Parameter | Required | Type | Default / constraints | Description | | --- | --- | --- | --- | --- | | `asins` | Yes | array of strings | — (`editor: stringList`) | Amazon ASINs to scrape, 10 alphanumeric characters each (e.g. `B07GBZ4Q68`). Bulk paste is supported — ASINs run concurrently. Prefill: `["B07GBZ4Q68", "B0CJ4V4TRP", "B07KQWR72Z"]` | | `amazonDomain` | No | string | `"amazon.com"` | Storefront to scrape. The Actor matches its locale and currency settings to that storefront, so prices come back in the local currency | | `language` | No | string (enum) | `"en"` | Optional display language, sent as `?language=…`. Does not change the currency — the marketplace does. Options: `""` (Auto), `en`, `en_US`, `en_GB`, `de`, `fr`, `es`, `it`, `nl`, `pl`, `pt`, `pt_BR`, `sv`, `tr`, `cs`, `da`, `ja`, `zh_CN`, `zh_TW`, `hi` | | `proxyCountry` | No | string (enum) | `"AUTO_SELECT_PROXY_COUNTRY"` | Proxy exit country. Auto select matches the exit to the marketplace; a country that contradicts the marketplace is overridden back to the marketplace's own country and the override is logged. Options: `AUTO_SELECT_PROXY_COUNTRY`, `US`, `GB`, `DE`, `FR`, `ES`, `IT`, `CA`, `AU`, `JP`, `IN`, `BR`, `MX`, `NL`, `PL`, `TR`, `SE`, `AE` | | `zipCode` | No | string | `""` | Destination ZIP/postal code (e.g. `10001`, `SW1A 1AA`) so price and delivery reflect that address. The Actor sets this delivery address before scraping; not every storefront accepts every format | | `proxyConfiguration` | No | object (`editor: proxy`) | Prefill: `{"useApifyProxy": true, "apifyProxyGroups": ["RESIDENTIAL"]}` | Full proxy override — Apify proxy groups or your own URLs. Most runs can leave this empty | There are no credential or API-key parameters in this schema — nothing here is marked `isSecret`, and none is needed. #### Free plan limits Free plan: up to 20 product rows per run (all ASINs together) and 200 per month; paid plans have no limit. #### Example input ```json { "asins": ["B07GBZ4Q68", "B0CJ4V4TRP", "B07KQWR72Z"], "amazonDomain": "amazon.com", "language": "en", "proxyCountry": "AUTO_SELECT_PROXY_COUNTRY", "zipCode": "10001", "proxyConfiguration": { "useApifyProxy": true, "apifyProxyGroups": ["RESIDENTIAL"] } } ``` #### Supported storefronts and ASIN format An ASIN must match `[A-Za-z0-9]{10}` — anything else is skipped with a warning in the run log rather than sent to Amazon. Duplicate ASINs in the same input are de-duplicated automatically. Twenty storefronts are known to the Actor, each matched to its own currency and language settings so Amazon returns a localized response: `amazon.com` 🇺🇸 · `amazon.co.uk` 🇬🇧 · `amazon.de` 🇩🇪 · `amazon.fr` 🇫🇷 · `amazon.it` 🇮🇹 · `amazon.es` 🇪🇸 · `amazon.nl` 🇳🇱 · `amazon.ie` 🇮🇪 · `amazon.se` 🇸🇪 · `amazon.pl` 🇵🇱 · `amazon.ca` 🇨🇦 · `amazon.com.mx` 🇲🇽 · `amazon.com.br` 🇧🇷 · `amazon.co.jp` 🇯🇵 · `amazon.in` 🇮🇳 · `amazon.com.au` 🇦🇺 · `amazon.sg` 🇸🇬 · `amazon.com.tr` 🇹🇷 · `amazon.ae` 🇦🇪 · `amazon.sa` 🇸🇦. A domain outside this list still runs (the URL is built from whatever you enter), but it gets no locale match, so Amazon serves its own default currency for that request rather than a guessed one. Three example inputs covering different use cases: ```json { "asins": ["B0CJ4V4TRP"], "amazonDomain": "amazon.com", "zipCode": "10001" } ``` ```json { "asins": ["B07GBZ4Q68"], "amazonDomain": "amazon.de", "language": "de", "proxyCountry": "DE" } ``` ```json { "asins": ["B07GBZ4Q68", "B0CJ4V4TRP", "B07KQWR72Z", "B0BSHF7WHW"], "amazonDomain": "amazon.co.uk" } ``` *** ### 📦 Output Format ![Amazon ASIN Scraper output fields: price, starsBreakdown, bestsellerRanks and variantAsins](https://api.apify.com/v2/key-value-stores/Lg9lp51Levfro6SrV/records/i-amazon-asin-output.webp) One dataset row per ASIN, always the same 59 keys — a field Amazon does not render for a given listing is `null` (or `[]`/`{}` for list/object fields) rather than omitted. The same keyed-by-ASIN dictionary is additionally written to the run's default key-value store under the `OUTPUT` key, for a single-file `output.json`-style export alongside the dataset. #### Output for a product ```json { "title": "Logitech G502 HERO High Performance Wired Gaming Mouse", "url": "https://www.amazon.com/gp/product/B07GBZ4Q68?smid=", "asin": "B07GBZ4Q68", "originalAsin": "B07GBZ4Q68", "price": { "value": 37.99, "currency": "$" }, "inStock": true, "inStockText": "In Stock", "listPrice": { "value": 69.99, "currency": "$" }, "brand": "Logitech G", "author": null, "shippingPrice": null, "stars": 4.6, "starsBreakdown": { "5star": 0.81, "4star": 0.11, "3star": 0.04, "2star": 0.01, "1star": 0.03 }, "reviewsCount": 58383, "answeredQuestions": null, "breadCrumbs": "Video Games > PC > Accessories > Gaming Mice", "videosCount": 2, "visitStoreLink": "https://www.amazon.com/stores/Logitech/page/...", "thumbnailImage": "https://m.media-amazon.com/images/I/61mpMH5TzkL._AC_SX679_.jpg", "galleryThumbnails": ["https://m.media-amazon.com/images/I/61mpMH5TzkL._SS40_.jpg"], "highResolutionImages": ["https://m.media-amazon.com/images/I/61mpMH5TzkL._AC_SL1500_.jpg"], "importantInformation": null, "sustainabilityFeatures": null, "description": "Logitech updated its iconic G502 gaming mouse to deliver even higher performance...", "features": ["HERO 25K sensor for accuracy and consistency", "11 programmable buttons", "Adjustable weight system"], "attributes": [{ "key": "Item model number", "value": "910-005469" }, { "key": "Date First Available", "value": "May 10, 2018" }], "productOverview": [{ "key": "Brand", "value": "Logitech G" }, { "key": "Connectivity Technology", "value": "Wired" }], "variantAsins": ["B07GBZ4Q68", "B07GBGY6HN"], "variantDetails": [{ "name": "Black", "thumbnail": "https://m.media-amazon.com/images/I/...", "images": ["https://m.media-amazon.com/images/I/..."], "asin": "B07GBZ4Q68", "price": { "value": 37.99, "currency": null } }], "reviewsLink": "https://www.amazon.com/product-reviews/B07GBZ4Q68", "hasReviews": true, "delivery": "FREE delivery Tomorrow", "fastestDelivery": "Get it as soon as tomorrow", "condition": "New", "returnPolicy": "This item can be returned in its original condition for a full refund within 30 days of receipt.", "support": null, "variantAttributes": [], "manufacturerAttributes": [], "seller": { "name": "Amazon.com", "id": null, "url": "https://www.amazon.com", "reviewsCount": null, "averageRating": null }, "bestsellerRanks": [ { "rank": 17, "category": "Video Games", "categoryNodeId": null, "url": "https://www.amazon.com/gp/bestsellers/videogames/ref=pd_zg_ts_videogames" }, { "rank": 3, "category": "PC Gaming Mice", "categoryNodeId": "402052011", "url": "https://www.amazon.com/gp/bestsellers/videogames/402052011/ref=pd_zg_hrsr_videogames" } ], "isAmazonChoice": true, "amazonChoiceText": "Amazon's Choice for \"gaming mouse\"", "bookDescription": null, "priceRange": null, "aPlusContent": { "title": "From the manufacturer", "rawText": "Engineered for esports...", "rawImages": [{ "name": "Hero image", "url": "https://m.media-amazon.com/images/S/..." }], "rawVideos": [], "modules": [{ "type": "premium-module-1-hero-image", "title": "hero-image", "text": null, "image": { "name": "", "url": "https://m.media-amazon.com/images/S/..." } }] }, "brandStory": { "title": "Logitech G", "image": { "name": "", "url": "https://m.media-amazon.com/images/S/..." }, "items": [{ "title": "Our story", "text": "Founded in 1981...", "url": "https://www.amazon.com/stores/...", "image": { "name": "", "url": "https://m.media-amazon.com/images/S/..." }, "items": [] }] }, "productComparison": null, "aiReviewsSummary": null, "monthlyPurchaseVolume": "10K+ bought in past month", "productPageReviews": [], "productPageReviewsFromOtherCountries": [], "locationText": "Deliver to New York 10001", "loadedCountryCode": "US", "offers": [], "unNormalizedProductUrl": "https://www.amazon.com/dp/B07GBZ4Q68", "shipsFrom": "Amazon.com", "position": 1, "isPinnedOffer": true, "input": "https://www.amazon.com/dp/B07GBZ4Q68" } ``` An ASIN that fails to fetch, or fails to parse, produces a shorter error row instead — `{"asin": "B0XXXXXXXX", "error": "fetch_failed"}` or `{"asin": "B0XXXXXXXX", "error": "parse_error: "}`. Filter these out downstream with `"error" not in row`, or keep them — they are pushed to the same dataset for visibility, but neither is billed. #### Schema stability and export options Field names are stable across runs and do not change when Amazon updates its front end. A handful of fields — raw on-page review bodies (`productPageReviews`, `productPageReviewsFromOtherCountries`), Q\&A count (`answeredQuestions`), the buy-box offer list (`offers`), the price-range widget (`priceRange`), the AI review-insights summary (`aiReviewsSummary`) and manufacturer support copy (`support`) — are kept in the schema for completeness but come back `null`/`[]` on nearly every listing, because Amazon rarely or never renders that data to a logged-out request. Export the dataset as JSON, CSV, Excel (XLSX), XML or HTML directly from the Apify Console **Storage** tab, or pull it programmatically through the Apify API / `apify-client` SDKs. The keyed-by-ASIN `OUTPUT` record in the run's key-value store is a convenience export for callers who want a single `{asin: record}` object instead of an array of rows. *** ### Amazon ASIN Scraper Pay Per Events Strategy Guide Three ways teams actually run this Actor in production, using its real inputs and outputs — not a generic pitch. #### 🎯 Strategy 1: Real-time enrichment pipeline When a new SKU or competitor ASIN enters your system — a procurement form, an inbound webhook, a manually curated list — trigger a run with that single ASIN via the Apify API. Read back `price`, `listPrice`, `inStock`, `stars`, `bestsellerRanks` and `attributes` from the resulting dataset row, and write them onto your own product or watchlist record. Because failed fetches are pushed as uncharged `error` rows rather than silently dropped, your enrichment job can log exactly which ASINs need a retry instead of guessing. #### 🎯 Strategy 2: Scheduled monitoring and alerting Create an Apify Schedule that runs this Actor daily or hourly against a fixed `asins` watchlist. The Actor itself takes one snapshot per run — it does not diff against the previous run — so store each run's `price`, `inStock` and `bestsellerRanks[].rank` values (the dataset or the `OUTPUT` key-value record both work) and compare them to yesterday's values in your own script or workflow tool. Fire an alert — Slack, email, a Zapier/Make step — only when the delta crosses your threshold: a price drop, `inStock` flipping to `false`, or a rank move past a category position you care about. #### 🎯 Strategy 3: Bulk dataset build Paste hundreds or thousands of ASINs into `asins` for a research or training dataset. Requests within a single run fan out at a **fixed internal concurrency of 5** — this is not an exposed input parameter, so it cannot be raised from the Console. For a larger catalogue, split your ASIN list across multiple runs (or launch several runs in parallel via the API) rather than expecting one run to scale its own concurrency. Aggregate the resulting datasets to CSV or a database once every run finishes. #### Strategy comparison at a glance | Strategy | Best for | Run pattern | Output format | | --- | --- | --- | --- | | Real-time enrichment | A single new ASIN appearing in your system | On-demand API call, one small run | JSON row via API or dataset | | Scheduled monitoring | A fixed watchlist tracked over time | Apify Schedule, recurring run | Dataset row per run, diffed externally | | Bulk dataset build | A large one-off catalogue or training set | One or more runs, large `asins` lists | CSV/JSON export from the dataset | *** ### 🌴 Related Amazon Scrapers & Tools | Scraper name | What it extracts | | --- | --- | | Amazon Search Products Scraper | Product results from an Amazon keyword or search-URL, for discovering ASINs to feed into this Actor | | Amazon Today's Deals Scraper By Discount, Price & Category | Today's Deals listings filtered by discount, price and category | | Amazon Buy Box, Seller & MAP Monitor | Ongoing buy-box, seller and MAP monitoring on a fixed ASIN list | *** ### How to integrate Amazon ASIN Scraper Pay Per Events with your stack Amazon ASIN Scraper Pay Per Events works with any language or tool that can make an HTTP request — it runs on Apify, so integration goes through the Apify API and its SDKs rather than a bespoke endpoint. #### Python ```python from apify_client import ApifyClient client = ApifyClient("") run = client.actor("fastdataapi/amazon-asin-scraper").call(run_input={ "asins": ["B07GBZ4Q68", "B0CJ4V4TRP", "B07KQWR72Z"], "amazonDomain": "amazon.com", "zipCode": "10001", }) rows = [] for item in client.dataset(run["defaultDatasetId"]).iterate_items(): if "error" in item: print("failed:", item["asin"], item["error"]) continue rows.append(item) import csv with open("amazon_products.csv", "w", newline="", encoding="utf-8") as f: writer = csv.DictWriter(f, fieldnames=["asin", "title", "price", "listPrice", "stars", "inStock"]) writer.writeheader() for r in rows: writer.writerow({ "asin": r["asin"], "title": r["title"], "price": (r["price"] or {}).get("value"), "listPrice": (r["listPrice"] or {}).get("value"), "stars": r["stars"], "inStock": r["inStock"], }) ``` #### Node.js ```javascript import { ApifyClient } from 'apify-client'; const client = new ApifyClient({ token: '' }); const run = await client.actor('fastdataapi/amazon-asin-scraper').call({ asins: ['B07GBZ4Q68', 'B0CJ4V4TRP', 'B07KQWR72Z'], amazonDomain: 'amazon.com', zipCode: '10001', }); const { items } = await client.dataset(run.defaultDatasetId).listItems(); for (const item of items) { if (item.error) { console.log('failed:', item.asin, item.error); continue; } console.log(item.asin, item.title, item.price?.value, item.inStock); } ``` #### MCP for AI agents This Actor is reachable through Apify's hosted MCP server, which exposes any public Apify Actor as a callable tool: ```text https://mcp.apify.com?tools=fastdataapi/amazon-asin-scraper ``` Point an MCP-compatible client — Claude Desktop, Cursor, or a custom agent built on the MCP spec — at that URL, and the agent can call this Actor mid-task with a list of ASINs and get typed JSON back, without leaving its own conversation loop. #### Async and scheduled pipelines For large ASIN batches, start the run through the API and poll `client.run(run_id).get()` for status rather than blocking on `.call()`, or use Apify's webhook feature to get notified when a run finishes instead of polling. For recurring jobs, create an Apify Schedule against a saved input (see Strategy 2 above) rather than triggering runs from your own cron. *** ### 🎯 Who Needs Amazon ASIN Scraper Pay Per Events? (Use Cases & Industries) #### Sellers and repricers A third-party seller tracks their own and competitors' ASINs daily, watching `price`, `inStock` and `bestsellerRanks[].rank` to catch undercutting or a stock-out before it costs a Buy Box. #### AI training data and RAG indexing An AI engineer indexes `description`, `features` and `attributes` into a vector store so a shopping-assistant agent can answer product questions from live catalogue text instead of a stale scrape held in the model's own training data. #### Competitive and market intelligence A market analyst pulls `price`, `starsBreakdown` and `bestsellerRanks` across a competitor's product line to build a category price-and-demand map, refreshed on whatever cadence the analysis needs. #### Researchers An academic or market researcher builds a public-data sample of pricing and rating distributions across a category using `price`, `stars`, `reviewsCount` and `breadCrumbs` — no account or login is used to reach any of it, and the data collected is limited to what Amazon renders on the public product page. #### Product and SaaS development A developer building a catalogue-enrichment or price-comparison product runs this Actor on a schedule and stores `attributes`, `productOverview` and image URLs as the backing data for their own API, without maintaining their own Amazon-facing scraper. *** ### Is it legal to scrape Amazon? Scraping publicly accessible web pages is broadly permitted under U.S. law — in *hiQ Labs, Inc. v. LinkedIn Corp.*, 938 F.3d 985 (9th Cir. 2019), the Ninth Circuit held that scraping data not gated behind a login does not violate the Computer Fraud and Abuse Act. That precedent concerns access, not Amazon's own contract terms. Separately, Amazon's Conditions of Use restrict automated access to its site; violating them is a potential **contract** dispute between you and Amazon, not a criminal matter, and the consequences run from a blocked IP to account action rather than prosecution. This Actor returns product catalogue data — prices, ratings, ranks, descriptions, images — not personal data about identifiable individuals, so GDPR and CCPA's personal-data obligations do not attach to its output in the way they would for a scraper of user profiles or reviewer identities. Amazon ASIN Scraper Pay Per Events returns only publicly accessible data. What you do with that data is your responsibility — consult legal counsel for commercial applications, and before building a competing catalogue product on top of the results. *** ### ❓ Frequently asked questions #### Does Amazon ASIN Scraper Pay Per Events work without an Amazon account? Yes. No Amazon account, login, cookie or API key is required — every field is read from the public, logged-out product page. #### How does it handle Amazon's anti-scraping measures? Each request looks like an ordinary desktop browser visit and runs through Apify Proxy (Residential is auto-selected by default). A short or empty response, or one carrying a CAPTCHA / "robot check" marker, is treated as a blocked page and retried with a fresh proxy session rather than returned as data. If `zipCode` is set, the actor sets that delivery address first so the returned page reflects it. #### Can I run it at scale without getting blocked? There is no published uptime or success-rate figure for this Actor. Concurrency within a single run is fixed at 5 — not an input you can raise — so scaling a large ASIN list means splitting it across multiple runs rather than one large one. Setting `zipCode` and leaving `proxyCountry` on Auto (which matches the exit to the marketplace) are the two levers documented in the schema for improving how often a page returns usable data. #### How fresh is the data it returns? Live. Every run fetches the product page fresh over HTTP; nothing is served from a cache. Two runs against the same ASIN minutes apart can return different `price` or `inStock` values if Amazon's own page has changed. #### Which fields work best for AI training and RAG indexing? For RAG: `description`, `features` and `attributes` carry the most descriptive text per product and chunk cleanly. For training data: `price`, `stars`, `starsBreakdown` and `bestsellerRanks` are the most structurally consistent numeric/categorical fields across records. All fields return as typed primitives, objects or arrays — no HTML parsing is needed before indexing. #### Is this data-protection relevant? No individual reviewer, buyer or seller-employee identity is returned — `seller` carries a business name, not a person. The output is business/product data, so the personal-data frameworks that govern profile or reviewer scraping do not apply here in the same way; storage and use decisions still sit with you. #### Does it work with Claude, ChatGPT and other AI agent tools? Yes. It is reachable through Apify's hosted MCP server (`https://mcp.apify.com?tools=fastdataapi/amazon-asin-scraper`), and callable as a standard HTTP endpoint through the Apify API by any agent framework — LangChain, CrewAI, a custom tool definition. Every response is typed JSON, ready to drop into an LLM context window without a parsing step. #### Is this an alternative to Amazon's Product Advertising API? For read-only product lookups, yes in effect — the Product Advertising API requires Amazon Associates approval and ties usage to your affiliate sales volume. This Actor needs neither; you paste ASINs and get JSON back, at the cost of running an HTTP scrape instead of a sanctioned API call. #### Can I mix marketplaces in one run? No — one run targets one `amazonDomain`. Run the Actor once per storefront and join the results on `asin` if you need several marketplaces side by side. #### How does it compare to other Amazon ASIN scrapers? Checked on the Apify Store on 26 July 2026: junglee/amazon-asins-scraper is the most-used option and adds offer/seller-competitor data and a rental pricing model ($40/month plus platform usage); it does not document a rating histogram or A+ content field. jaybird/amazon-product-data-scraper is a comparable pay-per-event, HTTP-only scraper that additionally advertises up to 5 top reviews per product, which this Actor does not attempt. harvestlab/amazon-scraper is a much broader suite — search scraping, cross-run BSR time-series tracking, alert webhooks and multi-provider AI analysis — at the cost of far more input surface to configure. This Actor's distinction is depth on the single product record itself: the full rating histogram and structured A+/brand-story content, returned from an ASIN list with six input fields. *** ### Disclaimer Amazon ASIN Scraper Pay Per Events extracts only publicly available data from Amazon product pages. This tool is intended for lawful use cases only. Users are responsible for complying with Amazon's Conditions of Use and applicable data protection laws in their jurisdiction. # Actor input Schema ## `asins` (type: `array`): Paste one or more ASINs (10 alphanumeric characters, e.g. `B07GBZ4Q68`). Bulk paste is supported — ASINs run concurrently. Find an ASIN in the URL after `/dp/` or under *Product details*. ## `amazonDomain` (type: `string`): Storefront to scrape. The actor matches its locale and currency settings to this storefront, so prices come back in the **local** currency. Known storefronts: `amazon.com`, `amazon.co.uk`, `amazon.de`, `amazon.fr`, `amazon.it`, `amazon.es`, `amazon.nl`, `amazon.ie`, `amazon.se`, `amazon.pl`, `amazon.ca`, `amazon.com.mx`, `amazon.com.br`, `amazon.co.jp`, `amazon.in`, `amazon.com.au`, `amazon.sg`, `amazon.com.tr`, `amazon.ae`, `amazon.sa`. ## `language` (type: `string`): Optional language code for the product page text. Leave on Auto to get the storefront's own language. This does **not** change the currency — the marketplace does. ## `proxyCountry` (type: `string`): Proxy exit country. **Auto select** matches the exit to the marketplace you chose. A country that contradicts the marketplace is overridden back to the marketplace's own country (a mismatched exit makes Amazon return a robot-check page) and the override is written to the run log. ## `zipCode` (type: `string`): Optional destination ZIP/postal code (e.g. `10001`, `SW1A 1AA`) so price and delivery reflect that address. The actor sets the delivery address for that ZIP/postal code before scraping. Not every storefront accepts every format. ## `proxyConfiguration` (type: `object`): Full proxy override: Apify groups (Residential / Datacenter) or your own URLs. Most runs can leave this empty. ## Actor input object example ```json { "asins": [ "B07GBZ4Q68", "B0CJ4V4TRP", "B07KQWR72Z" ], "amazonDomain": "amazon.com", "language": "en", "proxyCountry": "AUTO_SELECT_PROXY_COUNTRY", "zipCode": "", "proxyConfiguration": { "useApifyProxy": true, "apifyProxyGroups": [ "RESIDENTIAL" ] } } ``` # Actor output Schema ## `results` (type: `string`): All scraped items in the Actor's default dataset. ## `output` (type: `string`): The full run result as a single JSON object keyed by ASIN, stored in the default key-value store under the key 'OUTPUT' for parity with a stand-alone output.json file. # 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 '' with your token const client = new ApifyClient({ token: '', }); // Prepare Actor input const input = { "asins": [ "B07GBZ4Q68", "B0CJ4V4TRP", "B07KQWR72Z" ], "proxyConfiguration": { "useApifyProxy": true, "apifyProxyGroups": [ "RESIDENTIAL" ] } }; // Run the Actor and wait for it to finish const run = await client.actor("fastdataapi/amazon-asin-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 '' with your token. client = ApifyClient("") # Prepare the Actor input run_input = { "asins": [ "B07GBZ4Q68", "B0CJ4V4TRP", "B07KQWR72Z", ], "proxyConfiguration": { "useApifyProxy": True, "apifyProxyGroups": ["RESIDENTIAL"], }, } # Run the Actor and wait for it to finish run = client.actor("fastdataapi/amazon-asin-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 '{ "asins": [ "B07GBZ4Q68", "B0CJ4V4TRP", "B07KQWR72Z" ], "proxyConfiguration": { "useApifyProxy": true, "apifyProxyGroups": [ "RESIDENTIAL" ] } }' | apify call fastdataapi/amazon-asin-scraper --silent --output-dataset ``` ## MCP server setup ```json { "mcpServers": { "apify": { "type": "http", "url": "https://mcp.apify.com/?tools=fetch-actor-details,fastdataapi/amazon-asin-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 ` 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/4A6HImk66I2NBXF11/builds/RUybak5e10TDGtl2I/openapi.json