# US Grocery Prices: Kroger, Safeway, Publix, H-E-B & More (`vant47/us-grocery-prices-scraper`) Actor

Compare US grocery prices by store across Kroger banners, Safeway, Albertsons, Publix, H-E-B and Whole Foods. Shelf, catalog and delivery prices, dated deals, unit prices and stock. $0.004 per product: 50 cost $0.20 plus $0.02 start. No login. Public data.

- **URL**: https://apify.com/vant47/us-grocery-prices-scraper.md
- **Developed by:** [fortbrand](https://apify.com/vant47) (community)
- **Categories:** E-commerce, Automation
- **Features:** Limited permissions
- **Stats:** 1 total users, 1 monthly users, 72.7% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.20 / 1,000 products

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## US Grocery Prices: Kroger, Safeway, Publix, H-E-B & More

For grocery price analysts monitoring several US retailers. Collect store-specific product prices, advertised promotions, membership prices, unit prices and availability where each public source supplies them. **$0.004 per qualifying product**, so **50 products cost $0.20 plus a $0.02 start charge** at base pricing. No retailer login is needed.

Rows identify their retailer, store, source, observation time and price scope.

### What you get

Overlapping inputs at one store are deduplicated.

| Field | Meaning |
| --- | --- |
| `verdict` | Readable product, price, store and availability summary. |
| `retailer`, `bundleRetailer` | Display name and stable selected retailer/banner key. |
| `country`, `currency` | US and USD. |
| `storeId`, `storeName`, `location` | Source store identity, name and requested ZIP when a ZIP was used. |
| `productId`, `sku` | Retailer product and supplier identifiers; preserve them as text. |
| `gtin`, `upc` | Source-labelled barcode only when its format and check digit are valid. Leading zeros remain intact. |
| `title`, `brand`, `size` | Source product name, explicit brand and package size. |
| `price`, `regularPrice`, `onSale` | Current numeric amount, regular amount and source sale status. |
| `promoText`, `promoType` | Sale, coupon, BOGO or other published offer wording and type. |
| `promoStart`, `promoEnd` | Promotion dates supplied or supported by the source. |
| `memberPrice`, `memberProgram` | Explicit membership amount and program label, such as Prime or Club Card. |
| `unitPrice`, `unitOfMeasure` | Source unit amount and unit; Whole Foods computed amounts are marked. |
| `inStock`, `stockLevel` | Public availability and inventory signals, when supplied. |
| `rating`, `reviewCount`, `category` | Optional source review and taxonomy data. |
| `url`, `imageUrl`, `sourceUrl` | Product page, image and public collection endpoint. |
| `scrapedAt`, `priceScope` | Observation timestamp and the price context. |
| `searchTerm`, `sourceType`, `sourceInput` | Discovery term or source that first produced the observation. |
| `recordType` | PRODUCT, a free NOTE, or the final SUMMARY. |

Unknown values are null. Invalid barcodes and Safeway UPC lookup codes stay in separate source fields, with GTIN/UPC null. Extras include store addresses, aisles, coupon conditions, weight information and optional details.

The dataset has overview, deals and comparison views. The separate **COMPARISON JSON output is sorted by search term, then numeric price from cheapest upward**. It contains priced rows only.

COMPARISON groups observations for inspection; it does not assert that every result for a broad term is the same product. Compare equivalent sizes, units and brands, or use a shared source-backed barcode. A small package can have the lowest sticker price and a higher unit price.

### Retailers and price meaning

| Selection | Public collection scope |
| --- | --- |
| `kroger` | Selected-store pickup catalog, or public in-store catalog where pickup is unavailable. |
| `ralphs`, `frys`, `kingsoopers`, `fredmeyer` | Their own Kroger-family banner sites and verified stores. |
| `smiths`, `qfc`, `dillons`, `marianos`, `picknsave`, `harristeeter` | Additional supported Kroger-family banner selectors. |
| `safeway`, `albertsons` | Selected-store advertised catalog, Club Prices and linked coupon conditions. |
| `vons`, `jewelosco`, `acme`, `shaws`, `starmarket`, `tomthumb`, `randalls`, `pavilions`, `carrs` | Additional Albertsons-family banner selectors. |
| `publix` | Store-advertised prices and dated promotions, plus matched delivery prices with a separate delivery scope. |
| `heb` | Selected-store H-E-B ONLINE context in the website's in-store mode; curbside amounts remain separate. |
| `whole-foods` | Selected-store catalog prices, sales and explicit Prime amounts. |

A Club Price or Prime price can require membership. Coupon conditions can require clipping, a minimum quantity, another product or a particular fulfillment channel. Those conditions stay alongside the price. The Actor does not clip coupons or subtract hypothetical savings from a product amount.

Publix delivery matching requires the same physical store and a unique product title, brand and known equivalent package size. Ambiguous or unknown packages are not joined. Delivery prices can differ from shelf prices. `priceScope: "delivery"` identifies a primary delivery value; separate delivery evidence remains available when the primary amount is an advertised price.

### Start in three steps

1. Choose the retailers and enter search terms, category URLs or known products.
2. Choose common ZIPs, or set an exact store or ZIP for each retailer in `retailerInputs`.
3. Set the retailer and global product caps, run, then inspect SUMMARY before importing the dataset.

The form example searches milk across five retailers with ten products each. Its example ZIPs are chosen separately for each chain's operating area. They demonstrate coverage across retailers; they are not a local basket comparison in one neighborhood. Remove those per-retailer example ZIPs when supplying one common ZIP.

A cloud run on 15 November 2026 returned 50 unique observations, ten per retailer, with no source failures: 49 had numeric prices and the remaining observation had a dated promotion. Every qualifying row reconciled to one Product charge. Two 1,100-row cloud runs covered all five retailers without source failures; 2,159 of 2,200 rows had numeric prices.

### Inputs

| Input | Behavior |
| --- | --- |
| `retailers` | Defaults to kroger, safeway, publix, heb and whole-foods. Add a supported banner by its key. Unknown names produce free notes. |
| `searchTerms` | Terms such as milk, chicken or coffee, searched at each selected store. |
| `categoryUrls`, `startUrls` | Public category, product, search or deal URLs, routed to their selected retailer by domain. |
| `productIds` | Bare retailer IDs when one retailer is selected; prefix `retailer:ID` when selecting several. |
| `locations`, `postalCodes` | Common ZIPs. Nonempty locations takes precedence over postalCodes. No canonical ZIP default is injected. |
| `storeIds` | Exact stores override ZIPs. Prefix IDs with the retailer when several retailers are selected. |
| `retailerInputs` | Object keyed by retailer, overriding its terms, URLs, product IDs, store IDs or ZIP selections. |
| `maxItemsPerRetailer` | Total output cap per selected retailer/banner, default 10. |
| `maxItemsPerSearch` | Cap per source and store within a retailer, default 10. |
| `maxItems` | Global output cap, default 50. |
| `dealsOnly`, `includeDetails` | Deal filtering and slower optional metadata collection. |
| `includeUnpricedProducts` | Opt in to free catalog rows without a numeric price or dated promotion. Off by default. |
| `proxyConfiguration` | Automatic datacenter-first routing with US residential retries, or your explicit configuration. |

For a local comparison in Austin:

```json
{
  "retailers": ["heb", "whole-foods"],
  "searchTerms": ["coffee"],
  "postalCodes": ["78701"],
  "maxItemsPerSearch": 20,
  "maxItemsPerRetailer": 20,
  "maxItems": 40
}
```

For repeat monitoring of known products:

```json
{
  "retailers": ["safeway", "heb"],
  "productIds": ["safeway:136010121", "heb:314125"],
  "storeIds": ["safeway:3132", "heb:754"],
  "maxItemsPerRetailer": 1,
  "maxItems": 2
}
```

### Output example

One H-E-B observation from the five-retailer run on 15 November 2026:

```json
{
  "retailer": "H-E-B",
  "storeId": "768",
  "location": "78701",
  "productId": "690987",
  "title": "Central Market Organics 2% Reduced Fat Milk, 1/2 gal",
  "price": 3.97,
  "regularPrice": 3.97,
  "currency": "USD",
  "gtin": "041220189236",
  "scrapedAt": "2026-11-15T11:53:48.483Z"
}
```

### Pricing

Only rows with a numeric price or dated promotion create a Product charge. Other catalog rows, notes, summaries, duplicate discoveries, failed requests and empty results have no Product fee. There is no additional default dataset-row fee or optional-details fee.

| Products | Base | Bronze | Silver | Gold and above |
| --- | ---: | ---: | ---: | ---: |
| 2 | $0.008 | $0.0076 | $0.0072 | $0.0064 |
| 50 | $0.20 | $0.19 | $0.18 | $0.16 |
| 100 | $0.40 | $0.38 | $0.36 | $0.32 |
| 1,000 | $4.00 | $3.80 | $3.60 | $3.20 |

Add the $0.02 start charge at the standard 512 MB allocation. The platform counts one start unit per GB, minimum one. At larger memory allocations the start amount scales accordingly. The Product prices are $0.004 base, $0.0038 Bronze, $0.0036 Silver and $0.0032 Gold, Platinum and Diamond.

Set Apify's maximum total charge to bound a run. The Actor checks capacity before saving another paid product and stops cleanly when the next product cannot fit. SUMMARY reports that stop. Free unpriced catalog rows still count toward the output caps.

### Monitor prices every day

Save a task using stable retailer keys, exact store IDs and a consistent basket of products or terms. In Apify Console, create a schedule, select that task, choose the daily schedule and timezone, then connect its completed-run webhook to your database, spreadsheet or workflow.

Join snapshots with `bundleRetailer + storeId + productId` and `scrapedAt`. Preserve price scope and offer conditions, and store barcodes as text. Every scheduled run collects and charges a fresh observation.

Check SUMMARY's rows per retailer, failures, notes and source outcomes before treating a snapshot as complete. Make, Zapier, n8n and Sheets can fetch each completed dataset and SUMMARY. Keep missing observations as gaps.

### API and AI agents

```bash
curl -X POST \
  'https://api.apify.com/v2/acts/vant47~us-grocery-prices-scraper/runs' \
  -H 'Authorization: Bearer YOUR_APIFY_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"retailers":["heb","whole-foods"],"searchTerms":["coffee"],"postalCodes":["78701"],"maxItems":40,"maxItemsPerRetailer":20,"maxItemsPerSearch":20}'
```

```python
from apify_client import ApifyClient
client = ApifyClient("YOUR_APIFY_TOKEN")
run = client.actor("vant47/us-grocery-prices-scraper").call(run_input={
    "retailers": ["heb", "whole-foods"],
    "searchTerms": ["coffee"], "postalCodes": ["78701"],
    "maxItemsPerRetailer": 20, "maxItemsPerSearch": 20, "maxItems": 40
})
rows = list(client.dataset(run["defaultDatasetId"]).iterate_items())
products = [row for row in rows if row.get("recordType") == "PRODUCT"]
```

Connect an AI agent to `https://mcp.apify.com`. Ask it to collect US grocery prices by ZIP from the selected retailers, with product caps and explicit price scope. Ask it to inspect SUMMARY and compare equivalent sizes and units. Supply exact IDs when monitoring a known basket. API and MCP calls use your own Apify token; retailer credentials are unnecessary.

### Limits

Prices are public catalog, advertised, pickup or delivery observations, not audited physical shelf counts or checkout totals. Taxes, service charges, delivery fees, personalized offers, clipped-account state and historical backfill are outside coverage. Physical stock quantities, membership amounts, review data, barcodes and promotion dates remain null when the source does not supply them.

Kroger search and category pages often expose only their first product batch. Repeated pages are deduplicated and bounded; a large cap does not guarantee complete catalog enumeration. Use several terms, stores or known product IDs for monitoring breadth. Complete digital-coupon and member-price directories are not available.

Publix regular shelf prices are not supplied by its native catalog. Delivery matching is selective and can leave only an advertised price, dated promotion or no qualifying row. Savings-page inputs inspect the sale-marked catalog and do not prove exact flyer membership. Image-only flyer panels and ambiguous delivery matches are omitted.

H-E-B coupons keep their own validity dates; missing sale dates are not filled from an unrelated coupon. Whole Foods unit-price calculations are marked and leave ambiguous multipacks null. Supplier groups remain distinct from GTINs.

Retailers can refuse requests or change their public responses. Automatic routing retries on fresh anonymous sessions; explicit buyer proxy disable, group, country and custom URLs remain authoritative. Different retailers collect concurrently while requests within each component retain their pacing. A small global cap can fill before every retailer contributes. Set the global cap to at least the selected retailer count times the retailer cap for balanced coverage.

Optional details add requests and can be absent while a store price remains available. Public metadata caches contain store addresses or product-directory names, not reused product prices. Run progress and a serial dataset ledger support reboot recovery; ambiguous billing evidence halts further charges.

### FAQ

**Can I compare several retailers in one run?** Yes. Select retailer keys and common ZIPs, or provide individual store selections in retailerInputs.

**Does the cheapest row mean the cheapest equivalent product?** No. COMPARISON sorts numeric prices within a discovery term. Check size, unit, brand, barcode and membership conditions before making an equivalence claim.

**Why do I get fewer than my cap?** The source may have fewer matches, limited pagination, no supported store, unavailable prices or a spending limit. SUMMARY records the observed coverage.

**Are unpriced products charged?** Only a row with a numeric price or dated promotion qualifies. Other catalog rows are excluded by default and free when requested.

# Actor input Schema

## `retailers` (type: `array`):

Choose kroger, safeway, albertsons, publix, heb or whole-foods. Kroger banners: ralphs, frys, kingsoopers, fredmeyer, smiths, qfc, dillons, marianos, picknsave, harristeeter. Albertsons banners: vons, jewelosco, acme, shaws, starmarket, tomthumb, randalls, pavilions, carrs. Unknown names produce free notes.

## `searchTerms` (type: `array`):

Search each term at every selected store. Leave empty for URL or product monitoring.

## `categoryUrls` (type: `array`):

Public category URLs. Each is routed only to its selected retailer; accepts the same strings as startUrls.

## `startUrls` (type: `array`):

Public retailer URLs; automatically routed by domain. URLs never override the chosen store.

## `productIds` (type: `array`):

With one retailer, bare source IDs. With several, prefix retailer:ID, for example safeway:136010121. Product IDs are not barcodes.

## `locations` (type: `array`):

Common ZIP codes for every retailer. Nonempty locations takes precedence over postalCodes. No supported nearby store produces a free note. No default ZIP is injected.

## `postalCodes` (type: `array`):

Alias for locations; used when locations is empty. Every retailer resolves its own nearest supported store.

## `storeIds` (type: `array`):

Exact store IDs override ZIPs. With several retailers use retailer:ID, for example safeway:3132, heb:92. Bare IDs apply only with a single selected retailer.

## `retailerInputs` (type: `object`):

Optional object keyed by selected retailer. Set searchTerms, locations, postalCodes, storeIds, productIds, categoryUrls or startUrls for each. These override common selections. Use exact stores for repeat monitoring. Remove sample ZIPs when comparing one common ZIP.

## `maxItemsPerRetailer` (type: `integer`):

Total cap for each selected retailer/banner across its terms and stores. Base price $0.004 per qualifying product.

## `maxItemsPerSearch` (type: `integer`):

Source cap within each retailer. A source may expose fewer results. The retailer and global caps still apply.

## `maxItems` (type: `integer`):

Global cap across concurrently collected retailers. 50 products cost $0.20 at base price plus $0.02 start. Set at least the retailer count times the retailer cap to give every retailer its full allowance.

## `dealsOnly` (type: `boolean`):

Keep products marked with a source sale or offer. Conditional coupons remain separate from prices.

## `includeDetails` (type: `boolean`):

Optional slower ingredients, nutrition or product metadata where public. No extra result fee.

## `includeUnpricedProducts` (type: `boolean`):

Off by default. Rows with neither a numeric price nor dated promotion are free. They count toward output caps.

## `proxyConfiguration` (type: `object`):

Automatic default uses datacenter first and US residential retries. Explicit proxy disable, group, country or custom proxy is preserved.

## Actor input object example

```json
{
  "retailers": [
    "kroger",
    "safeway",
    "publix",
    "heb",
    "whole-foods"
  ],
  "searchTerms": [
    "milk"
  ],
  "retailerInputs": {
    "kroger": {
      "locations": [
        "45202"
      ]
    },
    "safeway": {
      "locations": [
        "94611"
      ]
    },
    "publix": {
      "locations": [
        "32801"
      ]
    },
    "heb": {
      "locations": [
        "78701"
      ]
    },
    "whole-foods": {
      "locations": [
        "78701"
      ]
    }
  },
  "maxItemsPerRetailer": 10,
  "maxItemsPerSearch": 10,
  "maxItems": 50,
  "dealsOnly": false,
  "includeDetails": false,
  "includeUnpricedProducts": false,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `products` (type: `string`):

No description

## `comparison` (type: `string`):

No description

## `deals` (type: `string`):

No description

## `summary` (type: `string`):

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "retailers": [
        "kroger",
        "safeway",
        "publix",
        "heb",
        "whole-foods"
    ],
    "searchTerms": [
        "milk"
    ],
    "retailerInputs": {
        "kroger": {
            "locations": [
                "45202"
            ]
        },
        "safeway": {
            "locations": [
                "94611"
            ]
        },
        "publix": {
            "locations": [
                "32801"
            ]
        },
        "heb": {
            "locations": [
                "78701"
            ]
        },
        "whole-foods": {
            "locations": [
                "78701"
            ]
        }
    },
    "maxItemsPerRetailer": 10,
    "maxItemsPerSearch": 10,
    "maxItems": 50
};

// Run the Actor and wait for it to finish
const run = await client.actor("vant47/us-grocery-prices-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "retailers": [
        "kroger",
        "safeway",
        "publix",
        "heb",
        "whole-foods",
    ],
    "searchTerms": ["milk"],
    "retailerInputs": {
        "kroger": { "locations": ["45202"] },
        "safeway": { "locations": ["94611"] },
        "publix": { "locations": ["32801"] },
        "heb": { "locations": ["78701"] },
        "whole-foods": { "locations": ["78701"] },
    },
    "maxItemsPerRetailer": 10,
    "maxItemsPerSearch": 10,
    "maxItems": 50,
}

# Run the Actor and wait for it to finish
run = client.actor("vant47/us-grocery-prices-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "retailers": [
    "kroger",
    "safeway",
    "publix",
    "heb",
    "whole-foods"
  ],
  "searchTerms": [
    "milk"
  ],
  "retailerInputs": {
    "kroger": {
      "locations": [
        "45202"
      ]
    },
    "safeway": {
      "locations": [
        "94611"
      ]
    },
    "publix": {
      "locations": [
        "32801"
      ]
    },
    "heb": {
      "locations": [
        "78701"
      ]
    },
    "whole-foods": {
      "locations": [
        "78701"
      ]
    }
  },
  "maxItemsPerRetailer": 10,
  "maxItemsPerSearch": 10,
  "maxItems": 50
}' |
apify call vant47/us-grocery-prices-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,vant47/us-grocery-prices-scraper"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/aKHL0bb37bgaUPLw5/builds/fXOPerkUsOxbOZhXR/openapi.json
