Black Friday Price Tracker: Watch 2026 Prices Daily

A Black Friday price tracker is a list of product URLs that a scraper checks on a schedule, saving every price it sees. For Black Friday 2026 (Friday, November 27), start the daily baseline by late October, check more often from mid-November, and every few hours from Thanksgiving to Cyber Monday (November 30). Turn on monitor mode so each run flags price-down, price-up and stock changes.

This guide builds that tracker for the US retailers people watch most, with real input and output from runs on 2026-10-20. It uses E-commerce Product Scraper Pro, an Apify actor I built, but the plan (what to watch, when to start, how often to check) applies to any tool.

Which US retailers you can track

The actor's README has a supported-sites matrix. For a US Black Friday watchlist, it comes down to this:

The big three are all datacenter sites, so a run pays only the start fee and the per-product events. For stores in the unsupported row, the Google Shopping price comparison guide shows how to see their prices through Google Shopping instead.

Step 1: build the watchlist

Use product page URLs, not search pages. A search page returns whatever ranks that day, so you can't compare day to day. The short, stable URL forms work best:

• Amazon: https://www.amazon.com/dp/<ASIN>
• Walmart: https://www.walmart.com/ip/<slug>/<item id>
• Target: https://www.target.com/p/<slug>/-/A-<TCIN>

Pick the exact model you'd buy. If you want "a 65-inch TV", pick three or four specific models across retailers rather than a category page.

Decide the list before you start, and don't edit it mid-season. Monitor mode stores its comparison state under the exact set of input URLs (and proxy country). Change one URL and the next run starts a fresh baseline in which every product is new. If you need to add products later, put them in a second task.

Step 2: the input

{
  "detailsUrls": [
    { "url": "https://www.amazon.com/dp/B07CMS5Q6P" },
    { "url": "https://www.walmart.com/ip/LEGO-Classic-Medium-Creative-Brick-Box/41004055" },
    { "url": "https://www.target.com/p/lego-star-wars-advent-calendar-2026-75456/-/A-95046358" }
  ],
  "monitorMode": true,
  "onlyChanges": true,
  "maxProductResults": 50
}

• monitorMode compares every product with the previous run of this list and sets changeType to new, price-down, price-up, back-in-stock, out-of-stock, changed or unchanged, with previousPrice, priceChange and priceChangePct.
• onlyChanges writes only new or changed products. Unchanged ones aren't written and are billed at the lower "product checked" price instead of "product scraped".
• maxProductResults is a safety cap. In monitor mode it counts every product checked, unchanged ones included, so set it above your list size.

If you'd rather fill in a form, the free e-commerce price tracker page builds this input for you and shows a fixed example of the output (not live prices).

Step 3: run it once and read the result

This script starts a run, prints what changed, and lists any input that didn't deliver:

import os
from apify_client import ApifyClient

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

watchlist = [
    "https://www.amazon.com/dp/B07CMS5Q6P",
    "https://www.walmart.com/ip/LEGO-Classic-Medium-Creative-Brick-Box/41004055",
    "https://www.target.com/p/lego-star-wars-advent-calendar-2026-75456/-/A-95046358",
]

run = client.actor("constructive_calm/ecommerce-product-scraper-pro").call(run_input={
    "detailsUrls": [{"url": u} for u in watchlist],
    "monitorMode": True,
    "onlyChanges": True,
    "maxProductResults": 50,
})

# 1. Products that are new or changed since the previous run of this exact list
for row in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(f'{row["changeType"]:<14}{row["site"]:<11}{row["price"]:>8} {row["currency"]}  '
          f'was={row["originalPrice"]}  previous={row["previousPrice"]}  {row["name"][:40]}')

# 2. Inputs that did not deliver (delisted, blocked, unsupported): one status row each
status_id = run["storageIds"]["datasets"]["status"]
for s in client.dataset(status_id).iterate_items():
    if s["outcome"] != "ok":
        print("CHECK", s["outcome"], s["errorDescription"], s["inputUrl"])

summary = client.key_value_store(run["defaultKeyValueStoreId"]).get_record("OUTPUT")["value"]
print(summary["statusMessage"])

The first run of a list is the baseline, so every product is new. Output from 2026-10-20, with one extra Target URL added to show what a delisted product looks like:

new           target        30.99 USD  was=44.99  previous=None  LEGO Star Wars Advent Calendar 2026 7545
new           walmart-us    21.42 USD  was=34.99  previous=None  LEGO Classic Medium Creative Brick Box ,
new           amazon-us     29.99 USD  was=49.99  previous=None  Logitech G305 Lightspeed Wireless Gaming
CHECK not-found The page does not exist (http-404). https://www.target.com/p/apple-airpods-pro-2nd-generation/-/A-85978612
3/4 product(s) delivered, 1 failed. Per-input details: Status dataset / OUTPUT record.

