Cyber Monday Price Tracker: Schedule, Costs & Scripts

A schedule that covers the important window

If you need frequent checks, schedule runs from 6 p.m. Eastern on Sunday, November 29, through 5 a.m. Eastern on Tuesday, December 1. That's 36 hourly runs. If you want a cheaper baseline, the same window at three-hour intervals gives you 12 runs.

The cron expressions below assume the scheduler uses America/New_York. They cover the same window, with the end time exclusive at 6 a.m. Tuesday.

Use these as additional schedules on the task that already does your regular checks. Just make sure the extra schedule doesn't overlap the daily run. If two jobs start close together, you'll end up with confusing results.

Choose cadence based on the decision you need to make

Hourly checks help when a short-lived price or stock change could change your decision. They're less useful if your only goal is the lowest observed price by the end of the event - then every three hours may be enough resolution at one-third the run count.

Often, a mix makes more sense than going all-in on one cadence. Check hourly on Sunday evening and during Monday's busier stretches, then switch to every three hours overnight. Whatever you choose, keep a daily check running for about a week afterward. Prices that jump on Tuesday or Wednesday might have been a temporary promo; prices that hold steady may be the retailer's new baseline.

One limitation to keep in mind: a tracker can only "see" what the session it uses can access. Member-only offers (like Walmart+ early access or Prime-exclusive pricing) may not show up to a signed-out shopper. If you're missing an offer, confirm whether your setup can access it before concluding that the deal never existed.

Estimate a 150-product watchlist

For 150 products, the lowest-cost case is that nothing changes. The upper bound assumes every product is written as changed on every run.

• FREE, unchanged: $0.005 + 150 × $0.0012 = $0.185 per run.
• FREE, all changed: $0.005 + 150 × $0.0048 = $0.725 per run.
• GOLD, unchanged: $0.005 + 150 × $0.0002 = $0.035 per run.
• GOLD, all changed: $0.005 + 150 × $0.0008 = $0.125 per run.

Now multiply by the scheduled run count for the full event window:

The 10% figure is just an illustration. It assumes 15 changed products at $0.0008, 135 unchanged at $0.0002, plus the $0.005 start fee, for $0.044 per run. Your real spend will vary based on product behavior and site response.

Account for runtime and variable fees

Hourly checks only work smoothly if a run finishes before the next one starts. If jobs overlap, you might compare against the same prior state or just get messy timing.

Small lists on datacenter sites can finish quickly. In one example, a three-product run took about 25 seconds. A larger list takes longer: the example README estimates roughly 30-40 Shopify products per minute at 1 GB, so 1,000 products could take around half an hour.

Some sites also add costs for residential proxies or browser rendering - often calculated per megabyte or per render. Keep those separate from the event-fee estimate above. Also set a maximum cost per run in your task options. That cap limits damage if there's a configuration mistake or an unexpected product count that makes one run more expensive than planned.

Compare snapshots by product URL

The script below joins product rows by URL, reports price differences, and flags currency changes. It assumes the run datasets contain recordType, url, price, currency, and scrapedAt fields. Install and configure the relevant client library and API token before running it.

import os
import sys
from apify_client import ApifyClient
client = ApifyClient(os.environ["APIFY_TOKEN"])
def prices(run_id):
"""Return url -> (price, currency, scrapedAt) for product rows."""
dataset = client.run(run_id).dataset()
return {
row["url"]: (row["price"], row["currency"], row["scrapedAt"])
for row in dataset.iterate_items()
if row.get("recordType") == "product"
and row.get("price") is not None
}
black_friday = prices(sys.argv[1])
cyber_monday = prices(sys.argv[2])
matched = black_friday.keys() & cyber_monday.keys()
for url in sorted(matched):
old_price, old_currency, old_time = black_friday[url]
new_price, new_currency, new_time = cyber_monday[url]
if old_currency != new_currency:
print(f"{url}: currency changed; not comparable")
continue
difference = new_price - old_price
cheaper = (
"Cyber Monday" if difference < 0
else "Black Friday" if difference > 0
else "same"
)
print(
f"{old_price:>8.2f} ({old_time[:10]})  "
f"{new_price:>8.2f} ({new_time[:10]})  "
f"{difference:+7.2f} {old_currency}  "
f"cheaper: {cheaper:<12} {url}"
)
print(
f"{len(matched)} products in both runs; "
f"{len(black_friday.keys() - cyber_monday.keys())} only in the first, "
f"{len(cyber_monday.keys() - black_friday.keys())} only in the second"
)

Run it with the Black Friday run ID first, and the Cyber Monday run ID second. The matched and unmatched counts are a basic quality check. If you meant to compare an identical list, the "only in" counts should usually be zero. If not, investigate missing products before concluding anything.

Also, a lower listed price isn't always the better deal. Check whether shipping, membership requirements, stock status, or product variants differ between snapshots. This script compares the recorded price and currency; it doesn't calculate a delivered total or confirm that two listings represent identical bundles.

Print changes in Eastern time

This example filters the Cyber Monday window and skips new or unchanged rows. It expects CSV columns like changeType, previousPrice, price, inStock, and name.

import csv
import sys
from datetime import datetime
from zoneinfo import ZoneInfo
ET = ZoneInfo("America/New_York")
start = datetime(2026, 11, 29, 18, tzinfo=ET)
end = datetime(2026, 12, 2, 6, tzinfo=ET)
with open(sys.argv[1], encoding="utf-8", newline="") as file:
rows = sorted(
csv.DictReader(file),
key=lambda row: row["scrapedAt"]
)
for row in rows:
timestamp = datetime.fromisoformat(
row["scrapedAt"].replace("Z", "+00:00")
).astimezone(ET)
if not start <= timestamp < end:
continue
if row["changeType"] in ("new", "unchanged"):
continue
print(
f"{timestamp:%a %H:%M} ET  "
f"{row['changeType']:<14} "
f"{row['previousPrice'] or '':>8} -> "
f"{row['price']:<8} "
f"in stock: {row['inStock']:<6} {row['name']}"
)

Each history row may have one main changeType. In some trackers, stock changes can override price changes. A product might return to stock at the same time its price rises, yet the row may be labeled back-in-stock. If you see that, check both previousPrice and price, or look at the raw changes array if you have it. Don't assume the label captures everything that moved.

Keep monitoring after the sale

Leave the regular daily check running for about a week. If the price climbs back to an earlier level soon after Cyber Monday, that suggests the event price was temporary. If it stays lower, the promo may have reset the product's baseline for a while. Neither pattern proves what happens next season, but this follow-up gives you better context than a single sale-day snapshot.