# Amazon ASIN Scraper With Profit & Fee Estimates (`scrapier/amazon-asin-scraper`) Actor

Amazon ASIN Scraper: Extract ASINs, product titles, prices, ratings, reviews, categories, sellers, and estimated fees and profit margins. Analyze product profitability, competition, pricing, and sales opportunities for Amazon product research and e-commerce intelligence.

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

## Pricing

from $5.99 / 1,000 results

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

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

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

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

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

# README

### Amazon ASIN Scraper — Product Data With Profit & Fee Estimates

Amazon ASIN Scraper With Profit & Fee Estimates turns a list of ASINs into full product records, then runs every price through Amazon's own referral and FBA fulfilment fee logic to show what a seller actually nets. Each row carries the scraped listing — price, brand, images, attributes, A+ content, variants, bestseller ranks — next to a versioned fee estimate, landed cost, profit per unit, margin, ROI and break-even price. Every response is structured JSON, ready for a spreadsheet, a sourcing pipeline, or an LLM as context. No other Amazon ASIN scraper on the Apify Store computes fees or profit from what it scrapes.

### What is Amazon ASIN Scraper With Profit & Fee Estimates?

Amazon ASIN Scraper With Profit & Fee Estimates queries Amazon's public product detail pages by ASIN and returns two things in every result row: the full scraped product record, and a computed unit-economics estimate — Amazon's referral fee, FBA fulfilment fee, net proceeds and, once you supply a unit cost, profit per unit, margin, ROI and break-even sell price. No Amazon account, Seller Central login or Associates approval is required; every field comes from the public `/dp/<ASIN>` page.

What none of the competing Amazon scrapers on the Apify Store do is the fee and profit math. `junglee/amazon-asins-scraper`, `jaybird/amazon-product-data-scraper` and `harvestlab/amazon-scraper` all return catalogue and pricing data, but none of their documented output fields compute a referral fee, an FBA fulfilment fee, or a profit-per-unit figure (checked on their Apify Store listings, 2026-07-25).

- Full product record — title, brand, price, images, attributes, A+ content, brand story, variants, bestseller ranks, seller and delivery data
- Referral fee + FBA fulfilment fee estimate, itemised per fee in `feeBreakdown[]`
- Profit per unit, margin %, ROI % and break-even sell price once `unitCost` is supplied
- Storefront control via `marketplaceDomain` and `pageLanguage`
- Delivery-location control via `deliveryPostcode`, so the priced buy box matches a real destination
- Proxy/geo control via `exitCountry`, so requests exit from the market you're costing for

### 📦 What data can you get with Amazon ASIN Scraper?

Every successful ASIN produces one dataset row combining a scraped product record with a computed fee and profit estimate. Nothing is fetched from a second endpoint — both come out of parsing the same page.

| Result Type | Extracted Fields | Primary Use Case |
| --- | --- | --- |
| Product record | `title`, `brand`, `price`, `listPrice`, `stars`, `starsBreakdown`, `reviewsCount`, `breadCrumbs`, `attributes`, `features`, `description`, `galleryThumbnails`, `highResolutionImages`, `variantAsins`, `variantDetails`, `bestsellerRanks`, `seller`, `delivery`, `condition`, `aPlusContent`, `brandStory` | Catalogue enrichment, listing QA, competitor teardown |
| Fee & profit estimate | `feeCategory`, `referralFeePercent`, `estimatedReferralFee`, `estimatedClosingFee`, `sizeTier`, `billableWeightPounds`, `estimatedFulfilmentFee`, `estimatedAmazonFeesTotal`, `estimatedNetProceeds`, `landedUnitCost`, `estimatedProfitPerUnit`, `estimatedProfitMarginPercent`, `estimatedRoiPercent`, `estimatedBreakEvenSellPrice`, `feeBreakdown` | Sourcing decisions, PO approval, catalogue-wide profitability audits |
| Sales-volume & rank signal | `salesVolumeAvailable`, `salesVolumeBadgeText`, `estimatedMonthlyUnitsLow`, `estimatedMonthlyUnitsHigh`, `estimatedMonthlyProfitLow`, `bestsellerRanks` | Demand sizing before you commit to a purchase order |

#### Fee & profit estimate

This is the field group nothing else on the Store returns. Referral fee is looked up from the product's own breadcrumb category against a hardcoded, versioned rate table (`feeScheduleVersion`, e.g. `amazon-us-2026-07`) — flat or price-tiered depending on category, with a $0.30 minimum and a $1.80 media closing fee where it applies. FBA fulfilment fee comes from `Item Weight` and `Item Dimensions`, parsed off the page into a size tier (`Small Standard` through `Extra-Large 150+ lb`) and a billable weight — the greater of actual weight and dimensional weight (L×W×H ÷ 139) above the small-standard tier. Net proceeds is sell price minus all three fees. Once you add `unitCost`, `inboundShippingCost` and `extraCostPerUnit`, the same row adds landed cost, profit per unit, margin %, ROI % and the sell price at which you break even. `feeEstimateBasis` and `feeAssumptions` sit next to every money field so the arithmetic can be checked by hand — and every field the fee engine can't support stays `null`, never `0`.

