Amazon Today's Deals Scraper: Deal Countdown & New Arrivals

Amazon Today's Deals Scraper — Countdown, New & Ended Deals

Amazon Today's Deals Scraper reads Amazon's own Today's Deals promotions feed and turns each raw start/end timestamp into a countdown — hours remaining, deal phase, percent elapsed — then, when you run it again, tells you exactly which deals are new, which have ended, and which changed price since the previous run. Every result is structured JSON with a consistent schema, ready to load into a spreadsheet, a monitoring pipeline, or pass straight to an LLM as context. No Amazon account, login, or API key is required to run it — just an Apify account.

What is Amazon Today's Deals Scraper: Deal Countdown & New Arrivals?

It's an Apify Actor that queries Amazon's internal Today's Deals promotions endpoint (the same feed that powers amazon.com/deals) and returns each deal as one structured row: product identity, price and savings, the deal's live/ended state, and — when tracking is enabled — how that deal has changed since the last time you ran it. No Amazon account or API credential is required; the Actor reads the same publicly served deals page any visitor sees.

What makes it different from a plain deals scrape is that it doesn't just capture a single snapshot. It computes a countdown (hoursRemaining, dealPhase, dealElapsedPercent) from Amazon's own start/end timestamps, and — across repeated runs — persists a baseline snapshot so it can flag isNewSinceLastRun, endedSinceLastRun, priceChangeSinceLastRun, and emit a separate row for every deal that disappeared from the feed since your last run.

Key capabilities:

• 🧮 Bulk collection — up to 500 deals per run from Amazon's ranked promotions window, with a configurable maxDeals
• ⏳ Countdown enrichment — hoursRemaining, hoursSinceStart, dealDurationHours, dealElapsedPercent, and a classified dealPhase (JUST_STARTED, FIRST_HALF, SECOND_HALF, FINAL_DAY, FINAL_HOURS, ENDED) computed directly from Amazon's timestamps
• ⏰ Time-window shortlists — filter to deals ending within X hours (endsWithinHours) or that started within X hours (startedWithinHours), independent of each other
• 🔁 Run-over-run change tracking — a named key-value store snapshot lets each run diff itself against the previous one and report isNewSinceLastRun, endedSinceLastRun, priceChangeSinceLastRun, and dealIdChanged
• 🔚 Disappearance detection — a dedicated row type for deals that vanished since your last run, with a disappearedReason of EXPIRED or ROTATED_OUT_STILL_LIVE
• 🧹 Filler-row filtering — Amazon's own feed mixes in promotional slots with no deal at all; excludeNonDealRows strips them by default

What data can you get with the Amazon deal countdown scraper?

The Actor returns two row types from a single run: the live deal rows currently in Amazon's promotions window, and — when change tracking is on — disappeared deal rows for anything that was in your previous run but is missing now.

Result type	Extracted fields	Primary use case
Active deal (rowType: "active")	asin, title, link, image, priceToPay, basisPrice, currency, savingsAmount, savingsPercentageValue, dealType, dealId, dealState, isRealDeal, dealStartTime, dealEndTime, hoursRemaining, hoursSinceStart, dealDurationHours, dealElapsedPercent, dealPhase, endsToday, isNewSinceLastRun, previousPriceToPay, priceChangeSinceLastRun, dealIdChanged	Deal countdown dashboards, "deals ending soon" alerts, price-drop monitoring
Disappeared deal (rowType: "disappeared")	Same product/price fields carried over from the last snapshot, plus disappearedReason (EXPIRED or ROTATED_OUT_STILL_LIVE), endedSinceLastRun	Detecting deals that expired vs. deals that simply fell out of Amazon's ranked window while still live

Deal countdown and change tracking

This is the capability the three highest-ranked competing Amazon deals scrapers on the Apify Store do not document: none of their published READMEs or sample output (checked on the Apify Store, 2026-07-25) show a countdown field, a "new since last run" flag, or a disappearance reason. Their output samples stop at price, savings, and the raw dealStartTime/dealEndTime strings — the reader still has to compute "how long is left" and "did this show up yesterday" themselves.

