# Amazon Offers Scraper (All Offers Display) (`crawlerbros/amazon-offers-scraper`) Actor

Scrape every seller offer for one or more Amazon ASINs from the All-Offers-Display panel: condition, price, seller name/rating, ships-from, delivery estimate, and buy-box winner flag.

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

## Pricing

from $3.00 / 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.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

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

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

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

# README

## Amazon Offers Scraper

Scrape **every seller offer** for one or more Amazon ASINs from the All-Offers-Display panel (the "Other Sellers on Amazon" / "See All Buying Options" list). Get condition, price, seller name and rating, ships-from, delivery estimate, and which offer currently wins the buy box -- for as many products as you need, across multiple marketplaces and destinations.

### What this actor does

- **Input by ASIN or by product URL** -- mix and match freely
- **Every offer, not just the buy box** -- new, used, and third-party seller offers on the same listing
- **Condition filter** -- restrict to New, Used, Collectible, or Renewed only, or All (each matched exactly -- a "Used only" filter never silently includes Collectible/Renewed offers)
- **Fulfillment type filter** -- restrict to Fulfilled by Amazon (FBA), Fulfilled by Merchant (FBM), or sold-and-shipped-by-Amazon
- **Destination-aware** -- set a delivery country / postal code, since offer sets and delivery estimates change by destination
- **Buy-box detection** -- the current buy-box winner is explicitly flagged, never guessed from list position
- **Empty fields are omitted**

### Output per offer

- `productAsin` -- the product ASIN this offer belongs to
- `offerPosition` -- 1-based order the offer appeared in on the page (buy box is always position 1)
- `condition`, `subCondition` -- e.g. `"Used"` / `"Like New"`
- `conditionNote` -- extra condition detail text, when Amazon shows one
- `price` -- `{ value, currency, display }`
- `unitPrice` -- `{ value, currency, display }`, when Amazon shows a per-unit price
- `listPrice` -- `{ value, currency, display }`, the strikethrough "List Price" Amazon shows for this specific offer, only present when Amazon's own DOM carries it (typically the pinned/buy-box offer on a discounted item) -- never derived/computed
- `savingsPercent` -- integer percent-off (e.g. `30` for "-30%"), only present alongside a real `listPrice`
- `deliveryEstimate` -- the delivery promise text shown for this offer
- `isFreeDelivery` -- `true`/`false`, only when the delivery text gives explicit evidence either way (e.g. "FREE delivery..." vs. a stated shipping charge); omitted when ambiguous
- `shippingPrice` -- `{ value, currency, display }`, only present when Amazon shows an explicit paid-shipping amount
- `shipsFrom` -- who ships the item
- `soldBy` -- `{ name, sellerId, profileUrl }`
- `sellerRating`, `sellerRatingsCount` -- third-party seller reputation, when Amazon shows a rating line for that seller
- `sellerPositivePercent12m` **or** `sellerPositivePercentLifetime` -- the positive-feedback percentage, exactly one of the two depending on which real period Amazon measured it over (sellers with a full 12-month history get "% positive over last 12 months"; newer sellers get "% positive over lifetime" instead) -- never conflated into one field, since they cover different windows
- `fulfillmentType` -- `"FBA"` / `"FBM"` / `"AMAZON"`, derived from Amazon's own "Ships from"/"Sold by" labels; omitted when the combination is ambiguous (e.g. a named third-party fulfillment center)
- `isBuyBoxWinner` -- `true` only for the pinned/buy-box offer, never inferred from position
- `maxQuantity` -- highest quantity selectable for this offer, when a quantity control is shown
- `couponText` -- any coupon/promotion text shown on the offer row
- `marketplace` -- `{ countryCode, domain, marketplaceId, currency, language }`
- `requestContext` -- `{ productAsin, sourceUrl, canonicalUrl, deliveryCountry, postalCode }`
- `page` -- `{ classification: "SUCCESS", totalOfferCount, moreOffersAvailable }`. `totalOfferCount` is Amazon's own reported total offer count for the ASIN (when available). The actor automatically expands Amazon's own "See N more options" panel toggle before extracting, which fully recovers every offer on ASINs where Amazon had already rendered them all client-side (just hidden behind that toggle); on ASINs with a substantially larger real offer count, Amazon's client-side reveal itself only carries a further batch (not literally every remaining offer), so `moreOffersAvailable: true` can still appear even when `maxOffersPerProduct` was set higher than `totalOfferCount` -- this remaining gap would require a genuine server-side page-2 fetch the actor does not perform. Check this field rather than assuming `maxOffersPerProduct` was always fully honored.
- `recordType: "offer"`, `scrapedAt`

