# ALDI Australia Scraper: Special Buys, Super Savers & Prices (`moggedhq/aldi-australia-scraper`) Actor

Get ALDI Special Buys in Australia, Super Savers and product prices for milk, coffee or weekly deals by store. Includes unit prices, sale dates, brand, size, category and available stock signals. About $0.0025 per product: 1,000 products cost $2.50. No login.

- **URL**: https://apify.com/moggedhq/aldi-australia-scraper.md
- **Developed by:** [mogged](https://apify.com/moggedhq) (community)
- **Categories:** E-commerce, Automation
- **Security:** Limited permissions
- **Stats:** 3 total users, 2 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 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

## ALDI Australia Scraper: Special Buys, Super Savers & Prices

For retail price analysts, brands and comparison teams monitoring ALDI Australia by store. Get ALDI Special Buys, Super Savers, Lower Prices and everyday product prices in one consistent retail dataset. About **$0.0025 per product at one store**: 20 products cost about **$0.05**, or 1,000 cost **$2.50**, plus the small Actor start charge. No login is required.

Choose search words, links, postcodes or store IDs. Each product-store pair is delivered once, using the selected store's public price data.

This is an independent, unofficial tool. It is not affiliated with or endorsed by ALDI. The public website is the source of every product value; missing values remain `null`.

### What you get

The output starts with a readable verdict. IDs preserve leading zeros and prices are numeric AUD. A free summary reports coverage and any spending-limit stop.

| Field | Meaning |
| --- | --- |
| `verdict` | A short price, store, promotion and stock statement. |
| `retailer`, `country`, `currency` | ALDI Australia, AU and AUD. |
| `storeId`, `storeName` | The actual ALDI service-point reference and store name. |
| `location` | The postcode you requested, rather than the store's postcode. |
| `productId`, `sku` | The full ALDI SKU string. |
| `gtin` | A source barcode if supplied; currently unavailable and null. |
| `title`, `brand`, `size` | Product name, brand and selling pack size where published. |
| `price` | Displayed selling amount in AUD; variable-weight pack estimates are identified. |
| `regularPrice` | A numeric source was-price, only when ALDI actually publishes one. |
| `onSale` | True for a positively identified promotional range, Special Buy or price reduction; otherwise unknown. |
| `promoText`, `promoType` | Verified promotion names and the source's availability or savings text. |
| `promoStart`, `promoEnd` | Source dates only. Special Buys release dates are retained; an expiry is not inferred. |
| `memberPrice`, `memberProgram` | Null when the source provides no loyalty price or program. |
| `unitPrice`, `unitOfMeasure` | Comparable amount and basis, such as 2.38 and `100 g`. Always use them together. |
| `inStock`, `stockLevel` | Public store traffic-light result and wording, when available. |
| `rating`, `reviewCount` | Null when the public source supplies no reviews. |
| `category` | The product's reported department and category path. |
| `url`, `imageUrl` | The source product page and primary product image. |
| `scrapedAt` | UTC observation timestamp. |

Additional fields include `specialBuyDate`, ISO `catalogueWeek`, `unitPriceText`, `shelfPrice`, `priceDisplay`, `priceBasis`, `isVariableWeight`, `availabilityText`, `availabilityTrafficLight`, `stockCheckedAt`, `stockInformationAvailable`, `notForOnlineSale`, `discontinued`, `storePostcode`, `storeCity`, `storeRegion`, `storeAddress`, `requestedLocations`, `promotionLabels` and `sourceUrls`.

With `includeDetails` enabled, product detail pages can add description, ingredients, allergens, nutritional claims, storage and usage instructions, origin, warnings, additional information and a complete image gallery. These fields depend on what ALDI publishes for that product. `detailsIncluded` tells you whether the optional request succeeded. There is no separate detail fee.

### Why the store matters

A postcode resolves to the nearest walk-in ALDI store through ALDI's own store finder. The nearest store can have a different postcode: the tested request for `2000` resolved to store `G525`, 73 Oxford Street in Darlinghurst, postcode `2010`. Both values appear in the row. Store comparisons should join on `storeId`, not the requested postcode alone.

For repeat monitoring, supply the returned `storeIds`. Empty `locations` uses the website default. Postcodes resolving to one store share one charged row and appear in `requestedLocations`. Unavailable stores produce free notes.

### Start in three steps

1. Enter a specific search word such as `milk`, `coffee` or `cheese`, or paste a current ALDI Australia category or product URL.
2. Add the postcodes or exact store IDs to compare. Start with 20 products and keep detail enrichment off for the fastest first run.
3. Run the Actor, inspect the Product overview or Deals view, then download JSON, CSV or Excel from the dataset.

The tested 20-product milk prefill near postcode 2000 returned 20 rows and 8 positively identified promotions in 20 seconds. Future runs depend on ALDI's response time and the number of stock or detail requests.

### Input reference

| Input | Default and behavior |
| --- | --- |
| `searchTerms` | Array of words; the console prefill is `["milk"]`. If no selectors are supplied, milk is used. |
| `startUrls` | Optional category, product, search or Special Buys links. |
| `productIds` | Optional full 18-digit SKU strings, preserving leading zeros. |
| `locations` | Australian four-digit postcodes. Console prefill: `["2000"]`; empty means the website default store. |
| `storeIds` | Optional exact store references such as `G525`. |
| `maxItemsPerSearch` | 20 candidate products per selector and store; range 1 to 10,000. |
| `maxItems` | 20 product-store rows across the whole run; range 1 to 10,000. |
| `dealsOnly` | False. True excludes products without positive promotion evidence. |
| `includeDetails` | False. Adds slower optional product detail requests without a second product fee. |
| `proxyConfiguration` | Apify datacenter by default; Australian residential retry only after datacenter fails. |

Input arrays accept 100 entries each. Invalid input produces a free note. The global `maxItems` and Apify spending limit apply across all stores combined.

#### Compare several stores

```json
{
  "searchTerms": ["coffee"],
  "locations": ["2000", "3000", "4000", "5000", "6000"],
  "maxItemsPerSearch": 10,
  "maxItems": 50
}
```

#### Current Super Savers

```json
{
  "searchTerms": [],
  "startUrls": ["https://www.aldi.com.au/products/super-savers/k/1588161426952145"],
  "locations": ["3000"],
  "dealsOnly": true,
  "maxItemsPerSearch": 60,
  "maxItems": 60
}
```

#### Product details at one exact store

```json
{
  "productIds": ["000000000000762476"],
  "storeIds": ["G525"],
  "includeDetails": true,
  "maxItems": 1
}
```

Paste current category URLs containing `/k/` and the category ID. Product URLs end with the full SKU. Search links use `/results?q=milk`. A dated catalogue link uses `/special-buys/YYYY-MM-DD`, optionally with `?theme=Pet+Essentials`. The bare `/special-buys` link selects the latest released date advertised in ALDI's current calendar, or the earliest advertised date when none has been released. It does not mean every historical or upcoming catalogue. Marketing pages and PDF catalogue links are not product input routes.

### Example from a real run

The following row was collected on 28 October 2026 for postcode 2000, resolved to G525. The product name, price and promotion are actual output values.

```json
{
  "verdict": "A$3.99 at 73 Oxford Street; Limited Time Only.",
  "retailer": "ALDI Australia",
  "country": "AU",
  "currency": "AUD",
  "storeId": "G525",
  "storeName": "73 Oxford Street",
  "location": "2000",
  "productId": "000000000538441002",
  "sku": "000000000538441002",
  "title": "Milk Mouse - Milk Chocolate 168g",
  "brand": "CHOCEUR",
  "size": "168 g",
  "price": 3.99,
  "regularPrice": null,
  "promoType": "Limited Time Only",
  "promoStart": null,
  "promoEnd": null,
  "unitPrice": 2.38,
  "unitOfMeasure": "100 g",
  "inStock": null,
  "stockLevel": null,
  "url": "https://www.aldi.com.au/product/choceur-milk-mouse-milk-chocolate-168g-000000000538441002",
  "scrapedAt": "2026-10-28T19:52:28.570Z"
}
```

### Reading prices and promotions correctly

Random-weight products have an approximate pack price and a separate comparison price. Read `price`, `unitPrice`, `unitOfMeasure` and `priceBasis` together. `shelfPrice` retains the other source price amount so analysts can audit weight conversions.

ALDI often shows only the current reduced price. A named range proves promotion membership, not a numerical discount. `regularPrice` requires an explicit was-price. Special Buys release dates never become invented promotion expiries.

Keyword searches are checked against Lower Prices, Super Savers and Limited Time Only for the same term and store. Named deal inputs provide their promotion context. Other category and exact-product results can have unknown membership; use named deal links for promotion research.

Stock uses the public store traffic light where offered. Catalogue presence and the online-sale flag `notForSale` do not prove physical shelf availability. Exact quantities are unavailable.

### Monitor prices every day

Save a working input as an Apify task. In Console, add a schedule for that task at your preferred local time. Keep the same exact store IDs, SKU strings and selection limits so daily snapshots are comparable. Export the dataset into your warehouse or spreadsheet through an integration or successful-run webhook.

Join snapshots on `retailer`, `storeId` and `productId`; compare prices, promotion and stock fields. Keep `scrapedAt`. Missing from a capped search does not mean delisted. Exact IDs give stable watchlists. Fresh runs charge again; duplicate discoveries within one run do not.

### Pricing and limits

| Job | Product charge before tier discounts |
| --- | --- |
| 20 products at one store | $0.05 |
| 10 products at five distinct stores | $0.125 |
| 100 product-store rows | $0.25 |
| 1,000 product-store rows | $2.50 |

The list price is $0.0025 per delivered Product. Bronze is $0.002375, Silver $0.00225, and Gold or higher $0.002. The platform Actor start charge is $0.00005 at the supported memory sizes. Failed requests, retries, duplicate discoveries, note rows and the summary have no product charge. Optional details use the same product fee.

Set Apify's maximum charge before starting a large job. The Actor checks capacity before delivery, stops cleanly when another row would exceed the limit, and records that stop in the summary. Progress survives an Apify reboot or migration: saved product-store keys and reconciled billing prevent replayed work from creating duplicate rows or a second product charge.

### API use

Python:

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")
run = client.actor("moggedhq/aldi-australia-scraper").call(run_input={
    "searchTerms": ["milk"], "locations": ["2000"], "maxItems": 20
})
for row in client.dataset(run["defaultDatasetId"]).iterate_items():
    if row.get("recordType") == "PRODUCT":
        print(row["storeId"], row["sku"], row["price"])
```

JavaScript:

```javascript
import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: 'YOUR_APIFY_TOKEN' });
const run = await client.actor('moggedhq/aldi-australia-scraper').call({
    productIds: ['000000000000762476'], storeIds: ['G525'], maxItems: 1
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
const products = items.filter(row => row.recordType === 'PRODUCT');
```

Use the successful run's dataset ID for exports and its key-value store `SUMMARY` record for coverage. The Product overview, Deals and Full analyst output views show different columns from the same dataset. Filter `recordType` when consuming exports because free note and summary records also appear there. Use `dealsOnly` to return a deals-only product selection.

### Use with AI agents (MCP)

Connect an MCP client to `https://mcp.apify.com` and ask it to run `moggedhq/aldi-australia-scraper`. Example: compare ten coffee products near postcodes 2000 and 3000, including unit price. Supply `maxItems: 20` and `maxItemsPerSearch: 10`; read PRODUCT rows and SUMMARY after completion. Private Actors require an authorized account.

### Honest limits and FAQ

**Does this cover every ALDI store?** The Actor uses ALDI's public walk-in store finder. A postcode may select a nearby store. If no store is available, it returns a free note. Exact store IDs make repeat checks more predictable.

**Are the prices national?** Each request carries the resolved store reference. ALDI says displayed prices depend on the selected location. The actual store ID and requested location are both returned.

**Why are barcodes, member prices or reviews null?** They were not supplied in the verified public product records. A SKU is not relabeled as a barcode, and an unknown rating is not zero.

**Why are many stock fields null?** The stock checker is only exposed for some products. Null means unknown, not in stock and not sold out. A traffic-light result is a recent indication and can change before a store visit.

**Can I collect old Special Buys catalogues?** Only dates still exposed by the live public source are reliable. This is a current-price collector, not a historical catalogue archive. Save recurring snapshots to build your own history.

**Why did a two-word search return loosely related items?** Search behavior follows ALDI's own matching and ordering. Prefer a specific single word, a category link, or exact SKUs for a stable watchlist.

**What happens when ALDI changes or refuses a request?** Requests are paced, transient failures are retried with fresh sessions, and missing inputs become free notes. Persistent source failures appear in the summary. No public endpoint can be guaranteed never to change; monitoring should inspect coverage as well as run success.

**Can I send results to a spreadsheet?** Yes. Use dataset downloads or Apify integrations with Google Sheets, Make, Zapier, n8n and webhooks. Retain the store and product keys when joining observations.

ALDI Australia prices, ALDI AU product data, ALDI Special Buys dates, Super Savers and Lower Prices, collected with clear store provenance.

# Actor input Schema

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

ALDI search words, such as milk, cheese or coffee. The site may match words separately.

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

Optional public ALDI Australia links. Use current /products/.../k/ID, /product/...-SKU, /results?q=term, or /special-buys/date.

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

Optional full 18-digit ALDI SKU strings. Preserve leading zeros.

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

Resolve each postcode to its nearest public ALDI walk-in store. Actual store postcode and requested postcode are returned separately. Empty uses the site default store.

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

Optional exact ALDI store references, for example G525. Use these for repeatable store comparisons.

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

Maximum candidate products for each input search, category or product and store. dealsOnly may reduce delivery.

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

Global maximum paid product-store rows across all inputs and locations. Duplicate rows are free.

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

Deliver only positively identified Super Savers, Lower Prices, Limited Time Only, Special Buys or price reductions. Unknown promotion status is excluded.

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

Fetch individual product detail JSON for description, ingredients, allergens, origin and images where available. Slower; the product price is unchanged.

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

Default is Apify datacenter. Automatic Australian residential retry is used only after datacenter failures. Custom proxies or direct requests can be supplied.

## Actor input object example

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

# Actor output Schema

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

// Run the Actor and wait for it to finish
const run = await client.actor("moggedhq/aldi-australia-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": ["2000"],
    "maxItemsPerSearch": 20,
    "maxItems": 20,
}

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

```

## MCP server setup

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