# Amazon Deals Scraper (`crawlerbros/amazon-deals-scraper`) Actor

Scrape Amazon's Today's Deals grid (/deals) - discounted products with deal price, list price, savings amount/percent, deal type, brand and department IDs. Filter by category, brand, rating, price range and discount range across 20+ Amazon marketplaces.

- **URL**: https://apify.com/crawlerbros/amazon-deals-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 Deals Scraper

Scrape **Amazon's Today's Deals** grid (`/deals`) across 23 Amazon marketplaces. Get every discounted product's ASIN, title, images, brand, department/category, variation options and pinned status. Filter by category, brand, price range, discount range and deal type (see FAQ for the current status of the `minRating` filter). No login required.

### What this actor does

- **23 marketplaces** — amazon.com, .co.uk, .de, .fr, .it, .es, .ca, .com.au, .co.jp, .in, .com.br, .com.mx, .nl, .se, .pl, .com.tr, .ae, .sa, .sg, .eg, .ie, .com.be, .co.za
- **Filters:** category/department, brand, deal price range, discount percent range, deal type (real collection bubbles Amazon shows on the page); a `minRating` input also exists but currently has no effect since Amazon's Deals grid never exposes per-deal ratings (see FAQ)
- **Deal fields:** title, images, deal/list price, savings amount/percent, deal badge text/messaging, countdown-badge expiry timestamp, claim progress, deal state/promotion type, lightning-deal flag, brand name/ID, department names/IDs, category, variation options, pinned flag
- **Pagination:** walks the deals grid page by page up to your limits
- **Empty fields are omitted**

### Output per deal

