Amazon Today's Deals Scraper By Discount, Price & Category

Amazon Deals Scraper — Extract Discounts, Prices and Ratings

An Amazon deals scraper that pulls live rows from Amazon's own Today's Deals feed and lets Amazon's servers do the filtering first — by discount percentage, price range, department, brand, and Prime Exclusive status — before a single row is downloaded. Each deal returns as typed JSON: deal price, list price, savings, a full 1★–5★ rating breakdown, category data, every product image, and the deal's own start/end window. Amazon's deals feed caps any single query at 500 results; this Actor's filter sweep walks multiple independent filter windows and unions them, deduplicated by ASIN, to collect past that ceiling. The guide below covers every input and output field and how teams run this in production — real-time enrichment, scheduled price-drop monitoring, and bulk dataset builds.

---

🧭 What does the Amazon Deals Scraper do?

The Amazon Deals Scraper reads Amazon's data.amazon.com promotions endpoint — the same JSON API amazon.com/deals calls in your browser — and returns every deal that matches your filters as one structured row per ASIN. No Amazon account, login, or cookies are required; the session is established by pulling a CSRF token straight from the public deals page. Filters for discount percentage, price, department, brand, and Prime Exclusive status are all applied server-side by Amazon, which means they don't just trim the output — they change which 500-deal window you're even looking at.

• Server-side discount, price, department, brand, and Prime Exclusive filtering — Amazon evaluates the filter, not a post-download regex
• A filter sweep (sweepBy) that walks up to 200 independent filter windows and merges them, deduplicated by ASIN, to collect more than Amazon's 500-per-query ceiling
• Local title-keyword include/exclude filtering for text search, since Amazon's deals API has none
• Full customer review histogram (5★ through 1★ percentages) on every deal, not just an aggregate rating
• Every product image returned, with hi-res URL, low-res URL, and pixel dimensions — not just the first one
• Non-deal filler rows (title and ASIN, no price, no deal window) identified and excluded by default, and never billed

---

Features & capabilities

Core features

Every row is built from Amazon's own JSON response — there's no HTML parsing, so there's no risk of the price-concatenation bug that affects scrapers built on Amazon's rendered price markup (where a <span> holding the dollars and a second <span> holding the cents get joined as strings instead of added as a decimal, silently inflating prices by roughly 100x). Prices in this Actor come straight from Amazon's moneyValueOrRange.value.amount field as a single numeric value — priceToPay and basisPrice are floats, not reassembled strings.

• Deal economics — priceToPay, basisPrice, savingsAmount, savingsPercentageValue, currency
• Ratings depth — rating, reviewCount, reviewCountDisplay, and fiveStarPercent through oneStarPercent
• Categorisation — category, productType, glProductGroup, categoryId
• Deal metadata — dealId, dealType, dealState, dealStartTime, dealEndTime, dealDurationHours, dealBadgeLabel, dealBadgeMessage, isPrimeExclusive
• Sweep provenance — filterWindow and filterWindowIndex record which filter window found each ASIN, so you can see which department or discount band a deal surfaced under
• Full image set — image, imageLowRes, imageWidth, imageHeight, imageCount, and the complete allImages array
• Strict discount enforcement — Amazon's internal discount metric and the percentage printed on a row can disagree slightly. Whenever minDiscountPercent or maxDiscountPercent is set, the Actor holds every row to the printed savingsPercentageValue as well, so a row is never emitted that visibly contradicts the range you asked for
• A hard ceiling the Actor can't remove — Amazon's promotions API enforces a 500-deal ceiling per filter window regardless of what maxDeals requests; the code comment in main.py notes entity.totalCount is always 500 and pagination terminates there no matter the query. This is why sweepBy exists — it's the only way past a platform limit, not an Actor-imposed one

How this compares to other Amazon deals scrapers

Observed on the Apify Store, 2026-07-26:

