# Giant Eagle Scraper: Store Prices, myPerks Deals & Weekly Ad (`moggedhq/giant-eagle-scraper`) Actor

Get Giant Eagle and Market District products with the price at your store: sale price, myPerks deals, digital coupons, weekly ad deals with dates, unit price, stock, SKU and size. Search, categories or product links by ZIP or store. About $0.004 per product. No login.

- **URL**: https://apify.com/moggedhq/giant-eagle-scraper.md
- **Developed by:** [mogged](https://apify.com/moggedhq) (community)
- **Categories:** E-commerce, Automation
- **Security:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% 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

## Giant Eagle Scraper: Store Prices, myPerks Deals & Weekly Ad

For retail price analysts, brands and comparison services monitoring Giant Eagle and Market District groceries at selected US stores. Collect advertised prices, sale comparisons, weekly-ad dates, coupon conditions, unit prices, shelf locations and availability in one consistent product table. About **$0.004 per delivered product**, or **$4 for 1,000 products**, plus a minimum **$0.00005 Actor start charge**. No retailer login or retailer API key is needed.

On November 4, 2026, SKU `00030034000622`, Giant Eagle Reduced Fat Milk, 2% Milkfat, was **$2.99 at Westerville Market District, store 6507**, and **$4.99 at Robinson Market District, store 47**.

### What you get

| Field | Meaning |
| --- | --- |
| `retailer`, `country`, `currency` | Giant Eagle, US and USD. |
| `storeId`, `storeName`, `location` | Verified retailer store code, store name and requested ZIP. |
| `productId`, `sku` | Original retailer SKU, represented as a string with leading zeros. |
| `gtin` | Dedicated barcode field when explicitly supplied by the source. |
| `title`, `brand`, `size` | Product name, brand and displayed package size. |
| `price`, `regularPrice` | Advertised current price and supplied comparison price. |
| `onSale`, `promoText`, `promoType` | Sale flag, promotion conditions and normalized promotion type. |
| `promoStart`, `promoEnd` | Advertised price-promotion dates, derived from explicit source dates or dated terms. |
| `memberPrice`, `memberProgram` | Membership price only when the source identifies a membership-scoped price. |
| `unitPrice`, `unitOfMeasure` | Published unit price and unit, such as oz, gl, each or lb. |
| `inStock`, `stockLevel` | Catalog availability flag and any explicit stock quantity. |
| `rating`, `reviewCount` | Dedicated review fields for compatible retail exports. |
| `category`, `url`, `imageUrl` | Main department, store-specific product link and product image. |
| `scrapedAt` | UTC time the source response was mapped into a row. |

Useful Giant Eagle fields include:

| Field | Meaning |
| --- | --- |
| `banner` | Giant Eagle or Market District, based on the verified store name. |
| `aisle`, `storeAddress` | Source shelf location and public store address. |
| `sellByWeight`, `pricingModel`, `priceIsEstimate` | Weight-based pricing and average-weight price estimates. |
| `priceQuantity` | Quantity associated with the displayed price; useful for multi-buy offers. |
| `priceRequiresMembership` | Whether the source price scope explicitly identifies a membership requirement. |
| `scopedPromo` | Original quantity, terms, price-lock flag, badge, kind and scope. |
| `scopedPromoPrice`, `scopedPromoUnitPrice` | Separate source promotion price fields. |
| `coupons` | Coupon descriptions, conditions, redemption quantities, values and formatted expiration dates. |
| `rewardPromos` | Product reward conditions, quantities and amounts supplied by the catalog. |
| `rebates` | Advertised rebate type, value, required quantity and expiration date. |
| `weeklyAd`, `circularStart`, `circularEnd` | Weekly-ad identification and the source circular date window. |
| `isEverydaySavings`, `isNewLowPrice` | Giant Eagle's source savings badges. |
| `isDeal` | Whether a row has a sale, coupon, reward, savings badge or weekly-ad context. |
| `inventoryStatus`, `fulfillmentMethods` | Original availability label and pickup/delivery methods. |
| `unitPriceText`, `rawUnitPrice`, `unitQty`, `units` | Source unit labels and values for auditing unit-price comparisons. |
| `categoryPath`, `categorySeoUrls` | Full catalog breadcrumb and category links. |
| `requestedLocations` | ZIPs that resolved to this same store in the run. |
| `sourceProductId` | Source identifier, including its store-code prefix. |
| `details` | Optional description, ingredients, directions, allergens, health claims and warnings. |

### Understand prices and promotions

`price` preserves the number the retailer publishes for the selected store. `regularPrice` preserves the separate comparison price when the catalog supplies one. For example, the November 4 observation of Produce Strawberries at Robinson Market District showed a **$3.99** advertised price and a **$5.99** comparison price, with terms **Valid 10/29 - 11/4/2026**. The output converts that date range into `2026-10-29` and `2026-11-04` and retains the original terms.

For a multi-buy, retain `priceQuantity` beside `price`. Comparison prices can be per-item while the advertised price covers several items. A display of two for a stated amount refers to that offer quantity. The original terms and scoped promotion remain available for basket logic. For a product sold by weight, retain `sellByWeight`, `pricingModel`, size and unit-price information together. The source can describe an average package size while the displayed price is per pound.

### How to use it

1. Choose products with `searchTerms`, `startUrls` or `productIds`.
2. Choose ZIPs in `locations` or exact codes in `storeIds`, and set your row limits.
3. Run the Actor, inspect the store names in the overview, and export the dataset or retrieve it through the API.

A first price check:

```json
{
  "searchTerms": ["milk"],
  "locations": ["15205"],
  "maxItemsPerSearch": 20,
  "maxItems": 20
}
```

A fixed store panel:

```json
{
  "searchTerms": ["milk", "bread", "coffee"],
  "storeIds": ["47", "6507"],
  "maxItemsPerSearch": 50,
  "maxItems": 300
}
```

Weekly-ad products:

```json
{
  "startUrls": ["https://www.gianteagle.com/grocery/weekly-ad"],
  "storeIds": ["47"],
  "dealsOnly": true,
  "maxItemsPerSearch": 100,
  "maxItems": 100
}
```

Cloud validation returned priced products for 35 varied inputs across five ZIPs and seven stores. Three mixed-input runs each delivered 1,200 distinct product/store rows. A forced reboot preserved row and charge counts. Ten rendered-page observations matched the exported prices.

### Inputs

| Input | Default and behavior |
| --- | --- |
| `searchTerms` | Product queries, such as milk, chicken or coffee. With no source fields supplied, uses milk. |
| `startUrls` | Optional Giant Eagle category, search, weekly-ad or product links. |
| `productIds` | Optional retailer SKU strings, including leading zeros. |
| `locations` | US five-digit ZIP codes. Uses the first matching grocery store in the retailer's distance-ordered results. |
| `storeIds` | Exact numeric retailer store codes. Takes precedence over ZIPs. |
| `maxItemsPerSearch` | Up to 2,000 delivered products per source and store; default 20. |
| `maxItems` | Global delivered-product cap, up to 10,000; default 20. |
| `dealsOnly` | Keep advertised deals and savings; default false. |
| `includeDetails` | Include additional catalog text; default false, with the same product price. |
| `proxyConfiguration` | Optional proxy settings. Automatic mode first tries the default datacenter pool, then US residential after refusals. |

### Example product observation

Observed November 4, 2026:

```json
{
  "retailer": "Giant Eagle",
  "country": "US",
  "currency": "USD",
  "storeId": "6507",
  "storeName": "Westerville Market District",
  "location": null,
  "productId": "00030034000622",
  "sku": "00030034000622",
  "gtin": null,
  "title": "Giant Eagle Reduced Fat Milk, 2% Milkfat, with Vitamin A & D, Grade A",
  "brand": "Giant Eagle",
  "size": "1 gl",
  "price": 2.99,
  "regularPrice": null,
  "onSale": false,
  "unitPrice": 2.99,
  "unitOfMeasure": "gl",
  "inStock": true,
  "banner": "Market District",
  "aisle": "Dairy",
  "sellByWeight": false
}
```

### Pricing

The list price is **$0.004 per distinct delivered product at one store**. Bronze is **$0.0038**, Silver is **$0.0036**, and Gold and higher are **$0.0032** per product. Optional details use the same product charge.

| Delivered products | List-price product charge |
| --- | --- |
| 20 | $0.08 |
| 100 | $0.40 |
| 1,000 | $4.00 |
| 5,000 | $20.00 |

Add the small Actor start charge, beginning at $0.00005. Your Apify tier and any applicable Store discount determine the actual product price displayed at run time. Duplicate discoveries, empty searches, failed requests, retries and informational notes have no product charge. The Actor stops when the buyer's available product-charge budget is exhausted.

### Monitor prices every day

Save an input as an Apify task. In Schedules, choose the frequency and timezone appropriate for your monitoring panel and attach the task. Keep the same explicit `storeIds`, product sources and limits across observations. Connect a webhook or integration to append successful runs to your warehouse, spreadsheet or comparison database.

Each run saves a `SUMMARY` record containing products delivered, stores resolved, deals found, duplicate exclusions, input outcomes, free failures and whether the spending limit was reached. Your scheduled workflow can inspect that record before updating its latest-price table. The `DEALS` output provides products marked as deals; large exports are split into numbered records listed in its index.

Delivery uses the saved dataset as its recovery ledger. If the platform restarts a run, already delivered product/store rows are reconciled with acknowledged product charges before processing continues. Product identity stays stable across overlapping inputs and resumed work.

### API access

Start a run with an Apify token and the same JSON input you use in the console:

```bash
curl -X POST \
  'https://api.apify.com/v2/acts/moggedhq~giant-eagle-scraper/runs' \
  -H "Authorization: Bearer $APIFY_TOKEN" \
  -H 'Content-Type: application/json' \
  -d '{"storeIds":["47"],"searchTerms":["milk"],"maxItems":20}'
```

The response identifies the run and its default dataset. Poll the run until it finishes, then retrieve the dataset items. The default key-value store contains `SUMMARY` and `DEALS`.

Python with the Apify client:

```python
import os
from apify_client import ApifyClient

client = ApifyClient(os.environ["APIFY_TOKEN"])
run = client.actor("moggedhq/giant-eagle-scraper").call(run_input={
    "storeIds": ["47"],
    "searchTerms": ["milk", "bread"],
    "maxItemsPerSearch": 20,
    "maxItems": 40,
})
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    if item.get("recordType") == "PRODUCT":
        print(item["storeId"], item["sku"], item["price"])
```

### Use with AI agents (MCP)

Connect an Apify MCP client at `https://mcp.apify.com`, select this Actor, and give it the product sources, store codes or ZIPs and a global product cap. For example:

Find milk and coffee prices at Giant Eagle stores near 15205 and 44113. Return at most 100 products total, retaining the store code, sale conditions, unit price and availability.

### Limits

- The Actor reads public signed-out catalog information. It does not log in, clip coupons, redeem rewards or calculate a personalized checkout total.
- The source product SKU is preserved. The public product schema does not expose a separate UPC/GTIN field, so `gtin` and `upc` remain null rather than treating every retailer SKU as a barcode. Separate stock quantities, reviews and numeric myPerks point balances also remain null when absent.
- Targeted and individualized offer lists are excluded. Product reward promotions and public coupon terms are retained, but eligibility and qualifying purchases still matter.
- `regularPrice` is null when the source supplies no comparison price. Dates remain null when neither explicit dates nor a dated price-promotion term is supplied.
- `price` can refer to a multi-buy quantity or a pound of a weighted product. Preserve `priceQuantity`, `pricingModel`, size and terms when comparing per-item basket costs. No estimated package total is invented.
- A ZIP resolves according to the retailer's store ordering. Multiple nearby ZIPs can resolve to the same store. Exact store codes take precedence; ZIPs outside the service area can resolve to a distant store or no matching grocery store.
- With no ZIP or store code, the site virtual catalog is used where the retailer resolves it. Its catalog price is not a price at a physical branch. Select a real store for geographic price comparisons.
- Availability is the catalog status at observation time, not a reserved quantity or a guarantee of stock at checkout. Prices can change and exclude taxes or fulfillment fees.
- Website refusals and absent products become free notes and summary outcomes. Optional detail fields depend on the retailer's catalog completeness. The deals table view displays deal-related fields; use the `DEALS` output or `dealsOnly` input when you need only deal rows.

### FAQ

**Can I compare Giant Eagle and Market District?**

Yes. Supply store codes from both banners in one run. Each row identifies the banner, exact store and product SKU.

**What should a pipeline do with note rows?**

Filter `recordType == "PRODUCT"` for price observations. Keep `NOTE` rows and the `SUMMARY` record for coverage checks, source refusals and invalid input explanations.

**How does the spending limit work?**

The Actor checks the remaining affordable product count before delivery and stops cleanly when no further product charge fits. The summary reports that condition, so a monitoring workflow can distinguish a capped run from an empty assortment.

Search terms: Giant Eagle scraper, Giant Eagle store prices, Market District prices, myPerks deals, digital coupons, weekly ad dates and grocery unit prices.

# Actor input Schema

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

Search products such as milk, chicken or coffee at every selected store. Leave empty when using only URLs or product IDs.

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

Optional Giant Eagle category, search, product or weekly-ad links. ZIPs or storeIds determine the store; a store in a URL does not override them.

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

Retailer SKU numbers from product URLs, such as 00030034000622. Preserve leading zeros.

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

US ZIP codes, such as 15205, 44113 or 43215. Chooses the first matching grocery store in the site distance-ordered results. Empty uses the site virtual catalog.

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

Exact Giant Eagle store codes such as 6507 or 47. These take precedence over ZIP codes and are independently verified.

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

Maximum new product rows from each term, category or deals source at one store. Duplicates are free.

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

Global limit across all products and stores. About $0.004 per product: 20 products cost about $0.08 plus the small start charge.

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

Keep advertised sale, savings, coupon, reward or weekly-ad products. Coupon and multi-buy conditions remain separate from the item price.

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

Include ingredients, description, allergens, directions and health claims where the catalog supplies them. No extra product charge.

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

Default: datacenter first, with US residential only after refused datacenter attempts. You may supply your own proxy configuration.

## Actor input object example

```json
{
  "searchTerms": [
    "milk"
  ],
  "locations": [
    "15205"
  ],
  "maxItemsPerSearch": 20,
  "maxItems": 20,
  "dealsOnly": false,
  "includeDetails": false,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

No description

## `dealsView` (type: `string`):

No description

## `dealsOnly` (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 = {
    "searchTerms": [
        "milk"
    ],
    "locations": [
        "15205"
    ],
    "maxItemsPerSearch": 20,
    "maxItems": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("moggedhq/giant-eagle-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 = {
    "searchTerms": ["milk"],
    "locations": ["15205"],
    "maxItemsPerSearch": 20,
    "maxItems": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("moggedhq/giant-eagle-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 '{
  "searchTerms": [
    "milk"
  ],
  "locations": [
    "15205"
  ],
  "maxItemsPerSearch": 20,
  "maxItems": 20
}' |
apify call moggedhq/giant-eagle-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,moggedhq/giant-eagle-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/NkbyCIHaj73wi1F2e/builds/exPuR1QDLYCCei3Ee/openapi.json