This Actor computes both directly from Amazon's own timestamps and, when trackChangesBetweenRuns is on, from a persisted snapshot of your previous run:

{
  "asin": "B0EXAMPLE1",
  "dealPhase": "FINAL_HOURS",
  "hoursRemaining": 3.25,
  "endsToday": true,
  "dealElapsedPercent": 96.4,
  "isNewSinceLastRun": false,
  "endedSinceLastRun": false,
  "priceChangeSinceLastRun": -4.5,
  "disappearedReason": null,
  "diffStatus": "COMPARED",
  "isFirstRun": false
}

dealPhase is one of JUST_STARTED, FIRST_HALF, SECOND_HALF, FINAL_DAY, FINAL_HOURS, or ENDED, derived purely from hoursRemaining and hoursSinceStart — never from a hardcoded schedule. All countdown fields come back null, never a fabricated 0, whenever Amazon doesn't supply a usable start or end timestamp for that deal.

Deal identity and pricing

Every row also carries the deal's product identity and pricing: asin, title, link (a normalized amazon.com product URL), image (the high-resolution product image URL), priceToPay, basisPrice, savingsAmount, savingsPercentageValue, currency, dealType, dealId, and dealState. isRealDeal distinguishes an actual priced promotion from Amazon's own carousel filler slots — useful if you ever run with excludeNonDealRows turned off to see the raw feed.

Why not build an Amazon deal countdown tracker yourself?

Amazon does not publish a documented public API for its Today's Deals / promotions feed — the Product Advertising API is scoped to product search and catalog lookups, not the ranked, time-boxed promotions window behind amazon.com/deals. Building a reliable puller against that feed yourself means solving several problems this Actor already handles:

• A rotating CSRF token that isn't in any header. Amazon's promotions API requires a token that only exists embedded in the deals page HTML. This Actor scrapes it out of the page with a dedicated regex, with a fallback deals URL and up to 3 retries if the first page doesn't return one.
• Block pages that return HTTP 200. A blocked or rate-limited response often still comes back with a 200 status — it just has a few kilobytes of HTML instead of the tens of kilobytes a real deals page returns, or a body of a few hundred bytes instead of the tens of kilobytes a real API response returns. The Actor checks response size, not just status code, before trusting a page.
• A feed that silently caps at 500 rows. Amazon's own entity.totalCount is always 500 regardless of how many deals actually exist — anything you ask for above that is simply unreachable through this endpoint, and you won't find that out until you've built pagination and hit the wall yourself.
• State between runs. Detecting "new since last run" or "just expired" requires persisting a snapshot and diffing it correctly — including deciding whether a vanished deal actually expired or just rotated out of a ranked window while still live. That logic (see below) is easy to get subtly wrong.

Under the hood, the Actor walks the promotions endpoint in pages, following Amazon's own nextIndex cursor until it either collects maxDeals rows or Amazon's window runs out, using a bounded connection pool so it doesn't hammer the endpoint with unlimited parallel requests. Every page and retry attempt is logged with its HTTP status and response size, so a run that stalls or gets blocked is diagnosable from the log rather than a silent empty dataset.

If you only need a one-time snapshot of current deals, a simple page fetch might suffice. If you need the countdown, the new/ended tracking, or don't want to maintain scraping infrastructure against a feed that can change its markup at any time, that's what this Actor is for.

What's the difference between a one-off Amazon deals scrape and a deal tracker?

A one-off deals scrape returns a snapshot: whatever is live in Amazon's promotions window at the moment the request runs. It cannot tell you whether a deal you're looking at just appeared or has been running for a week, and it cannot tell you when a deal you saw yesterday is gone today.