Run the three-product list again and nothing is printed except 0/3 product(s) delivered, 3 unchanged (not output). The run was billed one start event and three "product checked" events.

Two fields matter most for Black Friday. price is the price the page shows, as a number. originalPrice is the "was" price, only when the page shows one higher than price. It's the retailer's claim, not a price history, so don't read was=49.99 as proof the item ever sold at $49.99. That check is what the baseline is for, and the fake Black Friday discounts guide does it with code.

Step 4: schedule the season

Save the input as a task in the Apify Console, then add schedules. Apify schedules take cron expressions and a timezone, and daylight-saving shifts are handled. With the timezone set to America/New_York:

The run counts were checked with a cron parser in that timezone. The hours never collide, which matters: two runs of the same list at the same minute would both compare against the same previous run. Delete the schedules after December 7, or they'll keep running.

2026 deal dates aren't announced yet. In 2025, Walmart published its Black Friday event dates on October 27, so expect announcements from late October and adjust the middle row when they arrive. The Thanksgiving to Cyber Monday timeline covers what happened on each day in 2025.

What it costs

The actor is pay per event, priced by Apify plan tier. From the README's table, for datacenter sites like these three:

Each run costs the start fee plus one event per product. The cheapest run is one where nothing changed, and the dearest is one where everything did. The real cost is in between, usually near the low end, because most prices don't move on most days.

• 25 products, daily only (48 runs): FREE 48 × ($0.005 + 25 × $0.0012) = $1.68 up to 48 × ($0.005 + 25 × $0.0048) = $6.00. GOLD $0.48 to $1.20.
• 100 products, all three schedules (108 runs): FREE 108 × $0.125 = $13.50 up to 108 × $0.485 = $52.38. GOLD 108 × $0.025 = $2.70 up to 108 × $0.085 = $9.18.

Apify's free plan gives $5 of usage every month, no credit card required. The actor has no free trial of its own, so the platform credit is what covers a first test. Set a maximum cost per run in the run options and the actor stops below it.

Step 5: export the history

Each run has its own dataset, so the price history is spread over many runs. This script collects every product row from a task's successful runs into one CSV:

import csv
import os
import sys
from apify_client import ApifyClient

client = ApifyClient(os.environ["APIFY_TOKEN"])
TASK_ID = sys.argv[1]            # your saved task's ID or "username~task-name"
FIELDS = ["scrapedAt", "site", "url", "name", "price", "originalPrice",
          "currency", "inStock", "seller", "changeType", "previousPrice"]

runs = client.task(TASK_ID).runs().list(status="SUCCEEDED").items
with open("price_history.csv", "w", newline="", encoding="utf-8") as f:
    out = csv.DictWriter(f, fieldnames=FIELDS, extrasaction="ignore")
    out.writeheader()
    n = 0
    for run in runs:
        for row in client.dataset(run["defaultDatasetId"]).iterate_items():
            if row.get("recordType") == "product":
                out.writerow(row)
                n += 1
print(f"{len(runs)} runs, {n} product rows -> price_history.csv")

On our daily test task (three products, monitor mode off) it printed 5 runs, 15 product rows -> price_history.csv. With onlyChanges on, the CSV holds only new and changed rows. A product missing from a run means it was unchanged, so carry its last price forward when you analyse the file. The fake-discount and timeline guides both do this.

For alerts instead of a CSV, the price drop alerts guide connects the same task to email or Slack.

Things that will trip you up

• Delisted and blocked products. A Black Friday SKU can vanish or redirect. Read the Status dataset (step 3 does), not just the run status: a run can succeed with zero rows.
• Manual test runs count. Any run of the exact same URL list becomes the "previous run" for the next one, including a test you start by hand.
• Member and in-store prices. The actor sees what a signed-out shopper sees online. Prime-exclusive, Walmart+ early-access and Target Circle prices may not be in price, and in-store prices can differ.
• Multi-packs and variants. Compare unitPrice when a listing switches pack size, and check variants[] when the colour you want is priced differently from the default.
• Lightning-style deals. A deal that lasts a few hours can fall between two 3-hourly runs. The Cyber Monday deal tracker guide works through hourly cadence and its cost.

For the whole retail calendar beyond Black Friday week, see the holiday sales calendar and price tracking guide.

Disclosure: I built the actor and this site. The plan above (watchlist, early baseline, schedule) works with any scraper or a spreadsheet.

Sources: E-commerce Product Scraper Pro README (supported sites, pricing table), Apify docs: Schedules, Walmart 2025 Black Friday Deals events announcement, Amazon: When is Black Friday 2025.