Cyber Monday Price Tracker: Hourly Checks for Nov 30

Cyber Monday 2026 is Monday, November 30. To track its prices, check your product list every hour from Sunday evening (in 2025, Walmart+ members got Cyber Monday deals from 7 p.m. ET on Sunday) until Tuesday morning, with monitor mode on so each run reports only what changed. Then compare each item's Cyber Monday low with its Black Friday price. Hourly checks cost about three times as much as checks every three hours.

This guide covers what's different about Cyber Monday, a schedule and its cost worked out from the actor's price table, and two scripts: one compares Black Friday with Cyber Monday for the same items, the other lists every change by hour. The setup (watchlist, input, export) is in the Black Friday price tracker guide; this page assumes it.

What's different about Cyber Monday

Cyber Monday is an online event, and in 2025 it was the biggest one. Adobe Analytics reported $14.25 billion of US online spending on Cyber Monday 2025, up 7.1% on 2024, and called it "the biggest online shopping day of all time". It counts Cyber Week as the five days from Thanksgiving to Cyber Monday, which brought in $44.2 billion online (Adobe, Dec 2, 2025).

Things from 2025 that matter for a tracker:

None of the 2026 dates or hours are announced yet. Treat the table as last year's pattern and update your schedule when retailers publish theirs.

Member-only prices are a blind spot: the tracker sees what a signed-out shopper sees, so Walmart+ early-access or Prime-exclusive prices may not show up until they're open to everyone.

Hourly or every three hours: the cost

Using an Apify schedule with the timezone set to America/New_York, the Sunday 6 p.m. to Tuesday 6 a.m. window is three cron entries:

Both were checked with a cron parser in that timezone. Make them extra schedules on the same task as your daily check, and keep the hours from colliding with it.

The actor is pay per event. With monitorMode and onlyChanges on, every run pays the start fee, and each product pays either "product scraped" (new or changed, written) or "product checked" (unchanged, not written). For datacenter sites (Amazon US, Walmart, Target, Shopify stores) there's no traffic fee. From the README's price table:

For a 150-product list, one run costs between "nothing changed" and "everything changed":

• FREE: $0.005 + 150 × $0.0012 = $0.185 up to $0.005 + 150 × $0.0048 = $0.725
• GOLD: $0.005 + 150 × $0.0002 = $0.035 up to $0.005 + 150 × $0.0008 = $0.125

Over the window:

The 10% column is an illustration (15 changed products at $0.0008, 135 unchanged at $0.0002, plus the start fee), not a measured rate. Sites that need residential proxies or a browser, such as amazon.co.uk or Wayfair, add a per-MB or per-render fee on top.

Two practical limits. First, a run has to finish before the next one starts, or two runs compare against the same baseline. Small lists finish in under a minute on datacenter sites (our three-product runs took about 25 seconds), but the README measures about 30–40 Shopify products a minute at 1 GB, so a list of 1,000 needs half an hour. Second, set a maximum cost per run in the run options, so a bad hour can't run up the bill.

A middle path many people will prefer: hourly on Sunday evening and Monday, every three hours overnight.

Black Friday vs Cyber Monday for the same item

onlyChanges is right for alerts but wrong for a side-by-side comparison, because unchanged products aren't written. For the comparison, run the same list once more with monitor mode off on Black Friday evening and again on Cyber Monday evening, in a second task, so every product is written both times. With monitor mode off, the second task doesn't touch the first task's change tracking.

This script joins two runs by product URL:

import os
import sys
from apify_client import ApifyClient

client = ApifyClient(os.environ["APIFY_TOKEN"])

def prices(run_id):
    """url -> (price, currency, scrapedAt) for every product row of one run."""
    ds = client.run(run_id).dataset()
    return {r["url"]: (r["price"], r["currency"], r["scrapedAt"])
            for r in ds.iterate_items() if r.get("recordType") == "product" and r.get("price")}