A deal tracker — what this Actor does when trackChangesBetweenRuns is enabled — adds a second dimension: change over time. It persists a snapshot of every deal it collects to a named Apify key-value store, and on the next run compares against it. That comparison is what produces isNewSinceLastRun, endedSinceLastRun, priceChangeSinceLastRun, dealIdChanged, and the dedicated disappeared-deal rows with disappearedReason.

This distinction matters because Amazon's deals window is a ranked, capped feed (500 rows), not a stable list — a deal can drop out of that window because it expired, or simply because higher-ranked deals pushed it out while it's still live. Only a tracker that diffs consecutive runs, keyed by ASIN rather than Amazon's own dealId (which can itself change on a live deal), can tell those two cases apart. This Actor returns both a snapshot view (every field above) and the tracked-change view (the fields in this section) from the same run — no separate mode or extra input required.

How to scrape Amazon's Today's Deals with this Actor

1. Open Amazon Today's Deals Scraper: Deal Countdown & New Arrivals on the Apify Store and click Try for free (or Start, if you already have it saved).
2. Leave the input at its defaults for a straight pull of Amazon's current deals window, or set maxDeals to how many deals you want (up to 500).
3. Set the countdown filters you care about: endsWithinHours for an "ending soon" shortlist, startedWithinHours for a "just landed" shortlist. Leave both at 0 to get everything.
4. Click Start and let the run finish — there's no query string or URL to supply; the Actor reads Amazon's public deals feed directly.
5. Open the Dataset tab and export the results as JSON, JSONL, CSV, Excel, or XML, or pull them programmatically with the Apify API or apify-client.

{
  "maxDeals": 200,
  "endsWithinHours": 24,
  "trackChangesBetweenRuns": true
}

How to run this on a recurring schedule

There's no batching input to fill in — a single run always scans the entire deals window in one pass, up to maxDeals. To watch for new arrivals or expirations over time, use an Apify Schedule to re-run the same Actor (with the same trackingStoreName) every few hours; each run then diffs itself automatically against the last one via the key-value store snapshot, with no extra input needed.

⬇️ Input

The Actor takes no required fields — running it with an empty input {} collects up to 100 current deals with tracking enabled. Every option below is optional.

Parameter	Required	Type	Constraints	Description
maxDeals	No	integer	default 100; min 1; max 500	Number of deals to collect from Amazon's Today's Deals feed. Amazon's promotions surface exposes a hard 500-deal window — its own totalCount is always 500 — so anything above 500 is capped at 500, and the cap is logged.
endsWithinHours	No	integer	default 0; min 0; max 8760	Keep only deals whose end time is this many hours away or less. Set 0 to turn the filter off. Amazon deal windows tend to run long (commonly 4–30 days), so a small value like 24 typically keeps only a handful of rows out of hundreds.
startedWithinHours	No	integer	default 0; min 0; max 8760	Keep only deals that went live in the last X hours, based on Amazon's own deal start time — no previous run required. Set 0 to turn the filter off.
excludeNonDealRows	No	boolean	default true	Amazon's deals feed mixes in promotional slots that carry no deal at all (no deal type, no price, no start/end window). Leave this on to keep them out of your dataset; turn it off to see the raw feed exactly as Amazon returns it.
trackChangesBetweenRuns	No	boolean	default true	Saves a snapshot of every deal collected to a named key-value store and compares the next run against it, filling in isNewSinceLastRun, endedSinceLastRun, and priceChangeSinceLastRun. The first run has no baseline, so those columns come back null with isFirstRun: true — never a fabricated "new".
trackingStoreName	No	string (editor: textfield)	default "amazon-deal-tracker"	Name of the Apify key-value store that holds the previous run's snapshot. Use different names to track several independent deal watchlists side by side (for example, electronics-deal-watch).
includeDisappearedDeals	No	boolean	default true	Adds one extra row per deal that was in your previous run but is missing from this one, marked rowType: "disappeared". Each carries a disappearedReason of EXPIRED (its end time has passed) or ROTATED_OUT_STILL_LIVE (it dropped out of Amazon's ranked window but hasn't expired).
onlyNewDeals	No	boolean	default false	Keeps only rows where isNewSinceLastRun is true, so a scheduled run emits nothing but fresh arrivals. In practice this depends on a completed comparison against a previous run: on a run with no usable baseline (the very first run for a given trackingStoreName, a scope change, or tracking disabled), isNewSinceLastRun is null rather than true for every row, so the run pushes zero rows to the dataset.
proxyConfiguration	No	object (editor: proxy)	default { "useApifyProxy": false }	Route requests through Apify Proxy. Not required to run the Actor — it works directly against Amazon's public deals feed by default. Enable it only if you see block responses in the run log.

