Amazon Offers Scraper (All Offers Display): $5.00 per 1,000 Results

Every successful run returns up to 26 detailed offer fields per listing directly from the Amazon All-Offers-Display panel. These fields include the precise price, condition notes, seller ratings, shipping speeds, and an explicit buy-box winner flag. A thousand results cost $5.00 on the free-plan price, letting you run targeted inventory audits without high upfront costs. This is built for e-commerce developers who need to see every active merchant on a listing, showing condition, shipping terms, and buy-box status. It is not for anyone who needs to extract buyer reviews or product descriptions, which are not included in these records.

Try it: open Amazon Offers Scraper (All Offers Display) on Apify, sign in on the free plan and run the prefilled example.

Can you try Amazon Offers Scraper (All Offers Display) before paying?

Yes. Apify's free plan includes $5.00 of prepaid usage every month and asks for no credit card. At $0.005 per result, that covers up to 1,000 results of Amazon Offers Scraper (All Offers Display) a month, before run-start charges and platform usage.

The example request further down caps maxOffersPerProduct at 5 for each of its 1 asins, so a first run returns at most 5 results and costs at most $0.025 in result charges. That is enough to see the real shape of the data before deciding anything.

Amazon Offers Scraper (All Offers Display) was last updated on 2026-08-08. It is one of 1,724 Actors CrawlerBros publishes on Apify, which together have 734,650 lifetime public runs and an average rating of 4.63 out of 5 across 416 reviews.

What does it cost to run Amazon Offers Scraper (All Offers Display)?

Each result costs $0.005 on Apify's free plan, which is $5.00 per 1,000 results. Starting a run is charged separately at $0.005 per GB of Actor memory. Apify also bills the platform usage each run consumes, at the rates of your Apify plan, on top of these charges.

Your spend is driven directly by the maxOffersPerProduct configuration and the size of your input arrays. Setting a lower maxOffersPerProduct cap on large listings is the easiest way to control result charges before scaling up. To check whether this scraper meets your structural requirements without spending, run a single target ASIN with the cap set to 5 to keep the result cost under $0.025.

How do you run Amazon Offers Scraper (All Offers Display) from the API?

The schema marks 1 of its 8 controls as required: asins. Nothing in the payload below is illustrative. Those are the schema's prefilled defaults for Amazon Offers Scraper (All Offers Display), so the request works once your token is in place.

Call the synchronous endpoint to start a run and receive dataset items in one request:

curl -X POST "https://api.apify.com/v2/acts/crawlerbros~amazon-offers-scraper/run-sync-get-dataset-items?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"asins":["B0DXXYS4BJ"],"productUrls":[],"conditions":"ALL","fulfillmentTypes":[],"maxOffersPerProduct":5,"deliveryCountry":"US","postalCode":"10001","proxyConfiguration":{"useApifyProxy":true}}'

The same run from Python, using the official client:

from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")

run_input = {
  "asins": [
    "B0DXXYS4BJ"
  ],
  "productUrls": [],
  "conditions": "ALL",
  "fulfillmentTypes": [],
  "maxOffersPerProduct": 5,
  "deliveryCountry": "US",
  "postalCode": "10001",
  "proxyConfiguration": {
    "useApifyProxy": True
  }
}

run = client.actor("crawlerbros~amazon-offers-scraper").call(run_input=run_input)

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

And from Node.js:

import { ApifyClient } from 'apify-client'

const client = new ApifyClient({ token: '<YOUR_APIFY_TOKEN>' })

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

const run = await client.actor('crawlerbros~amazon-offers-scraper').call(input)
const { items } = await client.dataset(run.defaultDatasetId).listItems()
console.log(items)

Because the call is synchronous, your client waits for the whole run. Keep it for exploration. For scheduled work, start the run without waiting and collect the dataset afterwards, so network trouble costs you a retry rather than the results.

Which Amazon Offers Scraper (All Offers Display) inputs matter, and which can you skip?

The asins array is the only required field and accepts multiple product identifiers. For most runs, the scraper's automatic fallback behavior handles proxy adjustments dynamically, so you can safely leave the proxy configuration unchanged.

• asins (array): Amazon ASINs to fetch offers for, e.g. B0DCH8VDXF. Default: [].
• productUrls (array): Full Amazon product URLs (any /dp/{ASIN} link). The marketplace domain and ASIN are both extracted from each URL. Default: [].
• conditions (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). Default: "ALL".
• fulfillmentTypes (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). Default: [].
• maxOffersPerProduct (integer): Hard cap on the number of offer records emitted per ASIN (the buy-box/pinned offer counts as one). Default: 20.
• deliveryCountry (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). Default: "".
• postalCode (string): Destination postal code to refine delivery estimates. Optional.
• proxyConfiguration (object): Uses the free AUTO (datacenter) proxy group by default. Some marketplaces (e.g. amazon.co.uk, amazon.de) drop datacenter connections outright, so the actor fast-fails a network-level timeout on a target and automatically retries it once under a RESIDENTIAL session -- a bounded fallback, never the default. Default: {"useApifyProxy":true}.