Feature	This Actor	piotrv1001/amazon-todays-deals-scraper	api-empire / scraper-engine amazon-todays-deals-scraper
Server-side discount/price/department/brand filters	✅	❌ (domain + limit only)	❌ (startUrls + maxItems only)
Filter sweep past Amazon's 500-deal ceiling	✅	Not documented	Not documented
Review star-histogram (5★–1★ breakdown)	✅	Not documented	Not documented
Full image set with dimensions	✅ (allImages)	Not documented	Not documented
Non-deal filler rows excluded and uncharged	✅	Not documented	Not documented
Multi-region Amazon domains	US only	13 domains listed	Not documented
Pricing model	Pay per event	Pay per event	Flat price per month

If your use case is feeding structured data into an LLM or a pricing model, the filter-depth row is the decision-maker — pulling 10,000 unfiltered rows and post-filtering in your own code costs more runtime and more pay-per-event charges than asking Amazon's own servers to do it first.

When another tool might suit you better

If you need deal data from Amazon's UK, German, or Japanese marketplaces, piotrv1001's scraper lists 13 regional domains on its Store listing (checked 2026-07-26) — this Actor targets the US promotions endpoint only. If your workflow is a single flat-rate subscription rather than pay-per-result pricing, the flat-monthly listings from api-empire and scraper-engine may fit your budget model better, though at the cost of the server-side filter sweep documented above.

The Amazon Deals Scraper within the Scrapio data stack

This Actor covers Amazon's Today's Deals feed. For general product search and listing pages, use Amazon Search Products Scraper. For ASIN-level product detail and buy-box/seller monitoring, use Amazon Product Scraper — Buy Box & Seller Monitor. For bulk ASIN discovery, use Amazon ASINs Scraper.

---

Why do developers and data teams scrape Amazon's deals feed?

🏢 Deal aggregators and affiliate marketers

Deal-blog and coupon-site operators pull priceToPay, basisPrice, savingsPercentageValue, and dealEndTime on a schedule to auto-populate a live deals feed, using link for outbound affiliate clicks and dealBadgeLabel to reproduce Amazon's own "X% off" badge on their own page without recomputing it.

📊 AI training data and RAG indexing

title, category, productType, and the review histogram (fiveStarPercent–oneStarPercent) give an LLM-facing shopping assistant structured, typed fields to reason over instead of parsing HTML mid-conversation. Two common uses: (1) RAG enrichment — indexing title and dealBadgeMessage so an agent can answer "what's on sale in Electronics right now" with current data; (2) training or fine-tuning data for price-comparison and recommendation models, where priceToPay/basisPrice/savingsPercentageValue provide a clean numeric label without unit-parsing.

📱 Competitive and market intelligence

Retail and brand teams track savingsPercentageValue and dealType (BEST_DEAL, LIGHTNING_DEAL, etc.) by category or brandName to see how aggressively competitors are discounting a given department, and use dealStartTime/dealEndTime to catalogue how long promotions typically run.

🔬 Research and academic use

savingsPercentageValue, rating, and the review-count histogram across a large sweepBy: "departments" run give researchers a public snapshot of promotional pricing patterns and rating distributions across e-commerce categories. Public deal-page data only — no account-gated or personal data is collected.

🎥 Product and SaaS development

Browser extensions and price-drop alert apps run this Actor on a schedule, diff priceToPay against the previous run per asin, and push a notification the moment a tracked product's deal price changes.

---

🍚 Input parameters

None of the parameters are required — every field can be left at its default for an unfiltered run of up to 500 deals.