None of the fields above hold a secret value — the Actor doesn't accept an Amazon login, API key, or password of any kind. It reads only what a logged-out visitor to amazon.com/deals can see.

Common pitfall: onlyNewDeals: true combined with a fresh trackingStoreName (or trackChangesBetweenRuns: false) will return an empty dataset, not "all deals" — there's no baseline yet for anything to be "new" against. Run once with onlyNewDeals off to seed the tracking store, then turn it on for subsequent scheduled runs.

Example input

{
  "maxDeals": 300,
  "endsWithinHours": 48,
  "startedWithinHours": 0,
  "excludeNonDealRows": true,
  "trackChangesBetweenRuns": true,
  "trackingStoreName": "electronics-deal-watch",
  "includeDisappearedDeals": true,
  "onlyNewDeals": false,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}

⬆️ Output

Every row is typed, normalized JSON with the same schema across runs — countdown fields are null, never 0, when Amazon doesn't supply a usable timestamp. Charging is per pushed row under the row_result event: rows removed by excludeNonDealRows, endsWithinHours, or startedWithinHours are filtered out before push_data is called and are never pushed or charged. Export results as JSON, JSONL, CSV, Excel, XML, or RSS from the Dataset tab, or pull them with the Apify API.

Scraped results

[
  {
    "asin": "B0EXAMPLE1",
    "title": "Example Wireless Noise-Cancelling Headphones, Over-Ear, Bluetooth 5.3",
    "rowType": "active",
    "dealPhase": "FINAL_HOURS",
    "hoursRemaining": 3.25,
    "endsToday": true,
    "dealEndTime": "2026-07-25T23:00:00+00:00",
    "dealStartTime": "2026-07-18T08:00:00+00:00",
    "hoursSinceStart": 175.75,
    "dealDurationHours": 179.0,
    "dealElapsedPercent": 98.2,
    "isNewSinceLastRun": false,
    "endedSinceLastRun": false,
    "disappearedReason": null,
    "previousPriceToPay": 84.99,
    "priceChangeSinceLastRun": -5.0,
    "dealIdChanged": false,
    "diffStatus": "COMPARED",
    "isFirstRun": false,
    "priceToPay": 79.99,
    "basisPrice": 129.99,
    "savingsAmount": 50.0,
    "savingsPercentageValue": 38,
    "currency": "USD",
    "dealType": "BEST_DEAL",
    "dealId": "a1b2c3d4e5",
    "dealState": "AVAILABLE",
    "isRealDeal": true,
    "link": "https://www.amazon.com/dp/B0EXAMPLE1",
    "image": "https://m.media-amazon.com/images/I/71exampleAB.jpg",
    "scrapedAt": "2026-07-25T19:45:00.123456+00:00"
  },
  {
    "asin": "B0EXAMPLE2",
    "title": "Example Stainless Steel French Press Coffee Maker, 34oz",
    "rowType": "active",
    "dealPhase": "JUST_STARTED",
    "hoursRemaining": 118.5,
    "endsToday": false,
    "dealEndTime": "2026-07-30T18:00:00+00:00",
    "dealStartTime": "2026-07-25T14:00:00+00:00",
    "hoursSinceStart": 5.75,
    "dealDurationHours": 124.0,
    "dealElapsedPercent": 4.6,
    "isNewSinceLastRun": true,
    "endedSinceLastRun": false,
    "disappearedReason": null,
    "previousPriceToPay": null,
    "priceChangeSinceLastRun": null,
    "dealIdChanged": null,
    "diffStatus": "COMPARED",
    "isFirstRun": false,
    "priceToPay": 29.99,
    "basisPrice": 44.99,
    "savingsAmount": 15.0,
    "savingsPercentageValue": 33,
    "currency": "USD",
    "dealType": "LIGHTNING_DEAL",
    "dealId": "f6g7h8i9j0",
    "dealState": "AVAILABLE",
    "isRealDeal": true,
    "link": "https://www.amazon.com/dp/B0EXAMPLE2",
    "image": "https://m.media-amazon.com/images/I/61exampleCD.jpg",
    "scrapedAt": "2026-07-25T19:45:00.123456+00:00"
  },
  {
    "asin": "B0EXAMPLE3",
    "title": "Example Adjustable Standing Desk Converter, 28-inch",
    "rowType": "disappeared",
    "dealPhase": "ENDED",
    "hoursRemaining": null,
    "endsToday": null,
    "dealEndTime": "2026-07-24T20:00:00+00:00",
    "dealStartTime": "2026-07-15T08:00:00+00:00",
    "hoursSinceStart": null,
    "dealDurationHours": null,
    "dealElapsedPercent": null,
    "isNewSinceLastRun": false,
    "endedSinceLastRun": true,
    "disappearedReason": "EXPIRED",
    "previousPriceToPay": 149.99,
    "priceChangeSinceLastRun": null,
    "dealIdChanged": null,
    "diffStatus": "COMPARED",
    "isFirstRun": false,
    "priceToPay": 149.99,
    "basisPrice": 219.99,
    "savingsAmount": 70.0,
    "savingsPercentageValue": 32,
    "currency": "USD",
    "dealType": "BEST_DEAL",
    "dealId": "k1l2m3n4o5",
    "dealState": "AVAILABLE",
    "isRealDeal": true,
    "link": "https://www.amazon.com/dp/B0EXAMPLE3",
    "image": "https://m.media-amazon.com/images/I/81exampleEF.jpg",
    "scrapedAt": "2026-07-25T19:45:00.123456+00:00"
  }
]