### Output: status records

When an ASIN's page can't be classified as a normal offers page (not found, invalid ASIN, sign-in wall, CAPTCHA, rate-limited, or a genuinely empty offers panel), the actor emits one explicit status record instead of silently returning zero rows:

- `productAsin`, `marketplace`, `requestContext`
- `page.classification` -- one of `NOT_FOUND`, `INVALID_ASIN`, `AUTH_REQUIRED`, `CAPTCHA`, `ROBOT_CHECK`, `DOG_PAGE_503`, `RATE_LIMITED`, `NO_OFFERS`, etc.
- `recordType: "status"`, `scrapedAt`

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `asins` | array | – | ASINs to fetch, e.g. `B0DCH8VDXF` |
| `productUrls` | array | – | Full `/dp/{ASIN}` product URLs (marketplace domain auto-detected) |
| `conditions` | string | `ALL` | `ALL` / `NEW` / `USED` / `COLLECTIBLE` / `RENEWED` |
| `fulfillmentTypes` | array | `[]` (no filter) | Any of `FBA` / `FBM` / `AMAZON`; leave empty for no filter |
| `maxOffersPerProduct` | int | `20` | Hard cap on offers emitted per ASIN (1-50) |
| `deliveryCountry` | string | – | 2-letter destination country; also picks the default marketplace domain |
| `postalCode` | string | – | Destination ZIP/postal code |
| `proxyConfiguration` | object | AUTO | Apify proxy config |

#### Example: single ASIN, all conditions

```json
{
  "asins": ["B0DCH8VDXF"],
  "conditions": "ALL",
  "maxOffersPerProduct": 10
}
```

#### Example: multiple ASINs, new only, destination-aware

```json
{
  "asins": ["B0DXXYS4BJ", "B0DCH8VDXF"],
  "conditions": "NEW",
  "deliveryCountry": "US",
  "postalCode": "10001",
  "maxOffersPerProduct": 20
}
```

#### Example: by product URL, UK marketplace

```json
{
  "productUrls": ["https://www.amazon.co.uk/dp/B0DCH8VDXF"],
  "conditions": "ALL"
}
```

### Use cases

- **Price monitoring** -- track how many sellers compete on a listing and at what price
- **Buy-box tracking** -- monitor which seller currently owns the buy box over time
- **Repricing intelligence** -- see competitor pricing, condition, and shipping terms side by side
- **Seller research** -- discover which third-party sellers list a given ASIN and their ratings
- **Arbitrage / reselling** -- compare New vs Used pricing spreads on the same product

### FAQ

**What is the All-Offers-Display panel?** It's the list Amazon shows when you click "See All Buying Options" or "X used & new" on a product page -- every seller currently offering that ASIN, not just the buy-box winner.

**Why do offer sets change by destination?** Amazon only shows offers a seller can actually ship to your delivery address. Setting `deliveryCountry`/`postalCode` makes the results match what a real shopper in that location would see.

**Why is `sellerRating` sometimes missing?** Amazon only shows an independent seller-rating line for third-party sellers. Offers fulfilled and sold directly by Amazon (or "Amazon Resale") don't carry a separate rating line, so the field is correctly omitted rather than fabricated.

**How is `fulfillmentType` determined?** From Amazon's own "Ships from" and "Sold by" labels on each offer row -- `FBA` (Fulfilled by Amazon) when Amazon ships it but a third party sold it, `AMAZON` when Amazon both sold and shipped it, `FBM` (Fulfilled by Merchant) when the ships-from and sold-by names match (the seller ships it themselves). If the combination is ambiguous (e.g. a named third-party fulfillment center), the field is omitted rather than guessed.