Parameter	Required	Type	Constraints	Description
maxDeals	No	integer	default 100; min 1; max 10000	Total unique deals to return. Amazon caps any single filtered query at 500 deals, so values above 500 only pay off when sweepBy is switched on.
minDiscountPercent	No	integer	min 0; max 100	Only deals discounted at least this much. Applied by Amazon server-side, so it also changes which 500 deals are reachable. Leave empty for any discount.
maxDiscountPercent	No	integer	min 0; max 100	Upper bound on the discount. Useful to carve the catalogue into bands. Leave empty for no upper bound.
minPrice	No	integer	min 0; max 100000	Only deals at or above this price (USD). Leave empty for no minimum.
maxPrice	No	integer	min 0; max 100000	Only deals at or below this price (USD), applied server-side. Leave empty for no maximum.
departments	No	array (stringList)	prefill ["Electronics"]	Department names exactly as Amazon writes them, or raw browse-node IDs. The live list of roughly 30 departments is printed in the run log at startup. Names that don't match today's catalogue are logged and ignored, never silently applied.
brands	No	array (stringList)	prefill []	Brand names from Amazon's live top-20 brand list for today's deals, or the exact brandId|Brand Name form for any other brand. The available brand list is printed in the run log.
primeExclusiveOnly	No	boolean	default false	Restrict to deals Amazon marks Prime Exclusive. Verified server-side by the Actor's author: switching this on moved the "With Prime" badge from 5/180 rows to 171/180.
titleKeywords	No	array (stringList)	prefill []	Keep only deals whose title contains at least one of these words (case-insensitive). Applied after download — Amazon's deals API has no text search. Leave empty to keep everything.
excludeTitleKeywords	No	array (stringList)	prefill []	Drop deals whose title contains any of these words (case-insensitive). Leave empty to exclude nothing.
sweepBy	No	string (enum)	default "none" — none, departments, discountBands, priceBands, departmentsAndDiscount	Amazon returns at most 500 deals per query, but every distinct filter combination has its own 500-deal window. The sweep walks many windows and merges them, deduplicated by ASIN. departments is the widest net (~30 windows); departmentsAndDiscount is the deepest and slowest.
maxFilterWindows	No	integer	default 30; min 1; max 200	Caps how many windows the sweep visits, so a deep sweep can't run away.
includeIncompleteRows	No	boolean	default false	Amazon's deals feed mixes in promotional filler slots that carry a title and ASIN but no price and no deal window. They're dropped by default and are never charged. Switch on to keep them, flagged isCompleteDeal: false.
proxyConfiguration	No	object (Apify proxy editor)	prefill {"useApifyProxy": false}	Optional. The Actor connects directly by default and that is the tested path. Enable a proxy only if your runs start getting blocked.

A hidden alias exists in the code for backward compatibility: a limit key is read before maxDeals if both are present in the raw input JSON, but only maxDeals is exposed in the input schema and Console UI.

Example input

{
  "maxDeals": 2000,
  "minDiscountPercent": 40,
  "maxPrice": 100,
  "departments": ["Electronics", "Home & Kitchen"],
  "primeExclusiveOnly": false,
  "excludeTitleKeywords": ["refurbished", "renewed"],
  "sweepBy": "departments",
  "maxFilterWindows": 30,
  "includeIncompleteRows": false
}

Supported filter combinations

Every filter parameter is combinable — minDiscountPercent/maxDiscountPercent, minPrice/maxPrice, departments, brands, and primeExclusiveOnly all apply together in the same request. If minDiscountPercent is greater than maxDiscountPercent (or minPrice greater than maxPrice), the Actor swaps them and logs a warning rather than failing the run. Three realistic combinations:

• Deep discount, single category: {"minDiscountPercent": 50, "departments": ["Electronics"]} — only 50%+ off deals in Electronics
• Budget sweep across the whole catalogue: {"maxPrice": 25, "sweepBy": "priceBands", "maxDeals": 3000} — walks the price-band windows below $25 and unions them
• Brand-specific run: {"brands": ["Levoit"], "maxDeals": 500} — deals for one brand from the live top-20 brand catalogue

Brand and department values are resolved against a live catalogue Amazon returns at the start of every run — the Actor calls the promotions API once with calculateRefinements=true before collecting any deals, and logs how many departments and brands were found along with the unfiltered window's total deal count. A departments or brands value that doesn't match today's catalogue is reported by name in the run log and dropped from the filter rather than silently applied — the run still proceeds with whatever filters did resolve. Brand names are especially narrow: the API only exposes brand names for roughly the top 20 brands surfacing in the current query, so most brands are only reachable through the exact brandId|Brand Name form rather than a plain name match.