Every dataset row — active or disappeared — carries the same 31 keys shown above; there's no dataset-view subset hiding extra fields on this Actor. Fields that don't apply to a given row (for example, countdown fields on a disappeared row, or price-change fields on the very first run) come back null rather than being omitted.

How can you use the data extracted with this Actor?

• 🛍️ Deal hunters and content creators: filter to dealPhase: "FINAL_HOURS" or a low endsWithinHours to build a live "deals ending soon" feed for a blog, newsletter, or social post — sorted by savingsPercentageValue or hoursRemaining.
• 🤖 AI engineers and LLM developers: run the Actor on a schedule, feed the JSON output into a retrieval store or directly into an agent's context window, and let the model answer "what deals just dropped in the last 24 hours" grounded in isNewSinceLastRun and startedWithinHours rather than a stale training cutoff.
• 📊 Market researchers: track savingsPercentageValue, dealType, and dealDurationHours across a category over weeks to characterize how aggressively Amazon discounts a segment, and how long typical promotions run.
• 💰 Price-drop monitors: diff priceToPay against previousPriceToPay on every scheduled run and alert only when priceChangeSinceLastRun crosses a threshold you set, instead of re-scraping and comparing manually.

🔁 How do you monitor new and ending Amazon deals over time?

Deal monitoring here means running the Actor repeatedly against the same trackingStoreName and reading the delta each run reports, rather than eyeballing two dataset exports yourself. Each run persists a snapshot of every deal it collects (ASIN, price, deal identity, and window) to a named Apify key-value store, then diffs the next run's collection against it.