- `asin` — Amazon Standard Identification Number
- `title` — product title
- `sourceUrl` — canonical product URL
- `images[]` — product image URLs (hi-res and low-res variants)
- `dealPrice`, `listPrice` — `{value, currency, display}` — included whenever Amazon's Deals grid carries live pricing for that specific deal (a real subset of deals — typically roughly half on any given fetch — genuinely have no price data attached, e.g. brand-level coupon promos; never fabricated, see FAQ)
- `savingsAmount`, `savingsPercent` — included whenever Amazon exposes them (derived from the deal's own price fields and/or its badge percentage, whichever is present)
- `dealBadgeText` — the deal grid's own badge label (e.g. `"15% off"`), when shown
- `dealBadgeMessage` — the badge's messaging line (e.g. `"Limited time deal"`), when shown
- `dealEndsAt` — ISO-8601 UTC expiry timestamp for a Lightning-Deal-style countdown badge (e.g. `"Ends in"`), when Amazon exposes one for that deal
- `percentClaimed`, `percentClaimedMessage` — live claim-progress for the deal (e.g. `34.0`, `"34% claimed"`), when Amazon exposes it for that deal
- `dealState` — the deal's live state as Amazon reports it (e.g. `AVAILABLE`)
- `dealPromotionType` — Amazon's internal promotion classification for the deal (e.g. `BEST_DEAL`, `LIGHTNING_DEAL`)
- `isLightningDeal` — boolean, whether Amazon's own cart data flags this as a Lightning Deal
- `brandId`, `brandName` — Amazon's internal brand ID and its resolved display name
- `departmentIds[]`, `departmentNames[]` — Amazon's internal department/category IDs and resolved names
- `categorySymbol`, `productType` — Amazon's internal category taxonomy codes
- `brandLogoUrl` — the brand's logo image, when shown
- `variationDimensions` — variant/size/color options and their ASINs (when present)
- `isPinned` — whether Amazon pinned this deal
- `dealId` — stable deal/promotion ID (when exposed by the widget)
- `position` — 1-based rank in the deals grid
- `recordType: "deal"`, `scrapedAt`

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `marketplace` | string | `amazon.com` | Which Amazon domain's Deals page to scrape |
| `dealType` | string | `(any)` | Real collection bubble Amazon shows on the page — Lightning Deals / Coupons / Outlet / Customers' Most-Loved / Lowest Price in 365 Days / plus 30+ per-category bubbles (Electronics, Beauty, Fashion, Home, Toys & Games, etc.), all live-verified against amazon.com/deals |
| `category` | string | – | Free-text filter matched against department name / category taxonomy code |
| `brand` | string | – | Free-text brand substring filter |
| `minRating` | int | – | Minimum star rating (1-5) — currently a no-op; see FAQ |
| `priceMin` / `priceMax` | int | – | Deal price range (local currency, when price data is available — see FAQ) |
| `discountMin` / `discountMax` | int | – | Discount percent range (when available — see FAQ) |
| `maxItems` | int | `30` | Hard cap on emitted deals (1-2000) |
| `maxPages` | int | `5` | Hard cap on grid pages walked (1-50) |
| `proxyConfiguration` | object | AUTO | Apify proxy — AUTO by default, auto-escalates to residential on repeated blocks |

#### Example: default US deals grid

```json
{
  "marketplace": "amazon.com",
  "maxItems": 30
}
```

#### Example: home & kitchen deals from a specific brand

```json
{
  "marketplace": "amazon.com",
  "category": "Home & Kitchen",
  "brand": "Bissell",
  "maxItems": 60
}
```

#### Example: UK Customers' Most-Loved deals with a 4-star minimum

```json
{
  "marketplace": "amazon.co.uk",
  "dealType": "deals-collection-cml",
  "minRating": 4,
  "maxItems": 50
}
```

### Use cases

- **Deal aggregators** — build a curated "today's deals" catalog feed
- **Competitive intelligence** — see which brands/categories Amazon is currently discounting
- **Merchandising research** — track which products get pinned/featured in the Deals grid
- **Shopping assistants** — surface deals matching a user's category/brand interest
- **Catalog enrichment** — pull variation options (size/color) and brand metadata for deal ASINs

### FAQ

**Does this require an Amazon account or cookies?**  No. The Deals page is publicly browsable; the actor scrapes it directly with no login.

**Why don't I see `dealPrice`, `listPrice`, `savingsPercent`, `dealBadgeText` or `percentClaimed` on every record?**  Amazon's own Deals grid data genuinely omits price/badge/claim-progress information for a real subset of deals on any given fetch (commonly brand-level coupon promos with no single "deal price" to show). The actor never fabricates these fields — it populates them whenever Amazon's page includes them for that specific deal, and omits them entirely otherwise. All the catalog/structural fields (title, images, brand, category, variations) are always populated when Amazon shows them.

**Why do a few records occasionally show an implausibly large `dealPrice`/`listPrice`?**  On rare fetches, Amazon's own Deals grid data itself carries an inflated numeric value for a handful of deals — independently confirmed live by inspecting the raw page data byte-for-byte, not an actor parsing/arithmetic error (the actor's `savingsPercent` math on these records is still internally correct — e.g. a genuinely-computed "30% off" — only the absolute base price is implausible). This appears tied to sessions Amazon treats as higher-risk/automated (the same class of session-dependent behavior that can also cause Amazon to render a different regional currency than expected); the actor does not attempt to "correct" these values since there is no reliable way to distinguish a genuinely expensive real deal from an inflated one without fabricating a number. If you filter downstream by price, treat an outlier far outside a category's normal range with appropriate skepticism.

**Why is `dealType` filtering only "best effort" for some values?**  Amazon's Deals page groups deals into filter "bubbles". Category-style bubbles (e.g. Customers' Most-Loved) are backed by an explicit department list, so the actor can verify membership per deal. Promotion-style bubbles (Lightning Deals, Coupons, Outlet) aren't tagged per-item in the grid data the actor can see, so those filters pass every deal through rather than risk wrongly excluding a real match. Additionally, not every `dealType` value is guaranteed to render as a live bubble on every one of the 23 supported marketplaces on a given day (e.g. a smaller marketplace's Deals page may simply not have a "Jewelry" bubble today) — when this happens the actor logs a warning and passes every deal through unfiltered rather than silently returning zero results; check the run log if a `dealType` filter appears to have had no effect.

**Why does `sourceUrl` 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 the Deals grid successfully using a real browser session and proxy rotation; the URLs in the output are the correct, canonical Amazon product URLs and will render normally when opened in a browser or fetched with an equivalent session.