---

📦 Output format

Output is one typed JSON row per deal in the Actor's default dataset, exportable from the Apify Console as JSON, CSV, Excel, XML, or RSS — the standard Apify dataset export formats. The dataset's default view surfaces 39 columns as a table; the Actor actually writes 41 keys per row, listed in full below.

Output for a complete deal

{
  "asin": "B0FW7YTVH3",
  "title": "LEVOIT Air Purifiers for Home Large Room, Smart WiFi Air Purifier",
  "link": "https://www.amazon.com/dp/B0FW7YTVH3",
  "image": "https://m.media-amazon.com/images/I/81iH+3VYNzL.jpg",
  "priceToPay": 89.99,
  "basisPrice": 179.99,
  "savingsAmount": 90.0,
  "savingsPercentageValue": 50,
  "currency": "USD",
  "filterWindow": "department: Home & Kitchen",
  "filterWindowIndex": 3,
  "dealId": "54d4baef",
  "dealType": "BEST_DEAL",
  "isCompleteDeal": true,
  "dealState": "AVAILABLE",
  "dealStartTime": "2026-07-20T07:00:00Z",
  "dealEndTime": "2026-08-01T06:59:59Z",
  "dealDurationHours": 288.0,
  "dealBadgeLabel": "50% off",
  "dealBadgeMessage": "Limited time deal",
  "isPrimeExclusive": false,
  "rating": 4.4,
  "reviewCount": 8480,
  "reviewCountDisplay": "8,480",
  "fiveStarPercent": 72,
  "fourStarPercent": 12,
  "threeStarPercent": 7,
  "twoStarPercent": 4,
  "oneStarPercent": 5,
  "category": "Home",
  "productType": "AIR_PURIFIER",
  "glProductGroup": "gl_kitchen",
  "categoryId": "30905800",
  "brandId": "558260",
  "brandName": "Levoit",
  "imageLowRes": "https://m.media-amazon.com/images/I/41s9j3RlkwL.jpg",
  "imageWidth": 2070,
  "imageHeight": 1725,
  "imageCount": 6,
  "allImages": [
    { "hiRes": "https://m.media-amazon.com/images/I/81iH+3VYNzL.jpg", "lowRes": "https://m.media-amazon.com/images/I/41s9j3RlkwL.jpg", "width": 2070, "height": 1725 }
  ],
  "scrapedAt": "2026-07-20T09:41:17Z"
}

Every field is one of: asin, title, link, image, priceToPay, basisPrice, savingsAmount, savingsPercentageValue, currency, filterWindow, filterWindowIndex, dealId, dealType, isCompleteDeal, dealState, dealStartTime, dealEndTime, dealDurationHours, dealBadgeLabel, dealBadgeMessage, isPrimeExclusive, rating, reviewCount, reviewCountDisplay, fiveStarPercent, fourStarPercent, threeStarPercent, twoStarPercent, oneStarPercent, category, productType, glProductGroup, categoryId, brandId, brandName, imageLowRes, imageWidth, imageHeight, imageCount, allImages, scrapedAt. Two of these — reviewCountDisplay and allImages — are written to every row but are not in the dataset's default table view; open the row in the Console or export JSON to see them.

A field the API doesn't have for a given product is written as null, never omitted and never a placeholder like 0 or "". Amazon's promotions API declares an explicit type on every nested entity it returns, and answers an unavailable entity with HTTP 200 and a type: "error/v1" node instead of a normal payload — the Actor checks the declared type before reading a field, so a missing entity always comes through as null rather than silently reading garbage from an error node.

Output for a non-deal filler row (includeIncompleteRows: true)

Amazon's deals feed mixes in promotional slots that carry a title and an ASIN but no price and no deal window. With includeIncompleteRows off (the default) these are dropped entirely and never appear in the dataset or in your bill. Switched on, they're kept and flagged:

{
  "asin": "B0C1XYZ001",
  "title": "Shop today's Electronics deals",
  "link": "",
  "image": "",
  "priceToPay": null,
  "basisPrice": null,
  "savingsAmount": null,
  "savingsPercentageValue": null,
  "currency": null,
  "dealId": null,
  "dealType": null,
  "isCompleteDeal": false,
  "dealState": null,
  "dealStartTime": null,
  "dealEndTime": null,
  "dealDurationHours": null,
  "filterWindow": "unfiltered",
  "filterWindowIndex": 0,
  "scrapedAt": "2026-07-20T09:41:20Z"
}

To isolate only the priced, chargeable deals in a dataset that mixes both, filter on isCompleteDeal == true.

Schema stability and export options

Field names in this Actor's output are defined by the Actor's own code, not by Amazon's raw JSON keys, so they stay stable across Amazon front-end redesigns as long as the underlying promotions API entity shapes don't change. If Amazon adds a new entity type the Actor doesn't yet request, existing fields are unaffected — new data simply isn't collected until the Actor is updated. Results are delivered to the Actor's default Apify dataset for every run and can be exported as JSON, CSV, Excel (XLSX), XML, or RSS directly from the Apify Console, or pulled programmatically through the Apify API or apify-client SDKs.

---

Amazon Deals Scraper strategy guide

🎯 Strategy 1: Real-time enrichment pipeline

Trigger a run whenever a new ASIN enters your catalogue or CRM, filtered to departments matching your category and maxDeals set to whatever volume you need. Append the real fields — priceToPay, basisPrice, savingsPercentageValue, dealBadgeLabel, dealEndTime — to the source record, then write the enriched row back to your product database or spreadsheet. Because filters run server-side, a narrow minDiscountPercent/departments combination returns a small, cheap dataset instead of downloading everything and filtering locally.

🎯 Strategy 2: Scheduled monitoring and alerting

Set up an Apify Schedule to run the Actor daily or hourly against a fixed filter set (for example, departments + minDiscountPercent). Diff the new run's priceToPay and dealEndTime against the previous run's dataset, keyed on asin, and alert only when priceToPay drops further or a dealId disappears (the deal ended). This turns a static filter into a live price-drop monitor without re-scraping anything outside your tracked filter set.

🎯 Strategy 3: Bulk dataset build

For a research or training dataset, run with sweepBy: "departments" (or "departmentsAndDiscount" for the deepest coverage) and a high maxDeals, then export the resulting dataset directly to CSV or Excel from the Apify Console, or pull it via the API into a database. Each row carries filterWindow and filterWindowIndex, so you can trace exactly which department or discount band surfaced each ASIN, and dedupe or re-aggregate later without re-running anything.

Strategy comparison at a glance

Strategy	Best for	Run pattern	Output format
Real-time enrichment	Filling in live deal pricing for records you already track	On-demand, narrow filters	JSON via API, written back to your system
Scheduled monitoring	Catching price drops and deal expirations early	Recurring Apify Schedule, diffed on asin	Dataset per run, diffed programmatically
Bulk dataset build	Research, market snapshots, training data	One large sweepBy run	CSV / Excel / JSON export from the Console

---

🌴 Related Amazon scrapers & tools

Scraper	What it extracts
Amazon Search Products Scraper	Product search-result listings by keyword
Amazon Product Scraper — Buy Box & Seller Monitor	ASIN-level product detail, buy-box, and seller data
Amazon ASINs Scraper	Bulk ASIN discovery and lookup

---

How to integrate the Amazon Deals Scraper with your stack

This Actor works with any language or tool that can make an HTTP request through the Apify API, or with Apify's official client SDKs. Runs are started and monitored through the Apify Console or API — there is no separate signup flow or API key outside your Apify account token.

Python

from apify_client import ApifyClient
import csv

client = ApifyClient("<APIFY_API_TOKEN>")

run_input = {
    "maxDeals": 1000,
    "minDiscountPercent": 30,
    "departments": ["Electronics"],
    "sweepBy": "discountBands",
    "maxFilterWindows": 10,
}

