How to Track Grocery Inflation with a Fixed Basket of Staples

Start here

Ten staples, three chains, one location. Paste this into the Canadian Grocery Price Comparison API and hit Start.

{
  "queries": ["eggs", "milk", "bread", "butter", "chicken breast",
              "ground beef", "rice", "bananas", "onions", "canned tomatoes"],
  "location": "Vancouver, BC",
  "retailers": ["loblaws", "saveonfoods", "tnt"],
  "includeSummaries": true,
  "minMatchConfidence": "high"
}

includeSummaries adds a basket_summary record carrying totals_by_retailer and cheapest_retailer, so the basket total per chain is computed for you. minMatchConfidence: "high" matters more here than in a one-off comparison, for reasons I get to below.

Then schedule it. In the Apify console: the Actor’s Schedules tab, weekly.

The basket

Every item earns its place three ways. It’s a staple people actually buy, it’s stocked at every chain you’re pricing, and it has a package size the matcher can normalize into a unit price.

Turning runs into history

The Actor returns current prices and stores nothing between runs, so your history starts the day you schedule it. There’s no backfill. Each run also writes its own dataset, which means building a series is a matter of listing past runs and reading each one:

import pandas as pd
from apify_client import ApifyClient

client = ApifyClient("YOUR_API_TOKEN")
ACTOR = "sunny_eternity/canada-grocery-price-comparison"

rows = []
for run in client.actor(ACTOR).runs().list(limit=52, desc=True).items:
    if run["status"] != "SUCCEEDED":
        continue
    for item in client.dataset(run["defaultDatasetId"]).iterate_items():
        if item.get("_type") != "comparison":
            continue
        rows.append({
            "date": run["startedAt"].date(),
            "query": item["query"],
            "retailer": item["retailer"],
            "price": item["price"],
            "unit_price": item["comparable_unit_price"],
            "product_id": item["product_id"],
        })

df = pd.DataFrame(rows)

Skipping runs that didn’t reach SUCCEEDED keeps a half-finished scrape out of the series. Pin schema_version too if you’re storing this long term.

Building the index

Two numbers worth having. What the basket costs, in dollars, and that cost indexed to your first week.

# Cheapest match per item per date, at one retailer.
wide = (df[df.retailer == "loblaws"]
        .pivot_table(index="date", columns="query", values="price", aggfunc="min")
        .dropna()          # a date counts only if every item matched
        .sort_index())

cost = wide.sum(axis=1)
index = 100 * cost / cost.iloc[0]

print(pd.DataFrame({"basket_cost": cost.round(2), "index": index.round(1)}))

That dropna() is doing real work. If one item fails to match in a given week, the basket total for that week is a smaller basket, and it’ll read as deflation you didn’t have. Dropping the incomplete week is the honest fix.

Catching shrinkflation

Here’s the part most home-built trackers miss. When a 1 L carton becomes 900 ml at the same sticker, price reports no change at all, while you’re paying about 11% more for what’s inside. comparable_unit_price is what catches it, since it normalizes to the basis named in comparable_unit_basis.

Run the same index on both fields and the gap between them is your signal:

def relatives(col):
    """Average of per-item price relatives, base 100.

    Summed totals work for price but not for unit price, since that would add
    $/100g to $/100ml. Per-item changes averaged together avoids that.
    """
    w = (df[df.retailer == "loblaws"]
         .pivot_table(index="date", columns="query", values=col, aggfunc="min")
         .dropna()
         .sort_index())
    return 100 * (w / w.iloc[0]).mean(axis=1)

gap = pd.DataFrame({"sticker": relatives("price"), "unit": relatives("unit_price")})
gap["shrinkflation"] = (gap["unit"] - gap["sticker"]).round(2)
print(gap.round(1))

A shrinkflation column that drifts upward means packages are getting smaller faster than prices are rising. Canned tomatoes and butter are usually where it shows first.

Matching drift

The other thing that quietly corrupts one of these series. The Actor compares retailer search results, so the product that wins a query can change between runs. A store brand outranks a national brand one week, and your series records a 30% price drop that is really a different product.

# Items where the matched product changed at least once.
drift = df.groupby(["retailer", "query"])["product_id"].nunique()
print(drift[drift > 1].sort_values(ascending=False))

Anything in that list needs looking at before you trust its trend. Two defences: keep minMatchConfidence at high, and make your queries specific enough to have one obvious answer. "butter" is a loose query, "salted butter 454g" is a tight one.

Against the official number

Statistics Canada publishes a Consumer Price Index monthly, with a food component, and it’s the number the news reports. Yours will disagree with it, and that’s expected rather than a bug.

• Different scope. StatCan builds a national statistical sample with weighting and adjustments behind it. Yours is ten items at three named chains in one city.
• Different timing. Theirs is monthly and lands after the month it covers. Yours is weekly and current.
• Different purpose. Use yours to see movement early and at the store level. It isn’t evidence about the official series, and I wouldn’t present it as such.

Where a small basket genuinely beats the national number is specificity. It can tell you that butter at one chain in your city moved 8% this month, which no national aggregate will. To widen it, the comparison API guide covers the other thirteen chains, and the Loblaws guide covers scraping whole departments instead of a fixed list.