**Why is `isFreeDelivery`/`shippingPrice` sometimes missing?** Only set when Amazon's delivery text gives explicit evidence either way ("FREE delivery..." or a stated shipping charge). An ambiguous delivery estimate with no free/paid wording leaves both fields omitted rather than assuming free.

**What's the difference between `USED` and `COLLECTIBLE`/`RENEWED` in the condition filter?** Amazon's own AOD panel surfaces up to 4 distinct top-level condition buckets on the same listing -- `New`, `Used`, `Collectible` (rare/specialty copies, common on books/media), and `Renewed` (Amazon's official refurbishment program). Each `conditions` filter value matches its own bucket exactly -- selecting `USED` will never silently include a `Collectible` or `Renewed` offer. Use `ALL` if you want every condition together.

**Does the `conditions` filter work on non-English marketplaces?** The output `condition` field always shows Amazon's own real, localized text (e.g. Polish "Nowe", Dutch "Nieuw", Italian "Nuovo" for New-condition offers) -- it's never translated or altered. The `conditions` input filter itself recognizes the English bucket names plus a small, evidence-based set of live-verified translations: New-condition words for Polish/Dutch/Italian/German/Japanese/Spanish/French, plus Used/Collectible words for Japanese ("中古商品"/"コレクター商品"), German ("Gebraucht"), Italian ("Usato"/"Da collezione"), Spanish ("De 2ª mano"), and French ("D'occasion"). Filtering by `USED`/`COLLECTIBLE`/`RENEWED` on a marketplace whose offers render those buckets in a language this actor hasn't yet verified a translation for may under-match (real offers in that bucket excluded rather than risking a wrong match) -- use `ALL` and inspect the real `condition` text yourself if you need every bucket on an untranslated marketplace.

**Why did I get a status record instead of offers?** The ASIN's page didn't classify as a normal offers listing -- it may be invalid, geo-restricted, temporarily rate-limited, or genuinely have no additional offers beyond the buy box. The `page.classification` field tells you exactly why.

**I set `maxOffersPerProduct` to 50 but got fewer offers back -- is that a bug?** No -- `maxOffersPerProduct` is a cap, not a guarantee. The actor automatically expands Amazon's own "See N more options" panel toggle before extracting, which recovers every offer on ASINs where Amazon had already rendered them all client-side behind that toggle. On ASINs with a much larger real offer count (popular used-book listings with dozens of sellers are the most common case), Amazon's client-side reveal itself only carries a further batch rather than literally every remaining offer -- reaching the rest would require a genuine server-side page-2 fetch this actor does not perform. Every returned offer record's `page.totalOfferCount`/`page.moreOffersAvailable` fields tell you the real total and whether more exist beyond what was captured, so you can always tell the difference from a genuinely-exhausted result.

**Is this affiliated with Amazon?** No. This is an independent, third-party actor that reads Amazon's publicly viewable product pages.

**How fresh is the data?** Every run fetches the live page at request time -- offers, prices, and the buy-box winner can change within minutes on Amazon, so treat each run as a point-in-time snapshot.

**Why does `sourceUrl` / `soldBy.profileUrl` return a 503 if I curl it directly?** Amazon's edge (CloudFront) aggressively blocks plain, cookie-less, non-browser requests -- a bare `curl` from a clean shell with no session/cookies/JS will get a 503 "Service Unavailable" even though the same URL loads fine for a real shopper's browser. This actor itself reaches these pages successfully using a full browser session (Playwright) with a homepage-priming navigation and proxy rotation; the URLs in the output are the correct, canonical Amazon URLs and will render normally when opened in a browser or fetched with an equivalent session.

### More Amazon Actors

Part of a full Amazon scraper suite -- also check out:

- [Amazon Category Scraper](https://apify.com/crawlerbros/amazon-scraper)
- [Amazon Product Scraper](https://apify.com/crawlerbros/amazon-product-scraper)
- [Amazon Best Sellers & Rankings Scraper](https://apify.com/crawlerbros/amazon-bestseller-scraper)
- [Amazon Reviews Scraper](https://apify.com/crawlerbros/amazon-reviews-scraper)
- [Amazon Reviews Scraper Pro](https://apify.com/crawlerbros/amazon-reviews-scraper-pro)
- [Amazon Seller & Shop Scraper](https://apify.com/crawlerbros/amazon-seller-shop-scraper)
- [Amazon Deals Scraper](https://apify.com/crawlerbros/amazon-deals-scraper)
- [Amazon Brand Store Scraper](https://apify.com/crawlerbros/amazon-brand-store-scraper)
- [Amazon Creator Shop Scraper](https://apify.com/crawlerbros/amazon-creator-shop-scraper)
- [Amazon Wishlist & Registry Scraper](https://apify.com/crawlerbros/amazon-list-registry-scraper)
- [Amazon Keyword Suggestions Scraper](https://apify.com/crawlerbros/amazon-keyword-suggestions-scraper)

# Actor input Schema

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

Amazon ASINs to fetch offers for, e.g. `B0DCH8VDXF`.

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

Full Amazon product URLs (any `/dp/{ASIN}` link). The marketplace domain and ASIN are both extracted from each URL.

## `conditions` (type: `string`):

Only emit offers of this condition. Amazon's offer panel surfaces 4 distinct condition buckets -- New, Used, Collectible, and Renewed (Amazon Renewed program) -- each matched exactly ("Used only" never silently includes Collectible/Renewed offers).

## `fulfillmentTypes` (type: `array`):

Only emit offers with this fulfillment type. Derived from Amazon's own explicit "Ships from"/"Sold by" labels: FBA (Fulfilled by Amazon -- ships from Amazon, sold by a third-party seller), AMAZON (sold and shipped by Amazon itself), FBM (Fulfilled by Merchant -- the seller ships it themselves). Leave empty for no filter. Offers where the fulfillment type couldn't be confidently derived are excluded whenever a filter is set (but still included when this filter is empty).

## `maxOffersPerProduct` (type: `integer`):

Hard cap on the number of offer records emitted per ASIN (the buy-box/pinned offer counts as one).

## `deliveryCountry` (type: `string`):

2-letter destination country. Offer sets are destination-dependent; also selects the default marketplace domain for bare ASINs (ignored when `productUrls` supplies its own domain).

## `postalCode` (type: `string`):

Destination postal code to refine delivery estimates. Optional.

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

Uses the free AUTO (datacenter) proxy group by default. The actor escalates a single ASIN to a RESIDENTIAL session automatically only after repeated block detections on that ASIN.

## Actor input object example

```json
{
  "asins": [
    "B0DXXYS4BJ"
  ],
  "productUrls": [],
  "conditions": "ALL",
  "fulfillmentTypes": [],
  "maxOffersPerProduct": 5,
  "deliveryCountry": "US",
  "postalCode": "10001",
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `offers` (type: `string`):

Dataset containing all scraped Amazon offer and status records.

# 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": [
        "B0DXXYS4BJ"
    ],
    "productUrls": [],
    "conditions": "ALL",
    "fulfillmentTypes": [],
    "maxOffersPerProduct": 5,
    "deliveryCountry": "US",
    "postalCode": "10001",
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/amazon-offers-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": ["B0DXXYS4BJ"],
    "productUrls": [],
    "conditions": "ALL",
    "fulfillmentTypes": [],
    "maxOffersPerProduct": 5,
    "deliveryCountry": "US",
    "postalCode": "10001",
    "proxyConfiguration": { "useApifyProxy": True },
}

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

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

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

```

## CLI example

```bash
echo '{
  "asins": [
    "B0DXXYS4BJ"
  ],
  "productUrls": [],
  "conditions": "ALL",
  "fulfillmentTypes": [],
  "maxOffersPerProduct": 5,
  "deliveryCountry": "US",
  "postalCode": "10001",
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call crawlerbros/amazon-offers-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/jmNvptqojBKJBwj8r/builds/4P1Qu78kWbkK29hKV/openapi.json