```json
"feeBreakdown": [
  { "fee": "Referral fee", "amount": 3.44, "basis": "8.0% of 42.99 (Consumer Electronics), $0.30 minimum" },
  { "fee": "Closing fee", "amount": 0.0, "basis": "not applicable to this category" },
  { "fee": "FBA fulfilment fee", "amount": 3.68, "basis": "Large Standard, billable weight 1.2 lb" }
]
```

#### Product record

Every ASIN also returns the underlying catalogue record the fee math is built from: title, brand, byline/author, current and list price, stock and condition text, star rating plus the full ratings histogram, review count, breadcrumb category, feature bullets, the full attributes table (the same table `Item Weight`/`Item Dimensions` are parsed from), A+ content modules, brand story carousel, product-comparison widget, variant ASINs with per-variant price and image, bestseller ranks per category, seller and ships-from data, and delivery messaging. Set `trimRichContent: true` to blank the heaviest fields (A+ content, brand story, comparison table, both image arrays) when a costing sheet doesn't need them.

### How does Amazon ASIN Scraper differ from Amazon's official APIs?

Amazon publishes two relevant APIs, and neither alone does what this Actor does. The Product Advertising API (PA-API 5) returns catalogue data but is gated behind an Amazon Associates account and has been formally deprecated — as of the check below, its own documentation redirects to a deprecation notice stating that calls now return an HTTP 403 and that integrators should migrate to the new Creators API. The Selling Partner API's Product Fees API (`getMyFeesEstimateForASIN`) does compute referral and fulfilment fees, but only for an authorised Selling Partner's own account, one ASIN and price per call.

| Feature | Amazon's official APIs | Amazon ASIN Scraper |
| --- | --- | --- |
| Access requirement | Associates account (PA-API, deprecated) or an approved Selling Partner API app (SP-API) | An Apify account only — no Amazon account needed |
| Full catalogue record (images, A+, variants, ranks) | PA-API / Creators API only; SP-API Fees returns fees, not catalogue data | Yes, on every request |
| Referral + FBA fulfilment fee estimate | SP-API `getMyFeesEstimateForASIN` only, for your own seller account | Yes, on any public ASIN |
| Profit / margin / ROI from your unit cost | Not offered by either API | Yes, once `unitCost` is supplied |
| Requests per ASIN | SP-API Fees: 1 request/second, burst of 2, per Amazon's own reference docs | Batched — paste a list, one row streams back per ASIN |
| Setup | PA-API/Creators API developer registration, or SP-API OAuth app approval | Paste ASINs and click Start |

*Sources checked 2026-07-25: PA-API deprecation notice at `affiliate-program.amazon.com/creatorsapi/docs/en-us/paapiv5-deprecation`; SP-API rate limit and request shape at `developer-docs.amazon/sp-api/reference/getmyfeesestimateforasin`.*

Use the official APIs when you already hold Selling Partner credentials and only need fees for your own catalogue inside your own systems. Use Amazon ASIN Scraper when you want the product record and the fee math for any public ASIN — competitor, prospective supplier, or your own — without registering as a developer.

### What is the difference between an Amazon ASIN scraper and an FBA fee calculator?

An ASIN scraper and an FBA fee calculator solve two different halves of the same sourcing decision, and most tools only do one. An ASIN scraper is a catalogue extraction tool: it reads a product page and hands back title, images, price, brand, category, rank and reviews. An FBA fee calculator is a math tool: you type in a price and a category by hand, and it applies Amazon's referral and fulfilment fee tables to tell you what's left — Seller Central's own fee preview and most third-party calculators work this way.

The distinction starts to matter once a catalogue is large enough that manual calculator entry, not scraping, becomes the actual bottleneck — nobody re-types weight, dimensions and category for two hundred SKUs by hand. Amazon ASIN Scraper With Profit & Fee Estimates returns both in one object: the same `attributes` and `breadCrumbs` fields a scraper would give you feed directly into `feeBreakdown[]` and `estimatedProfitPerUnit`, the numbers a calculator would produce, without re-entering a single value per ASIN.

### How to scrape Amazon ASINs with Amazon ASIN Scraper?

1. Open **Amazon ASIN Scraper With Profit & Fee Estimates** on its Apify Store listing (or call it via the Apify API).
2. Paste one ASIN per line into `asins` — the required parameter, 10-character Amazon Standard Identification Numbers taken from the product URL after `/dp/`.
3. Set the controls that actually change the numbers: `fulfilmentChannel` (`FBA`, `FBM`, or `NONE`), `unitCost` + `inboundShippingCost` + `extraCostPerUnit` for landed cost, `exitCountry` to match the buyer geography, and `marketplaceDomain` if you're scraping a non-US storefront (fee fields stay `null` there — the schedule is amazon.com/USD only).
4. Click **Start**. ASINs are fetched concurrently.
5. Read results from the default dataset view, export as JSON/CSV/Excel/XML, or pull the keyed-by-ASIN object Apify stores under `OUTPUT` in the run's default key-value store.

```json
{ "asins": ["B07GBZ4Q68", "B0CJ4V4TRP"], "unitCost": "6.50", "fulfilmentChannel": "FBA" }
```

#### How to run multiple ASINs in one job