Fixed-choice controls: conditions accepts ALL (All conditions), NEW (New only), USED (Used only), COLLECTIBLE (Collectible only), RENEWED (Renewed only); deliveryCountry accepts 24 values (default ""), including US (United States), "" ((default - United States)), CA (Canada), MX (Mexico).

What does Amazon Offers Scraper (All Offers Display) return?

The output dataset contains clean rows containing the price, condition, seller identifier, and fulfillment method. It conspicuously does not contain generic buyer contact details, email addresses, or product-level descriptions.

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

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

These are the documented fields. Optional ones can be empty on a given record, so measure how often each field your deliverable depends on is populated across a real sample before automating the handoff.

How do you build the workflow end to end?

Open Amazon Offers Scraper (All Offers Display) and work through these in order. Each step ends with something to check, so a bad configuration surfaces on a small run rather than a scheduled one.

1. Run a single test using your target identifier in the asins array or supply a full link in productUrls.
2. Filter the inventory scope by setting the conditions parameter to NEW, USED, COLLECTIBLE, RENEWED, or leave it as ALL to grab the entire listing spectrum.
3. Select the target customer location by entering a 2-letter code in deliveryCountry and a ZIP code in postalCode to capture geo-specific pricing.
4. Limit the returned volume by entering a cap in the maxOffersPerProduct integer field.
5. Initiate the run and inspect the returned dataset to ensure the isBuyBoxWinner boolean matches the pinned offer.
6. Review the page.classification field in the output to confirm no status records indicating AUTH_REQUIRED, CAPTCHA, or RATE_LIMITED are present.
7. Expand the inputs to your complete ASIN list once you verify that fields like shipsFrom and soldBy.sellerId contain expected values.

How do you apply it? Three worked playbooks

These are Amazon Offers Scraper (All Offers Display)'s own documented use cases, each worked through as an operating pattern rather than a description.

Use case 1: Price monitoring

Outcome: Price monitoring -- track how many sellers compete on a listing and at what price

Configure: Set asins to ["B0DXXYS4BJ"], conditions to "ALL", and maxOffersPerProduct to 30.

Working method: Run the Actor on a daily schedule. Group the returned records by productAsin and sort them by price.value to map out the current seller pricing distribution.

Deliverable: A daily JSON report grouping all competing sellers, their current prices, and their shipping charges by productAsin.

Stop condition: The page.classification field on the status records returns RATE_LIMITED or CAPTCHA repeatedly.

Use case 2: Repricing intelligence

Outcome: Repricing intelligence -- see competitor pricing, condition, and shipping terms side by side

Configure: Set asins to ["B0DCH8VDXF"], conditions to "NEW", deliveryCountry to "US", and postalCode to "10001".

Working method: Run the scraper to gather all active new offers. Match the price.value and shippingPrice.value side by side with the fulfillmentType and sellerRating to analyze competing offers in the same marketplace context.

Deliverable: A structured CSV spreadsheet matching competitor pricing, merchant fulfillment methods, and shipping costs side by side.

Stop condition: The returned results show zero merchant offers because the fulfillmentType filter was configured too restrictively.

Use case 3: Arbitrage / reselling

Outcome: Arbitrage / reselling -- compare New vs Used pricing spreads on the same product

Configure: Set asins to ["B0DXXYS4BJ"], conditions to "ALL", and maxOffersPerProduct to 50.

Working method: Run the scraper across your target ASIN list. Group the resulting dataset by condition, then calculate the exact mathematical spread between the lowest-priced NEW offer and the lowest-priced USED offer.

Deliverable: An arbitrage dashboard identifying listings where the price delta between used and new conditions exceeds your target margin percentage.

Stop condition: The page.classification returns NO_OFFERS, indicating that the listing lacks secondary sellers altogether.

What breaks, and how do you design around it?

When targeting listings with hundreds of active sellers, the scraper is restricted by Amazon's client-side rendering which limits how many offers are loaded behind the initial toggle. If the page.moreOffersAvailable flag returns true, accept this boundary as the limit of single-page execution rather than assuming a technical error. For deeper historical trends, schedule recurrent snapshots rather than expecting the Actor to fetch historical price tables.

When should you not use Amazon Offers Scraper (All Offers Display)?