run = client.actor("<YOUR_USERNAME>/amazon-todays-deals-scraper-by-discount-price-category").call(
    run_input=run_input
)

rows = list(client.dataset(run["defaultDatasetId"]).iterate_items())

with open("amazon_deals.csv", "w", newline="", encoding="utf-8") as f:
    writer = csv.DictWriter(f, fieldnames=rows[0].keys())
    writer.writeheader()
    writer.writerows(rows)

print(f"Collected {len(rows)} deals")

Node.js

import { ApifyClient } from 'apify-client';

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

const input = {
    maxDeals: 1000,
    minDiscountPercent: 30,
    departments: ['Electronics'],
    sweepBy: 'discountBands',
    maxFilterWindows: 10,
};

const run = await client
    .actor('<YOUR_USERNAME>/amazon-todays-deals-scraper-by-discount-price-category')
    .call(input);

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(`Collected ${items.length} deals`);

HTTP / cURL

Any language that can issue an HTTP request can start a run directly through the Apify API, without either SDK:

curl "https://api.apify.com/v2/acts/<YOUR_USERNAME>~amazon-todays-deals-scraper-by-discount-price-category/run-sync-get-dataset-items?token=<APIFY_API_TOKEN>" \
  -H "Content-Type: application/json" \
  -d '{
    "maxDeals": 500,
    "minDiscountPercent": 40,
    "departments": ["Electronics"]
  }'

run-sync-get-dataset-items blocks until the run finishes and returns the dataset items directly in the response — convenient for smaller, filtered runs; for a large sweepBy sweep, use the async endpoints described below instead so the request doesn't have to stay open for the whole run.

Async and scheduled pipelines

For large sweepBy runs, start the run through the API and poll run.status (or subscribe to an Apify webhook for ACTOR.RUN.SUCCEEDED) rather than blocking on call(). For recurring monitoring, use an Apify Schedule to trigger the Actor on a fixed cadence with a saved input, then pull the resulting dataset via the API each time it completes.

---

🎯 Who needs Amazon deals data? (Use cases & industries)

🏢 Deal aggregators and affiliate marketers

A coupon site runs a sweepBy: "priceBands" sweep nightly, keeps rows with savingsPercentageValue above a threshold, and republishes title, priceToPay, dealBadgeLabel, and link as an affiliate feed.

📊 AI product and shopping assistants

A shopping-assistant agent queries this Actor filtered to a departments list and passes the typed JSON straight into its context window — title, category, and rating need no HTML parsing before the model can reason over them.

📱 Retail and brand competitive intelligence

A brand's pricing team filters by brands and tracks savingsPercentageValue and dealType over a week of scheduled runs to see how often and how deeply a category is being discounted.

🔬 Researchers

Academic and market researchers use a broad sweepBy: "departments" run to build a public dataset of promotional pricing and rating distributions across e-commerce categories, without touching any account-gated or personal data.

🎥 Deal-alert app and browser-extension developers

Product teams building a price-drop notifier schedule this Actor per tracked ASIN or category, diff priceToPay run over run, and push a notification the moment a deal appears or improves.

---

Is it legal to scrape Amazon's deals pages?

Scraping publicly accessible web pages is generally lawful in the United States; the Ninth Circuit's ruling in hiQ Labs v. LinkedIn (9th Cir., 2019) held that scraping data not gated behind a login does not violate the Computer Fraud and Abuse Act. That case concerned public profile pages, but the underlying principle — that accessing publicly available data is not "unauthorized access" — is the relevant precedent for scraping Amazon's public deals pages, which require no login.

Separately, scraping in a way that breaches a site's Terms of Service can expose the scraper to civil contract claims from the platform, distinct from and generally lower-stakes than criminal exposure. This Actor collects only publicly available deal and product data — ASINs, prices, titles, ratings, and images — none of which is personal data about an individual, so GDPR and CCPA obligations, which govern personal data, do not attach to this Actor's output. Amazon's Conditions of Use still govern what you may do with data collected from its site.