bf, cm = prices(sys.argv[1]), prices(sys.argv[2])   # Black Friday run, Cyber Monday run
for url in sorted(bf.keys() & cm.keys()):
    (p1, c1, t1), (p2, c2, t2) = bf[url], cm[url]
    if c1 != c2:
        print(f"{url}: currency changed {c1} -> {c2}, not comparable")
        continue
    diff = p2 - p1
    better = "Cyber Monday" if diff < 0 else "Black Friday" if diff > 0 else "same"
    print(f"{p1:>8.2f} ({t1[:10]})  {p2:>8.2f} ({t2[:10]})  {diff:+7.2f} {c1}  cheaper: {better:<12} {url}")
print(f"{len(bf.keys() & cm.keys())} products in both runs; "
      f"{len(bf.keys() - cm.keys())} only in the first, {len(cm.keys() - bf.keys())} only in the second")

Usage: python bf_vs_cm.py <black-friday-run-id> <cyber-monday-run-id>. There's no Black Friday 2026 data yet, so here it is on two real October runs. The first was a 15-product keyword search on 2026-10-18; the second, a three-product watchlist on 2026-10-20. One Amazon product was in both:

   29.49 (2026-10-18)     29.99 (2026-10-20)    +0.50 USD  cheaper: Black Friday https://www.amazon.com/dp/B07CMS5Q6P
1 products in both runs; 14 only in the first, 2 only in the second

The "only in" counts are your check that the two runs cover the same list. On matching lists they should both be 0, as they were when we compared two days of our daily test task (three products, all unchanged).

Every change, hour by hour

To see when a price moved during Cyber Monday, use the history export from the tracker guide (price_history.csv, change rows only) and list the changes in Eastern time:

import csv
import sys
from datetime import datetime
from zoneinfo import ZoneInfo   # Windows: pip install tzdata

ET = ZoneInfo("America/New_York")
WINDOW = (datetime(2026, 11, 29, 18, tzinfo=ET), datetime(2026, 12, 2, 6, tzinfo=ET))

for r in sorted(csv.DictReader(open(sys.argv[1], encoding="utf-8")), key=lambda r: r["scrapedAt"]):
    t = datetime.fromisoformat(r["scrapedAt"].replace("Z", "+00:00")).astimezone(ET)
    if not (WINDOW[0] <= t < WINDOW[1]) or r["changeType"] in ("new", "unchanged"):
        continue
    print(f"{t:%a %H:%M} ET  {r['changeType']:<14}{r['previousPrice'] or '':>8} -> {r['price']:<8} "
          f"in stock: {r['inStock']:<6} {r['name']}")

On a made-up five-row history (invented products and prices, real column format) it prints:

Sun 19:05 ET  price-down       79.00 -> 69.00    in stock: True   Air Fryer
Mon 00:02 ET  price-down      149.99 -> 129.99   in stock: True   Earbuds
Mon 12:01 ET  out-of-stock    129.99 -> 129.99   in stock: False  Earbuds
Tue 00:03 ET  back-in-stock   129.99 -> 149.99   in stock: True   Earbuds
Tue 03:04 ET  price-up         69.00 -> 79.00    in stock: True   Air Fryer

scrapedAt is UTC, so convert before you read "Monday". Each row gets one changeType, and stock changes win over price changes: the Tuesday Earbuds row is both back in stock and $20 dearer, and it's labelled back-in-stock. Read previousPrice and price (or the changes[] array in the raw dataset) to see both.

After Cyber Monday

Leave the daily check running for a week. If a product's price goes back up on Tuesday or Wednesday, its Cyber Monday price was a real low. If it doesn't, the "deal" was the new normal. The Thanksgiving to Cyber Monday price timeline has a script that finds the day each product hit its season low, and the fake discounts guide compares the sale price with the pre-season median. To get changes as messages instead of CSVs, see price drop alerts by email and Slack. For the rest of the retail year, the holiday sales calendar lists each event, and the free e-commerce price tracker page builds the input.

Disclosure: I built the actor and this site. The schedule and the scripts work with any scraper that writes these columns.

Sources: Adobe: Cyber Monday hits record $14.25 billion (Dec 2, 2025), Walmart 2025 Black Friday Deals events, Target press release, Nov 20, 2025, Amazon: When is Black Friday 2025, Apify docs: Schedules.