Do not use this Actor if you need a high-level catalog sweep, category-wide product extraction, or keyword search analysis. If your goal is to discover products or extract generic listing details rather than seller-by-seller offer grids, the Amazon Product Scraper or Amazon Scraper will be significantly more cost-efficient because they capture broad listing metadata without opening individual offer panels. Likewise, if you are looking to generate B2B sales leads by scraping merchant contact details, company registration numbers, and phone numbers, you should use the Amazon Seller & Shop Scraper instead, which is purpose-built to extract seller storefronts and profiles rather than real-time product offers.

What should you check before trusting the output?

• Verify that exactly one record per processed ASIN has isBuyBoxWinner set to true when page.classification is SUCCESS.
• Check that the sellerPositivePercent12m or sellerPositivePercentLifetime field is populated for all third-party seller records.
• Monitor the page.moreOffersAvailable boolean; if it is true, alert your system that some offers remain uncaptured on the page.
• Audit the dataset for status records where page.classification equals RATE_LIMITED to signal when to adjust your scraping schedule.
• Track the omission rate of the fulfillmentType field, raising an alert if too many records are missing FBA or FBM classifications.

None of this proves a record is correct. It gives a scheduled Amazon Offers Scraper (All Offers Display) run defined points where it should stop instead of quietly passing bad data downstream.

Frequently asked questions

What is the cost of running this Actor?

This Actor costs $5.00 per 1,000 results on the free-plan tier, which equals $0.005 per result. Apify also bills platform usage for computer resources consumed during the run on top of these result charges.

Can I test this Amazon scraper for free?

Yes, Apify's free plan provides $5.00 of monthly prepaid platform usage without requiring a credit card, which can cover up to 1,000 results of this Actor before run-start fees.

Why are some fields like sellerRating omitted from certain results?

Fields like sellerRating are omitted because Amazon only shows an independent seller-rating line for third-party merchants. When an offer is sold directly by Amazon, this rating line is missing on the live page, and the Actor leaves the field omitted rather than fabricating data.

How is the fulfillmentType field populated?

The field is populated when the value can be derived from Amazon's explicit labels on the page. The value is derived from Amazon's own 'Ships from' and 'Sold by' labels, leaving the field omitted if the combination is ambiguous.

What happens if an ASIN is invalid or can't be scraped?

The Actor will not return zero rows silently. Instead, it generates a single status record where page.classification indicates the problem, such as INVALID_ASIN, NOT_FOUND, or RATE_LIMITED.

Where to go next

When you are ready to run it, open Amazon Offers Scraper (All Offers Display) on Apify; the free plan covers up to 1,000 results a month.

Start with the Amazon Offers Scraper (All Offers Display) Actor page for the current input schema, pricing tier, and run history.

It is part of the Amazon Scraping Suite, which puts every related Actor on one page with its price and run history.

Other Actors we maintain for related data:

• Amazon Product Scraper: Scrapes Amazon product data including prices, reviews, seller info, variants, and delivery details.
• Amazon Scraper: Scrapes products from Amazon category and search result pages.
• Amazon Wishlist & Registry Scraper: Scrape public/shareable Amazon wishlists, gift lists, baby registries, and wedding registries from URLs you supply.
• Amazon Seller & Shop Scraper: Scrape Amazon third-party seller intelligence: seller profile pages (business name/address/phone, star rating, feedback windows, ratings histogram) and seller storefront catalogs (/s?me=).
• Amazon Reviews Scraper Pro: Extract customer reviews from any Amazon product across 19+ domains with star-rating filtering and sort options.
• Amazon Brand Store Scraper: Scrape Amazon Brand Store pages (/stores/{Brand}/page/{ID}) - curated storefront navigation, creative modules (images/video/CTAs), and every validated product link found on the page.
• Amazon Creator Shop Scraper: Scrape Amazon influencer/creator storefronts (/shop/{handle}): profile info, affiliate disclosure, curated Idea Lists with products and creator comments, and creator videos.
• Amazon Keyword Suggestions Scraper: Discover Amazon's search-autocomplete keyword suggestions for any seed keyword, across 23 marketplaces.

Related guides:

• Amazon Product Scraper Guide for Catalog & Pricing Teams
• Cross-Border Amazon Price Monitoring: Engineering Guide
• Amazon Bestseller Scraper: Operational Guide and Workflows
• Amazon Reviews Scraper Pro: Setup Guide and Playbooks

Resources

• Actor documentation, input schema, and pricing: verified against the published Actor on 2026-10-05.

• Actor last updated by its maintainers on 2026-08-08.

• Run outcome figures cover the 30 day public window ending 2026-10-05.

• Amazon Offers Scraper (All Offers Display) on Apify