The Amazon Deals Scraper returns only publicly accessible data. What you do with that data is your responsibility — consult legal counsel for commercial applications.

---

❓ Frequently asked questions

Does the Amazon Deals Scraper work without an Amazon account?

Yes. The Actor establishes its session by pulling a CSRF token straight out of the public amazon.com/deals page's HTML — no login, cookies, or Amazon account are used or required at any point.

How does the Actor handle Amazon's anti-scraping measures?

It detects blocking by response size rather than status code, since Amazon can return HTTP 200 with a small challenge or empty shell instead of a normal error. A deals-page response under roughly 50 KB, or an API response under roughly 10 KB with no rankedPromotions payload, is treated as a block and retried up to three times, waiting 1.5, then 3 seconds between attempts on the deals page, and 1, then 2 seconds between attempts on the API itself. A rejected filter shape (HTTP 400) is not retried, since retrying an invalid request can't fix it — the Actor treats a 400 as a permanently rejected request and moves on. No proxy is used by default — the Actor's tested path is a direct connection — but Apify Proxy can be configured through the proxyConfiguration input if a run starts getting blocked.

Can I run this at scale without getting blocked?

The Actor limits itself to 8 concurrent connections per run and pauses 0.25 seconds between pages within a filter window, as implemented in the source. There is no published uptime or success-rate figure for this Actor; how a given run performs depends on Amazon's own rate limiting, which is not something this Actor's documentation can guarantee against.

How fresh is the data this Actor returns?

Every run performs a live fetch against Amazon's promotions API — nothing is cached or served from a previous run. scrapedAt on every row records the exact UTC timestamp of that fetch.

Which fields work best for AI training and RAG indexing?

For RAG, index title, category, productType, and dealBadgeMessage — the highest-information text fields for matching a shopping query to a live deal. For training or fine-tuning a pricing or recommendation model, priceToPay, basisPrice, savingsPercentageValue, and the fiveStarPercent–oneStarPercent histogram are the most consistently structured numeric fields across records. Every field returns as a typed primitive — float, integer, boolean, or string — so no unit-parsing or string-cleaning is needed before passing rows into a model context.

Does the Actor return any personal data?

No. Every field describes a product, a deal, or an aggregate review statistic — never an individual reviewer or buyer. There is no personal-data handling to disclose, and no GDPR/CCPA lawful-basis question applies to this Actor's output.

Does this Actor work with Claude, ChatGPT, and other AI agent tools?

There is no MCP server integration published for this Actor. It is callable as a standard Apify Actor run through the Apify API by any agent framework capable of making an HTTP request — every response is typed JSON that needs no parsing before being placed in an LLM's context window.

Why are some rows missing prices?

They aren't deals. Amazon's deals feed mixes in promotional filler slots — a title and an ASIN with no offer attached — among genuine deals. They're identified by the absence of a deal type and a positive price, dropped by default, and never charged. Set includeIncompleteRows: true to keep them; they arrive flagged isCompleteDeal: false.

How does the Amazon Deals Scraper compare to other Amazon deals scrapers on Apify?

Checked on the Apify Store, 2026-07-26: piotrv1001/amazon-todays-deals-scraper takes only a domain and a limit, covers 13 regional Amazon marketplaces, and does not document server-side filtering, a sweep past the 500-deal ceiling, or a review-star histogram. The api-empire and scraper-engine listings for the same Actor name take startUrls and maxItems, are priced as a flat monthly subscription rather than pay-per-result, and likewise don't document filter parameters or a sweep mechanism. This Actor's advantage is filter depth and the ability to exceed Amazon's per-query cap; if multi-region coverage or flat-rate pricing matters more to your use case, one of those alternatives may be the better fit.

---

Disclaimer

The Amazon Deals Scraper extracts only publicly available data from Amazon's Today's Deals pages. This tool is intended for lawful use cases only. Users are responsible for complying with Amazon's Conditions of Use and applicable data protection laws in their jurisdiction.