**Does `minRating` actually filter anything?**  Not currently, in practice. Amazon's Deals grid data (the same page payload documented above) never includes a per-deal star rating — only structural/catalog fields do. Since the actor never excludes a deal on the *absence* of rating evidence (per its no-fabrication rule), `minRating` currently passes every deal through unfiltered rather than risk wrongly dropping real matches. The input is kept because a future/differently-trusted session could expose rating data the way it can expose pricing; if you need rating-based filtering today, filter the output dataset by `stars` after the run (it will simply be absent on every current record).

**How many deals can I get per run?**  Amazon's Deals grid returns up to 30 items per page (occasionally fewer, depending on catalog/session state). The actor attempts to walk further pages by reproducing the grid's own "load more" request live in-browser; if Amazon doesn't expose a further page in a given session, the actor stops cleanly rather than guessing. Each deal's `position` is always a gapless, 1-based rank across the full run regardless of how many items any individual page actually returned.

**What if my category/brand filter returns 0 results?**  These are free-text substring filters matched against the department name / category code / brand name Amazon exposes on each deal. If nothing matches, widen or clear the filter.

**Is this affiliated with Amazon?**  No, this is an independent third-party actor that scrapes Amazon's public Deals page.

**How fresh is the data?**  As fresh as the live page at run time — Amazon refreshes its Deals grid continuously throughout the day.

### 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 Offers Scraper (All Offers Display)](https://apify.com/crawlerbros/amazon-offers-scraper)
- [Amazon Seller & Shop Scraper](https://apify.com/crawlerbros/amazon-seller-shop-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

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

Which Amazon domain's Today's Deals page to scrape.

## `dealType` (type: `string`):

Only emit deals belonging to this collection bubble (the real filter chips Amazon shows atop the Deals page). Department-scoped bubbles (e.g. Customers' Most-Loved) are enforced by matching each deal's department IDs; tag-scoped bubbles (Lightning Deals, Coupons, Outlet) can't be verified per-deal from the grid data and pass through unfiltered. `(any deal type)` applies no filter.

## `category` (type: `string`):

Free-text filter matched against each deal's department/category name (case-insensitive substring, e.g. `Electronics`, `Home`, `Toys`). Leave empty for all categories.

## `brand` (type: `string`):

Free-text filter matched against each deal's brand name (case-insensitive substring, e.g. `Anker`, `Samsung`). Leave empty for all brands.

## `minRating` (type: `integer`):

Only emit deals with a star rating at or above this value. Deals without a visible rating pass through unless this is set.

## `priceMin` (type: `integer`):

Drop deals priced below this amount (in the marketplace's local currency).

## `priceMax` (type: `integer`):

Drop deals priced above this amount (in the marketplace's local currency).

## `discountMin` (type: `integer`):

Drop deals with a savings percentage below this value.

## `discountMax` (type: `integer`):

Drop deals with a savings percentage above this value.

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

Hard cap on emitted deal records.

## `maxPages` (type: `integer`):

Hard cap on how many grid pages (up to 30 items each) to walk (each page is a fresh in-browser fetch of the widget's own pagination request).

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

Apify proxy used to fetch the Deals page. AUTO (datacenter) is used by default; the actor escalates to residential automatically only after repeated block detections within a run.

## Actor input object example

```json
{
  "marketplace": "amazon.com",
  "dealType": "",
  "category": "",
  "brand": "",
  "maxItems": 30,
  "maxPages": 5,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `deals` (type: `string`):

Dataset containing all scraped Amazon deals.

# 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 = {
    "marketplace": "amazon.com",
    "dealType": "",
    "category": "",
    "brand": "",
    "maxItems": 30,
    "maxPages": 5,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/amazon-deals-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 = {
    "marketplace": "amazon.com",
    "dealType": "",
    "category": "",
    "brand": "",
    "maxItems": 30,
    "maxPages": 5,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("crawlerbros/amazon-deals-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 '{
  "marketplace": "amazon.com",
  "dealType": "",
  "category": "",
  "brand": "",
  "maxItems": 30,
  "maxPages": 5,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call crawlerbros/amazon-deals-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/acts/L7gPt7qapA7ta7ZAA/builds/ZCGpc1CkgHrdOUCKd/openapi.json