The fields to diff between runs are already computed for you: isNewSinceLastRun (true only when a run actually had a comparable baseline and the ASIN wasn't in it), endedSinceLastRun and disappearedReason (EXPIRED vs. ROTATED_OUT_STILL_LIVE) on the disappeared-deal rows, priceChangeSinceLastRun (the signed difference in priceToPay), and dealIdChanged (Amazon occasionally reissues a new dealId for what is functionally the same live deal — this flag surfaces that without treating it as a false "new" or "ended"). diffStatus tells you which comparison actually happened: COMPARED for a normal diff, FIRST_RUN when there was no baseline yet, SCOPE_CHANGED when your filter inputs changed between runs (the comparison resets rather than mixing incompatible scopes), or DISABLED when trackChangesBetweenRuns is off.

A typical workflow: schedule the Actor to run every few hours against a fixed trackingStoreName, with endsWithinHours set to your alert window. Each run reports which ASINs are isNewSinceLastRun: true (send those to a "new deal" alert) and which are endedSinceLastRun: true in the disappeared rows (send those to an "expired" log). Use an Apify Schedule to run it automatically, and a webhook or the Apify API to pull the latest dataset into your own alerting pipeline — the Actor itself doesn't send notifications, it produces the structured delta for you to act on.

Integrate Amazon Today's Deals Scraper and automate your workflow

Amazon Today's Deals Scraper works with any language or tool that can call the Apify API — there's no Amazon-side authentication to manage.

REST API with Python

from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")

run = client.actor("<YOUR_USERNAME>/amazon-todays-deals-scraper-deal-countdown-new-arrivals").call(
    run_input={
        "maxDeals": 200,
        "endsWithinHours": 24,
        "trackChangesBetweenRuns": True,
    }
)

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

Your Apify API token comes from your Apify account's Settings → Integrations page — it authenticates the platform call, not Amazon.

Scheduled monitoring and delivery

Use an Apify Schedule on the Actor to run it automatically on a recurring interval — keep trackingStoreName fixed across scheduled runs so the countdown and change-tracking fields stay comparable. Pull the latest dataset after each run via the Apify API, or connect an Apify webhook on run completion to push results into your own pipeline; the Actor itself doesn't call out to a third-party notification service.

⚖️ Is it legal to scrape Amazon's Today's Deals page?

Scraping publicly accessible web pages is generally lawful in the United States — courts including hiQ Labs, Inc. v. LinkedIn Corp. (9th Cir. 2019) have held that accessing data a website makes available to the public, without needing to log in, does not by itself violate the Computer Fraud and Abuse Act. This Actor extracts only what any visitor to amazon.com/deals can see without an account: product titles, prices, savings, and deal timing.

The data this Actor returns — product listings and promotional pricing — is business and catalog data, not personal data, so it does not fall under GDPR or CCPA. What applies instead is Amazon's own Terms of Service, which govern automated access to its site, and any database or intellectual-property rights Amazon holds in its catalog and pricing data. Scraping for internal monitoring or research carries a different risk profile than scraping to redistribute Amazon's catalog or to train a commercial model on it. Consult your legal team before using this data for commercial use cases involving bulk storage or redistribution.

❓ Frequently asked questions

Does this Actor support Amazon marketplaces outside the US?

No — every request goes to Amazon's US marketplace (marketplaces/ATVPDKIKX0DER), and pricing is pinned to USD via a currency-preference header regardless of what the raw API might otherwise return. There's no domain or marketplace input parameter. If you need amazon.co.uk, amazon.de, or another regional site, this Actor doesn't cover it.

Can I filter which deals I get by how soon they end or how recently they started?

Yes, with two independent, optional filters: endsWithinHours keeps only deals ending within that many hours (an "act now" shortlist), and startedWithinHours keeps only deals that went live within that many hours (a "just landed" shortlist). Both default to 0, which turns the corresponding filter off. Amazon's deal windows tend to run long — commonly 4 to 30 days — so a tight endsWithinHours value will typically return far fewer rows than the total feed.

How does this Actor handle Amazon's anti-bot measures?

It harvests a live CSRF token directly from the deals page HTML (with a fallback URL and up to 3 retries) before calling Amazon's promotions API, and validates every response by byte size rather than trusting a 200 status alone — a short response is treated as a block signature and retried with a short backoff. Apify Proxy is available as an opt-in proxyConfiguration input if you see block responses in the log, but the Actor runs without a proxy by default.

Does this Actor tell me which deals are new or about to expire?

Yes. dealPhase classifies every active deal into JUST_STARTED, FIRST_HALF, SECOND_HALF, FINAL_DAY, FINAL_HOURS, or ENDED based on its own start/end timestamps, and hoursRemaining / hoursSinceStart give the exact countdown. With trackChangesBetweenRuns on, isNewSinceLastRun flags deals that weren't in your previous run, and disappeared-deal rows carry disappearedReason: "EXPIRED" for deals whose window has actually closed.

How many deals does this Actor return per run?

Up to maxDeals, which defaults to 100 and is capped at 500 — Amazon's own promotions API reports a fixed totalCount of 500 for this window regardless of how many deals actually exist site-wide, so 500 is the practical ceiling for a single run, not an Actor-imposed limit.

What happens on the very first run, before there's anything to compare against?

With trackChangesBetweenRuns on, the first run for a given trackingStoreName has no previous snapshot, so diffStatus comes back FIRST_RUN, isFirstRun is true, and every change-tracking field (isNewSinceLastRun, endedSinceLastRun, priceChangeSinceLastRun, dealIdChanged) comes back null rather than a guessed value. If onlyNewDeals is also true on that same first run, the dataset will be empty — there's no baseline for anything to be flagged "new" against. Run once with onlyNewDeals off first to seed the store.

How do I use this Actor to monitor new and expiring deals over time?

Run it on a schedule against a fixed trackingStoreName using an Apify Schedule. Each run compares itself to the last and reports the fields covered above — filter your downstream pipeline on isNewSinceLastRun: true for arrivals and endedSinceLastRun: true (in the disappeared rows) for expirations.

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

It's callable as a standard HTTP endpoint through the Apify API, which means any agent framework that can make an HTTP request can call it, read back structured JSON, and ground its answer in the current deals feed rather than a stale training cutoff. There's no dedicated MCP server for this Actor at this time.

How does this compare to other Amazon deals scrapers?

The top-ranked competing listing on the Apify Store, piotrv1001/amazon-todays-deals-scraper (checked 2026-07-25), documents a required domain input covering 13 regional Amazon sites and a limit parameter up to 10,000 — broader marketplace coverage than this Actor, which is US-only. Two other listings that rank for the same search, api-empire/amazon-todays-deals-scraper and scraper-engine/amazon-todays-deals-scraper (both checked 2026-07-25), document a startUrls input and a maxItems default of 500, and list ratings/reviews and category as extractable data types in their feature tables, though neither shows those fields in their own published sample output. Across all three, the sample output shown stops at product identity, price, savings, and the raw dealStartTime/dealEndTime strings — none document a computed countdown, deal-phase classification, or run-over-run new/ended/price-change tracking, which is the capability this Actor is built around.

Can I use this Actor without managing proxies or Amazon credentials?

Yes. It requires no Amazon login, API key, or credential of any kind — it reads the same public deals page any visitor sees. Apify Proxy is available as an optional input if Amazon starts returning block responses in your run log, but it isn't required to get results.

💬 Your feedback

Found a bug, a field that doesn't match what Amazon actually returns, or a marketplace you'd like supported? Let Scrapier know through the Issues tab on this Actor's Apify Store page, or via the Actor Issues button on the run console — reports get triaged directly against this scraper's source.