`asins` is a plain array (the schema's `stringList` editor) — paste hundreds of ASINs, one per line, and they all queue in a single run. Duplicates are de-duplicated case-insensitively before fetching, and anything that isn't exactly 10 alphanumeric characters is skipped with a log warning rather than submitted. Fetches run concurrently at a fixed 5 in-flight requests in this build — that figure is a source-level constant, not an input parameter, so it holds regardless of list size; larger lists simply take proportionally longer to finish.

### ⬇️ Input

Only `asins` is required. Everything else has a default that reproduces a standard FBA seller on amazon.com.

| Parameter | Required | Type | Description | Example Value |
| --- | --- | --- | --- | --- |
| `asins` | Yes | array of string | One ASIN per line, 10 alphanumeric characters. `asinList`/`productAsins` are accepted as legacy aliases. | `["B07GBZ4Q68", "B075CYMYK6"]` |
| `marketplaceDomain` | No | string, default `"amazon.com"` | Storefront to read from. The fee schedule covers `amazon.com`/USD only. Legacy key `amazonDomain` takes priority if both are set. | `"amazon.com"` |
| `pageLanguage` | No | string, default `"en"`, enum: `""`, `en`, `en_US`, `en_GB`, `de`, `fr`, `es`, `it`, `nl`, `pl`, `pt`, `pt_BR`, `sv`, `tr`, `cs`, `da`, `ja`, `zh_CN`, `zh_TW`, `hi` | Page language, sent as `?language=…` and `Accept-Language`. Legacy key `language` takes priority. | `"en"` |
| `deliveryPostcode` | No | string, default `""` | Sets Amazon's delivery cookie before scraping, so the priced buy box matches that destination. Legacy key `zipCode` takes priority. | `"10001"` |
| `unitCost` | No | string, default `""` | What you pay your supplier per unit, before freight. Empty skips all profit maths; the fee side still runs. | `"6.50"` |
| `inboundShippingCost` | No | string, default `""` | Freight, duty and customs allocated to one unit. | `"0.90"` |
| `extraCostPerUnit` | No | string, default `""` | Anything else inside landed cost — prep, polybag, labelling, insert cards. | `"0.35"` |
| `fulfilmentChannel` | No | string, default `"FBA"`, enum: `FBA`, `FBM`, `NONE` | `FBA` adds an estimated fulfilment fee from the parsed size tier; `FBM` and `NONE` set it to 0. | `"FBA"` |
| `feeCategoryOverride` | No | string, default `""` | Force a referral-fee category instead of the breadcrumb-inferred one. An unrecognised value is ignored and the breadcrumb is used. | `"Consumer Electronics"` |
| `referralFeePercentOverride` | No | string, default `""` | Pin the referral percentage yourself. Values above 100 are coerced to 100 (and the coercion is logged). | `"15.5"` |
| `fulfilmentFeeOverride` | No | string, default `""` | Use your own per-unit fulfilment cost instead of the estimated FBA rate. | `"4.55"` |
| `includeFeeBreakdown` | No | boolean, default `true` | Adds the itemised `feeBreakdown[]` array. Turn off for a narrower dataset. | `true` |
| `trimRichContent` | No | boolean, default `false` | Blanks A+ content, brand story, comparison table and both image arrays. | `false` |
| `onlyProfitableAsins` | No | boolean, default `false` | Skip ASINs whose `estimatedProfitPerUnit` is ≤ 0. Only has an effect when `unitCost` is supplied — without it, nothing is filtered (a warning is logged). | `false` |
| `exitCountry` | No | string, default `"AUTO_SELECT_PROXY_COUNTRY"`, enum: `AUTO_SELECT_PROXY_COUNTRY`, `US`, `GB`, `DE`, `FR`, `ES`, `IT`, `CA`, `AU`, `JP`, `IN`, `BR`, `MX`, `NL`, `PL`, `TR`, `SE`, `AE` | Proxy exit country, so the buy-box price and delivery promise match the market you're costing for. Legacy key `proxyCountry` takes priority. | `"US"` |
| `proxyConfiguration` | No | object (proxy editor) | Full proxy override — Apify groups or your own URLs. Overrides `exitCountry`. Prefilled with the residential group. | `{"useApifyProxy": true, "apifyProxyGroups": ["RESIDENTIAL"]}` |

⚠️ The fee, profit and margin fields only populate for `amazon.com` in USD. On any other `marketplaceDomain`, product data still scrapes normally, but every money field comes back `null` with `feeEstimateBasis: "unsupported_marketplace:<domain> (schedule covers amazon.com only)"`.

#### Example JSON input

```json
{
  "asins": ["B07GBZ4Q68", "B0CJ4V4TRP", "B00FLYWNYQ"],
  "marketplaceDomain": "amazon.com",
  "pageLanguage": "en",
  "unitCost": "6.50",
  "inboundShippingCost": "0.90",
  "extraCostPerUnit": "0.35",
  "fulfilmentChannel": "FBA",
  "includeFeeBreakdown": true,
  "onlyProfitableAsins": false,
  "exitCountry": "US",
  "proxyConfiguration": { "useApifyProxy": true, "apifyProxyGroups": ["RESIDENTIAL"] }
}
```

**Common pitfall:** `asins` only accepts bare 10-character codes, not full URLs. Pasting `https://www.amazon.com/dp/B07GBZ4Q68` (or an ISBN-13, or a stray space) fails the `[A-Za-z0-9]{10}` check silently — the run logs "Skipping non-ASIN input" and moves on, so a copy-paste mistake produces a shorter dataset rather than a visible error. Strip the URL down to the code after `/dp/` before pasting.

### ⬆️ Output

Each ASIN produces one dataset item — typed, normalized JSON with a consistent schema across runs. Export as JSON, CSV, Excel, XML, or RSS from the Apify Console, or read it back through the API/SDK. The full keyed-by-ASIN result is also written to the run's default key-value store under the key `OUTPUT`, including entries `onlyProfitableAsins` filtered out of the dataset.

#### Scraped results

The default dataset **view** surfaces 29 columns for a quick read. The dataset row itself carries more — every key below is present on a successful record (many can be `null` when the page or fee engine has nothing to report).

**Default view (29 fields):** `asin`, `title`, `sellPrice`, `sellPriceCurrency`, `feeCategory`, `feeCategorySource`, `referralFeePercent`, `estimatedReferralFee`, `estimatedClosingFee`, `sizeTier`, `billableWeightPounds`, `estimatedFulfilmentFee`, `estimatedAmazonFeesTotal`, `estimatedNetProceeds`, `landedUnitCost`, `estimatedProfitPerUnit`, `estimatedProfitMarginPercent`, `estimatedRoiPercent`, `estimatedBreakEvenSellPrice`, `salesVolumeAvailable`, `salesVolumeBadgeText`, `estimatedMonthlyUnitsLow`, `estimatedMonthlyProfitLow`, `feeEstimateAvailable`, `feeEstimateBasis`, `feeScheduleVersion`, `stars`, `reviewsCount`, `url`.

**Additional identity/link fields not in the view:** `originalAsin` (string), `unNormalizedProductUrl` (string), `input` (string, the request URL), `position` (integer, fetch order), `isPinnedOffer` (boolean, `true` for the first item), `visitStoreLink` (string|null), `reviewsLink` (string), `shipsFrom` (string|null).

**Pricing & availability:** `price` (object `{value, currency}`|null), `listPrice` (object|null), `priceRange` (string|null), `inStock` (boolean|null), `inStockText` (string|null), `shippingPrice` (object|null), `condition` (string|null), `delivery` (string|null), `fastestDelivery` (string|null), `returnPolicy` (string|null), `support` (string|null).

**Brand & reputation:** `brand` (string|null), `author` (string|null), `starsBreakdown` (object, e.g. `{"5star": 0.81}`), `answeredQuestions` (integer|null), `isAmazonChoice` (boolean), `amazonChoiceText` (string|null), `bestsellerRanks` (array of `{rank, category, url}`), `aiReviewsSummary` (object|null).

**Rich content & media:** `description` (string|null), `bookDescription` (string|null), `features` (array of string), `breadCrumbs` (string|null), `videosCount` (integer), `thumbnailImage` (string|null), `galleryThumbnails` (array of string), `highResolutionImages` (array of string), `importantInformation` (string|null), `sustainabilityFeatures` (object|null), `aPlusContent` (object|null), `brandStory` (object|null), `productComparison` (object|null).

**Variants & attributes:** `variantAsins` (array of string), `variantDetails` (array of object), `variantAttributes` (array of `{key, value}`), `attributes` (array of `{key, value}`), `productOverview` (array of `{key, value}`), `hasReviews` (boolean), `seller` (object|null), `monthlyPurchaseVolume` (string|null, raw badge text), `locationText` (string|null), `loadedCountryCode` (string|null).

**Fee schedule & assumptions:** `feeScheduleCurrency` (string, `"USD"`), `feeScheduleMarketplace` (string, `"amazon.com"`), `feeAssumptions` (array of string, the plain-language rules the estimate was built under).

**Weight/dimension parsing:** `itemWeightPounds` (number|null), `itemWeightGrams` (number|null), `itemWeightSource` (string|null, the raw page value), `itemDimensionsInches` (array of number|null), `itemDimensionsSource` (string|null), `dimensionalWeightPounds` (number|null).

**Fee/profit internals:** `fulfilmentChannel` (string, echo of the resolved input), `profitEstimateAvailable` (boolean), `feeBreakdown` (array, omitted entirely when `includeFeeBreakdown` is `false`).

**Sales-volume internals:** `salesVolumeSource` (string|null, `"amazon_social_proof_badge"`), `estimatedMonthlyUnitsHigh` (integer|null — stays `null` for Amazon's open-ended "10K+" badges; only populated when the badge itself is bounded).

```json
[
  {
    "asin": "B07GBZ4Q68",
    "title": "Logitech G502 HERO High Performance Wired Gaming Mouse",
    "url": "https://www.amazon.com/gp/product/B07GBZ4Q68?smid=",
    "originalAsin": "B07GBZ4Q68",
    "price": { "value": 42.99, "currency": "$" },
    "listPrice": null,
    "inStock": true,
    "inStockText": "In Stock",
    "brand": "Logitech G",
    "stars": 4.6,
    "starsBreakdown": { "5star": 0.72, "4star": 0.15, "3star": 0.06, "2star": 0.03, "1star": 0.04 },
    "reviewsCount": 55283,
    "breadCrumbs": "Video Games > PC > Accessories > Gaming Mice",
    "attributes": [
      { "key": "Item Weight", "value": "5.11 ounces" },
      { "key": "Item Dimensions LxWxH", "value": "5.12 x 2.65 x 1.61 inches" }
    ],
    "features": ["HERO 25K sensor, up to 25,600 DPI", "11 programmable buttons"],
    "galleryThumbnails": ["https://m.media-amazon.com/images/I/61mpMH5TzkL._SS40_.jpg"],
    "bestsellerRanks": [{ "rank": 42, "category": "PC Gaming Mice", "url": "https://www.amazon.com/gp/bestsellers/..." }],
    "seller": { "name": "Amazon.com", "id": null, "url": "https://www.amazon.com/", "reviewsCount": null, "averageRating": null },
    "feeScheduleVersion": "amazon-us-2026-07",
    "feeScheduleCurrency": "USD",
    "feeScheduleMarketplace": "amazon.com",
    "feeAssumptions": [
      "US marketplace (amazon.com) standard selling plan; no per-item $0.99 fee.",
      "Referral percentage derived from the product's own breadcrumb trail, not from a Seller Central category assignment.",
      "Minimum referral fee $0.30. Media closing fee $1.80 where the category is books/music/video/video-games.",
      "FBA fulfilment fee uses the non-apparel, non-dangerous-goods rate card; apparel and hazmat rates are higher.",
      "Billable weight = greater of unit weight and dimensional weight (L x W x H / 139) for anything above 1 lb.",
      "Storage, long-term storage, inbound placement, returns processing, advertising and refund administration fees are NOT included."
    ],
    "sellPrice": 42.99,
    "sellPriceCurrency": "$",
    "itemWeightPounds": 0.3194,
    "itemWeightGrams": 145.0,
    "billableWeightPounds": 0.3194,
    "sizeTier": "Small Standard",
    "fulfilmentChannel": "FBA",
    "feeCategory": "Video Games",
    "feeCategorySource": "breadcrumb",
    "referralFeePercent": 15.0,
    "estimatedReferralFee": 6.45,
    "estimatedClosingFee": 1.80,
    "estimatedFulfilmentFee": 3.15,
    "estimatedAmazonFeesTotal": 11.40,
    "estimatedNetProceeds": 31.59,
    "landedUnitCost": 6.85,
    "estimatedProfitPerUnit": 24.74,
    "estimatedProfitMarginPercent": 57.55,
    "estimatedRoiPercent": 361.17,
    "estimatedBreakEvenSellPrice": 12.76,
    "feeEstimateAvailable": true,
    "feeEstimateBasis": "referral=breadcrumb; fulfilment=fba_rate_card; schedule=amazon-us-2026-07",
    "profitEstimateAvailable": true,
    "feeBreakdown": [
      { "fee": "Referral fee", "amount": 6.45, "basis": "15.0% of 42.99 (Video Games), $0.30 minimum" },
      { "fee": "Closing fee", "amount": 1.80, "basis": "media category flat fee" },
      { "fee": "FBA fulfilment fee", "amount": 3.15, "basis": "Small Standard, billable weight 0.3194 lb" }
    ],
    "salesVolumeAvailable": true,
    "salesVolumeSource": "amazon_social_proof_badge",
    "salesVolumeBadgeText": "3K+ bought in past month",
    "estimatedMonthlyUnitsLow": 3000,
    "estimatedMonthlyUnitsHigh": null,
    "estimatedMonthlyProfitLow": 74220.0
  }
]
```

Abbreviated view of a 3-ASIN batch, showing the fields most sourcing decisions read first — every item still carries the full field set documented above:

```json
[
  { "asin": "B07GBZ4Q68", "title": "Logitech G502 HERO...", "sellPrice": 42.99, "feeCategory": "Video Games", "estimatedNetProceeds": 31.59, "estimatedProfitPerUnit": 24.74, "feeEstimateBasis": "referral=breadcrumb; fulfilment=fba_rate_card; schedule=amazon-us-2026-07" },
  { "asin": "B075CYMYK6", "title": "Anker PowerCore 10000...", "sellPrice": 25.99, "feeCategory": "Consumer Electronics", "estimatedNetProceeds": 18.71, "estimatedProfitPerUnit": null, "feeEstimateBasis": "referral=breadcrumb; fulfilment=fba_rate_card; schedule=amazon-us-2026-07" },
  { "asin": "1250301696", "title": "A hardcover title...", "sellPrice": 18.00, "feeCategory": "Books", "estimatedNetProceeds": null, "estimatedProfitPerUnit": null, "feeEstimateBasis": "partial:referral_only — the page publishes no Item Weight, so the FBA size tier and fulfilment fee are null. Supply fulfilmentFeeOverride or set fulfilmentChannel=FBM." }
]
```

A failed fetch or a parse exception pushes a two-field diagnostic row instead of a full record — `{"asin": "B0XXXXXXXX", "error": "fetch_failed"}` or `{"asin": "B0XXXXXXXX", "error": "parse_error: <message>"}`. These are pushed for visibility but are **not charged**: only rows pushed with the `row_result` event (a fully parsed ASIN, whether or not the fee side resolved) are billed. Filter diagnostic rows out of an export by keeping items where the `error` field is absent.

### How can I use the data extracted with Amazon ASIN Scraper?

- 🧮 **Private-label and wholesale sourcing teams:** decide whether an ASIN is worth a purchase order before capital moves, reading `estimatedProfitPerUnit`, `estimatedRoiPercent` and `estimatedBreakEvenSellPrice` straight off the row.
- 🤖 **AI engineers and LLM developers:** an agent submits an ASIN list, receives JSON with the fee math already computed, and passes it straight into a sourcing-decision agent or a spreadsheet-generation tool without re-implementing Amazon's fee schedule.
- 📊 **Market researchers:** aggregate `feeCategory` and `referralFeePercent` across a catalogue to see where Amazon's cut is highest, or compare `salesVolumeBadgeText` and `bestsellerRanks` across a category to size demand.
- 🗂️ **Catalogue and product-ops teams:** bulk-audit an existing SKU list for listings whose `estimatedProfitPerUnit` has drifted negative since prices moved, pairing the run with `onlyProfitableAsins` to surface only the ones that still work.

### How do you monitor fee and profit estimates over time?

Amazon changes buy-box prices and its own fee schedules independently of anything you control, so a single run is a snapshot, not a forecast. The monitoring discipline is: re-run the same `asins` list on a schedule and diff the money fields between runs, because the referral percentage and the FBA rate card underneath them can both move without warning.

Fields worth diffing run over run: `sellPrice` (buy-box drift), `estimatedProfitPerUnit` and `estimatedRoiPercent` (the numbers that actually decide restock), `feeEstimateBasis` (flags when a size tier or category resolution changed), and `feeScheduleVersion` — when this string changes (it is stamped `amazon-us-2026-07` in the current build), every prior estimate in your history was computed under a schedule this build no longer uses, and the whole catalogue is worth re-checking rather than trusting the delta at face value.

A concrete loop: put the SKU list on a recurring Apify Schedule, keep each run's dataset, and compare `estimatedProfitPerUnit` against the previous run for every ASIN. Alert — via an Apify webhook into Slack, Make or Zapier on run completion — when a SKU crosses from positive to negative profit, or when `feeScheduleVersion` changes. Scheduling and webhook delivery are handled by the Apify platform, not by code inside this Actor; there is no built-in polling loop to configure here.

### Integrate Amazon ASIN Scraper and automate your workflow

Amazon ASIN Scraper With Profit & Fee Estimates works with any language or tool that can send an HTTP request, through the Apify API.

#### REST API with Python

```python
import requests

ACTOR = "<YOUR_USERNAME>/amazon-asin-scraper-profit-fee-estimates"
TOKEN = "<YOUR_APIFY_TOKEN>"

resp = requests.post(
    f"https://api.apify.com/v2/acts/%7BACTOR.replace('/', '~')}/run-sync-get-dataset-items",
    params={"token": TOKEN},
    json={"asins": ["B07GBZ4Q68", "B0CJ4V4TRP"], "unitCost": "6.50", "fulfilmentChannel": "FBA"},
    timeout=180,
)
resp.raise_for_status()
for row in resp.json():
    print(row["asin"], row.get("estimatedProfitPerUnit"), row.get("feeEstimateBasis"))
```

#### MCP for query-grounded AI agents

Reachable through Apify's hosted MCP server: point an MCP-compatible client (Claude Desktop, Cursor, or any client that speaks the Model Context Protocol) at `https://mcp.apify.com?tools=<YOUR_USERNAME>/amazon-asin-scraper-profit-fee-estimates`. The agent discovers the input schema, calls the Actor with a user-supplied ASIN list, and gets the fee/profit-annotated JSON back as tool output — grounding a sourcing answer in a live-scraped number instead of a guess.

#### Scheduled monitoring and delivery

Configure a recurring run from the Actor's **Schedule** tab in the Apify Console (cron-style interval), and attach a **webhook** on run completion to push results into Slack, Make, Zapier, or any HTTP endpoint. There is no polling endpoint inside the Actor itself — scheduling and delivery are Apify platform features, not a feature this codebase implements.

### Is it legal to scrape Amazon product and fee data?

Scraping publicly accessible Amazon product pages for information any visitor can see is generally lawful in the United States. In *hiQ Labs v. LinkedIn Corp.* (9th Cir. 2019, on remand 2022), the Ninth Circuit held that accessing data that is not behind a login wall does not violate the Computer Fraud and Abuse Act — the leading precedent for this general question, though it did not involve Amazon specifically. Amazon ASIN Scraper With Profit & Fee Estimates returns catalogue, pricing and fee data — not personal data about identifiable individuals — so GDPR/CCPA's personal-data rules do not attach to its output; the relevant framework instead is Amazon's own Conditions of Use, which restrict automated access as a matter of contract, and database-rights doctrine, which varies by jurisdiction. Scraping a handful of ASINs for a one-off sourcing decision carries a different risk profile than scraping at scale to build a resale or AI-training dataset. Consult your legal team for commercial use cases involving bulk data storage.

### ❓ Frequently asked questions

#### Which Amazon storefronts and languages does it support?

It scrapes any storefront domain you enter in `marketplaceDomain` (default `amazon.com`), in any of the 20 `pageLanguage` values — English, English (US/UK), German, French, Spanish, Italian, Dutch, Polish, Portuguese (and Brazil), Swedish, Turkish, Czech, Danish, Japanese, Chinese Simplified/Traditional, Hindi, or marketplace default. Product data returns on every storefront. The bundled fee schedule, however, only covers `amazon.com` in USD — on any other domain, every fee and profit field comes back `null` and `feeEstimateBasis` reads `unsupported_marketplace:<domain>`.

#### Can I change how much data comes back per ASIN?

Yes, without touching the numbers themselves. `trimRichContent` (default `false`) blanks A+ content, brand story, the comparison table and both image arrays to shrink heavy records. `includeFeeBreakdown` (default `true`) adds or removes the itemised `feeBreakdown[]` array.

#### How does Amazon ASIN Scraper handle Amazon's anti-bot measures?

It rotates across five desktop user-agent strings, routes through Apify residential proxy with a sticky session per ASIN on the first attempt and a fresh IP on retries, and detects CAPTCHA/robot-check block pages to trigger a retry with exponential backoff. When `exitCountry` targets `US` specifically, it also verifies the response is actually a US-localized page (checking delivery-country and currency markers) and retries on a fresh IP if not. It ships no inline CAPTCHA-solving service; the legacy `useCaptchaSolver` input is accepted for backward compatibility but has no effect beyond a log message.

#### Does Amazon ASIN Scraper extract profit and fee estimates?

Yes — every successful row carries `feeBreakdown[]`, `estimatedReferralFee`, `estimatedFulfilmentFee`, `estimatedNetProceeds`, and, with a unit cost, `estimatedProfitPerUnit`, `estimatedProfitMarginPercent`, `estimatedRoiPercent` and `estimatedBreakEvenSellPrice`. These stay `null` when the marketplace or currency isn't supported, when no price is on the page (unqualified buy box or out of stock), or when the referral category can't be resolved — `feeEstimateBasis` always says which.

#### How many ASINs does Amazon ASIN Scraper return per run?

One row per valid, de-duplicated ASIN in `asins` — the schema sets no maximum list length. Fetches run at a fixed concurrency of 5 in-flight requests, a source-level constant rather than an input parameter, so larger lists take proportionally longer; no throughput figure is published because per-ASIN response time depends on Amazon's own behaviour on the request.

#### How do I monitor fee and profit changes for the same ASINs over time?

Put the same `asins` list on a recurring Apify Schedule, keep each run's dataset, and diff `sellPrice`, `estimatedProfitPerUnit` and `feeScheduleVersion` against the previous run. Alert through an Apify webhook when profit crosses zero or the fee schedule version changes.

#### Does Amazon ASIN Scraper work with Claude, ChatGPT, and AI agent frameworks?

Yes, two ways: through Apify's hosted MCP server at `https://mcp.apify.com?tools=<YOUR_USERNAME>/amazon-asin-scraper-profit-fee-estimates` for MCP-compatible clients, or as a plain HTTP endpoint callable from any agent framework via the Apify API — an agent can retrieve landed-cost math before answering a sourcing question either way.

#### How does Amazon ASIN Scraper compare to other Amazon scrapers?

| Axis | This Actor | junglee/amazon-asins-scraper | jaybird/amazon-product-data-scraper | harvestlab/amazon-scraper |
| --- | --- | --- | --- | --- |
| Referral/FBA fee estimate | ✅ | ❌ (not in documented output) | ❌ (not in documented output) | ❌ (not in documented output) |
| Profit / ROI from unit cost | ✅ | ❌ | ❌ | ❌ |
| ASIN-list batch input | ✅ | ✅ | ✅ (product URLs) | ✅ |
| BSR time-series tracking across runs | Not offered | Not documented | Not documented | ✅ (its listing's own claim) |

Observed on each Actor's own Apify Store listing, 2026-07-25 — pricing, speed and success-rate claims from other listings are theirs, not independently measured here.

#### Can I use Amazon ASIN Scraper without managing proxies or Amazon credentials?

Yes. Apify Proxy is handled internally — `proxyConfiguration` comes prefilled with the residential group, and `exitCountry` is a simpler shortcut for the same thing. No Amazon Seller Central or Associates account is needed, since the Actor reads public product pages; you only need an Apify account, and an API token if you're calling it programmatically.

#### What happens if I paste a product URL instead of a bare ASIN?

It's dropped. Only exact 10-character alphanumeric tokens pass the input check; a full `/dp/` URL, an ISBN-13, or a typo is logged as "Skipping non-ASIN input" and never fetched — so it never appears in the dataset and is never charged.

### 💬 Your feedback

Found a bug, or a field that isn't populating the way this document says it should? Let us know through Scrapier's issue tracker on the Actor's Apify Store page, or leave a note in the Actor's Console **Issues** tab. Reports against real ASINs — including which marketplace and fulfilment channel you ran — help us fix parsing gaps fastest.

# Actor input Schema

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

One ASIN per line — 10 alphanumeric characters, e.g. `B07GBZ4Q68`. Take it from the product URL after `/dp/`. ASINs are fetched concurrently.

## `marketplaceDomain` (type: `string`):

Which Amazon storefront to read the listing from. The bundled fee schedule is **amazon.com / USD only** — any other storefront still returns full product data, but the fee and profit fields will be `null` and `feeEstimateBasis` will say `unsupported_marketplace`.

The base input key `amazonDomain` is still accepted and takes priority.

## `pageLanguage` (type: `string`):

Language code sent as `?language=…` and in `Accept-Language`. Attribute keys such as `Item Weight` are matched in English first, so leaving this on English gives the best fee coverage.

The base input key `language` is still accepted and takes priority.

## `deliveryPostcode` (type: `string`):

Optional destination postcode (e.g. `10001`). Sets Amazon's delivery cookie before scraping so the buy-box price you are costing out is the one for that location.

The base input key `zipCode` is still accepted and takes priority.

## `unitCost` (type: `string`):

What you pay your supplier for one unit, before freight, in the storefront's currency. Decimals welcome — example: `6.50`. Leave empty to skip all profit maths; the fee side still runs.

## `inboundShippingCost` (type: `string`):

Freight, duty and customs allocated to a single unit — the cost of getting it into the fulfilment centre. Example: `0.90`.

## `extraCostPerUnit` (type: `string`):

Anything else you want inside landed cost: prep, polybag, labelling, insert cards. Added straight into `landedUnitCost`. Example: `0.35`.

## `fulfilmentChannel` (type: `string`):

**FBA** adds an estimated Amazon fulfilment fee from the parsed size tier. **FBM (seller-fulfilled)** sets the Amazon fulfilment fee to 0 — your own shipping cost belongs in *Other cost per unit*. **Referral fee only** also skips it, for a quick gross look.

## `feeCategoryOverride` (type: `string`):

Force a referral-fee category instead of the one inferred from the breadcrumb trail. Useful when Amazon's browse node and your Seller Central category disagree. Examples: `Consumer Electronics`, `Home & Kitchen`, `Toys & Games`, `Clothing & Accessories`. An unrecognised value is ignored and the breadcrumb is used.

## `referralFeePercentOverride` (type: `string`):

Pin the referral percentage yourself, e.g. `8` or `15.5`. Overrides both the breadcrumb category and the category override above; `feeCategorySource` then reads `user_percent_override`. Values above 100 are coerced to 100 and the coercion is logged.

## `fulfilmentFeeOverride` (type: `string`):

Use your own per-unit fulfilment cost instead of the estimated FBA rate — handy when you already have the real figure from a Seller Central fee preview. Example: `4.55`.

## `includeFeeBreakdown` (type: `boolean`):

Adds `feeBreakdown[]` — one entry per fee with the amount and the sentence explaining how it was reached (percentage used, size tier, billable weight). Turn off for a narrower dataset.

## `trimRichContent` (type: `boolean`):

A+ modules, brand story, comparison tables and image galleries dominate the size of an Amazon record and a costing sheet never reads them. Turn this on to blank those fields and keep the dataset small.

## `onlyProfitableAsins` (type: `boolean`):

Skip any ASIN whose estimated profit per unit is zero or negative. Only has an effect when a unit cost was supplied — without one, profit is unknown and nothing is filtered out (a warning is logged).

## `exitCountry` (type: `string`):

Route requests through this country so the buy-box price and delivery promise match the market you are costing for.

The base input key `proxyCountry` is still accepted and takes priority.

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

Full proxy override — Apify groups or your own URLs. Overrides the exit country above. Most runs can leave this alone.

## Actor input object example

```json
{
  "asins": [
    "B00FLYWNYQ",
    "B075CYMYK6",
    "1250301696",
    "B07GBZ4Q68"
  ],
  "marketplaceDomain": "amazon.com",
  "pageLanguage": "en",
  "deliveryPostcode": "",
  "unitCost": "",
  "inboundShippingCost": "",
  "extraCostPerUnit": "",
  "fulfilmentChannel": "FBA",
  "feeCategoryOverride": "",
  "referralFeePercentOverride": "",
  "fulfilmentFeeOverride": "",
  "includeFeeBreakdown": true,
  "trimRichContent": false,
  "onlyProfitableAsins": false,
  "exitCountry": "AUTO_SELECT_PROXY_COUNTRY",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

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

All scraped items in the Actor's default dataset.

## `resultsByAsin` (type: `string`):

The same per-ASIN records as the dataset (plus fetch/parse-error placeholders), collected into one JSON object keyed by ASIN for direct lookup, stored under the key-value store key OUTPUT.

# 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 = {
    "asins": [
        "B00FLYWNYQ",
        "B075CYMYK6",
        "1250301696",
        "B07GBZ4Q68"
    ],
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapier/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 '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "asins": [
        "B00FLYWNYQ",
        "B075CYMYK6",
        "1250301696",
        "B07GBZ4Q68",
    ],
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("scrapier/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": [
    "B00FLYWNYQ",
    "B075CYMYK6",
    "1250301696",
    "B07GBZ4Q68"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call scrapier/amazon-asin-scraper --silent --output-dataset

```

## MCP server setup

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