# ALDI Australia Scraper: Prices, Specials & Special Buys (`egra_van/aldi-au-products`) Actor

Get ALDI Australia (aldi.com.au) products by keyword, category or product ID: price, unit price, price drops, Super Savers, Special Buys by date, categories and images in a clean format. Combine with our Coles & Woolworths scraper for full Australian grocery price comparison.

- **URL**: https://apify.com/egra\_van/aldi-au-products.md
- **Developed by:** [Argentin Vazdautan](https://apify.com/egra_van) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.85 / 1,000 aldi grocery 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: Prices, Specials & Special Buys

Scrape **ALDI Australia** ([aldi.com.au](https://www.aldi.com.au)) by keyword, category, **Special Buys** date or product and get **prices, unit prices, price drops, Super Savers, Lower Prices, Special Buys, categories and images** in one clean, typed format. Built for price-comparison apps, grocery price trackers, deal sites and retail analysts.

The Actor reads the same JSON API the ALDI website uses (no HTML parsing), so every field is complete and typed. It retries with new IPs when blocked, can fall back to a real Chrome browser, and reports every failed search as a clear error row instead of failing the whole run.

*Keywords: ALDI scraper, ALDI Australia API, ALDI Special Buys, ALDI prices, Australian grocery prices, supermarket price comparison, unit price, Super Savers, grocery price tracker.*

### What you can do

- 🔎 **Search** ALDI's range by keyword ("milk", "coffee pods", "nappies")
- 🗂️ **Scrape whole categories** by pasting category links (sub-categories too)
- 🛍️ **Get Special Buys** for any Wednesday/Saturday drop — or all current and upcoming ones at once
- 🏷️ **Only specials**: Special Buys, Super Savers, Lower Prices and price drops
- 📦 **Track specific products** by link or product number (e.g. on a daily schedule)
- ⚖️ **Compare fairly** with unit prices (`$0.71 per 100g`)
- 🔗 **Same schema as our Coles & Woolworths Actor** — combine the datasets for a full Australian price comparison
- 💸 **Pay only for products returned.** Error rows are free.

### Quick start

**Search:**

```json
{ "searchTerms": ["milk", "coffee pods"], "maxItemsPerSearch": 50 }
```

**All current & upcoming Special Buys, Super Savers and Lower Prices:**

```json
{ "onlySpecials": true, "maxItemsPerSearch": 500 }
```

**Categories and a Special Buys day:**

```json
{
  "categoryUrls": [
    "https://www.aldi.com.au/products/dairy-eggs-fridge/k/960000000",
    "https://www.aldi.com.au/special-buys/2026-09-30"
  ]
}
```

**Track products daily:**

```json
{ "productIds": ["https://www.aldi.com.au/product/lodge-farms-cage-eggs-700g-000000000000399451", "704511"] }
```

### Input

| Field | Default | What it does |
|---|---|---|
| `searchTerms` | – | Keywords to search. |
| `categoryUrls` | – | Category pages (`/products/…/k/…`), Special Buys days (`/special-buys/YYYY-MM-DD`), Super Savers or Lower Prices. |
| `productIds` | – | Product links or ALDI product numbers (`399451` or `000000000000399451`). |
| `onlySpecials` | `false` | Keep only specials. With nothing else filled in: last 2 + next 2 Special Buys days, Super Savers and Lower Prices. |
| `maxItemsPerSearch` | `100` | Max products saved per search term / category / list. |
| `sortBy` | `relevance` | Relevance, price or name order. |
| `storeId` | automatic | ALDI store code sent to the API. Prices are national, so leave it empty. |
| `proxyConfiguration` | Apify Proxy | See **Proxies**. |
| `useBrowserForCookies` | `false` | Start with cookies from a real browser (only if the log shows blocks). |
| `browserFallback` | `true` | If requests keep getting blocked, load the data from inside a real browser. |
| `maxPagesPerSearch`, `maxRetries`, `requestDelayMs` | `30`, `4`, `500` | Safety limits and pacing. |
| `saveDebugPages` | `true` | Save block pages / screenshots as `DEBUG-*` records. |
| `includeRaw` | `false` | Add ALDI's original product object as `raw`. |

### Output

```json
{
  "store": "aldi",
  "productId": "000000000000704511",
  "name": "BELMONT Choc Tim Tam Original Biscuits 200g",
  "brand": "BELMONT",
  "size": "200g",
  "price": 3.49,
  "wasPrice": 3.99,
  "savings": 0.5,
  "unitPrice": 1.75,
  "unitPriceMeasure": "100 g",
  "unitPriceText": "$1.75 per 100 g",
  "loyaltyPrice": null,
  "isOnSpecial": true,
  "promoType": "PRICE_DROP",
  "promoText": "Save $0.50 · Was $3.99",
  "availableFrom": null,
  "inStock": true,
  "category": "Snacks & Confectionery",
  "badges": [],
  "imageUrl": "https://dm…aldi.cx/is/image/…/product/jpg/scaleWidth/600/…",
  "url": "https://www.aldi.com.au/product/belmont-choc-tim-tam-original-biscuits-200g-000000000000704511",
  "currency": "AUD",
  "searchTerm": "tim tam",
  "categoryUrl": null,
  "scrapedAt": "2026-09-27T08:30:00.000Z"
}
```

| Field | Meaning |
|---|---|
| `price` | Shelf price in AUD (for weight-priced goods: the price ALDI charges). |
| `wasPrice`, `savings` | Only when ALDI shows a struck-through price. |
| `unitPrice`, `unitPriceText` | ALDI's comparable unit price. |
| `isOnSpecial`, `promoType` | `SPECIAL_BUY`, `SUPER_SAVER`, `LOWER_PRICE`, `PRICE_DROP`, `PROMOTION` or `LIMITED_TIME` (not counted as special). |
| `availableFrom` | Special Buys on-sale date text. |
| `inStock` | ALDI sells groceries in store only, so this is `false` only for discontinued products. |
| `loyaltyPrice` | Always `null` (ALDI has no loyalty pricing); kept for a schema shared with our Coles/Woolworths and Tesco Actors. |

**Error rows** (free) have `isError: true`, the failing input, `error`, `errorStep`, `httpStatus`, `blocked` and `blockMarkers`. Dataset views: **Products**, **Specials & savings**, **Errors**. The run summary (requests, retries, blocks, method, store used) is saved as `OUTPUT` in the key-value store.

### Proxies and reliability

The Actor uses fast plain HTTP requests to ALDI's JSON API. When a request is blocked it switches headers and IP, then (if `browserFallback` is on) loads the data from inside a real Chrome browser — and logs every step (HTTP status, detected block page, exit IP). The default **Apify Proxy** should work; if the log shows `BLOCKED` on every attempt, use proxy group **RESIDENTIAL** with country **AU**.

### Pricing

Pay per event: **$1.00 per 1,000 products** saved (`product` event). Error rows, retries and blocked attempts are free. Set a maximum cost per run and the Actor stops cleanly when it is reached.

### Good to know

- ALDI Australia does not sell groceries online; this is ALDI's **online product catalogue** with national shelf prices. Individual stores can differ, and Special Buys are "while stocks last".
- Special Buys drop on Wednesdays and Saturdays; upcoming days appear a few days before.
- Data is publicly visible on aldi.com.au; use it in line with ALDI's terms and applicable law. Not affiliated with ALDI.

# Actor input Schema

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

Keywords to search on aldi.com.au, e.g. "milk", "coffee pods", "nappies". Each term returns up to "Max products per search" products.

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

Pages copied from aldi.com.au: categories (https://www.aldi.com.au/products/dairy-eggs-fridge/k/960000000 — sub-categories work too), Special Buys dates (https://www.aldi.com.au/special-buys/2026-09-30), Super Savers (https://www.aldi.com.au/products/super-savers/k/1588161426952145) or Lower Prices (https://www.aldi.com.au/products/lower-prices/k/1588161425841179).

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

Specific products to check, e.g. for daily price tracking: product links (https://www.aldi.com.au/product/lodge-farms-cage-eggs-700g-000000000000399451) or ALDI product numbers (399451 or 000000000000399451).

## `onlySpecials` (type: `boolean`):

Keep only products on special: Special Buys, Super Savers, Lower Prices and price drops. With no search terms, links or products, the Actor returns the current and upcoming Special Buys plus the Super Savers and Lower Prices lists.

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

Maximum number of products saved for each search term, category or Special Buys list. You pay only for products saved.

## `sortBy` (type: `string`):

Order of search and category results, as on the website. Matters when "Max products per search" is lower than the number of results.

## `storeId` (type: `string`):

ALDI store code sent with API requests. Leave empty: the Actor picks a store automatically (ALDI shelf prices are national). Only set it if you know a store code, e.g. from the store finder.

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

Proxy used for all requests. The default Apify Proxy works in most cases. If the log says requests are BLOCKED, switch to the RESIDENTIAL group with country Australia (AU).

## `useBrowserForCookies` (type: `boolean`):

Open aldi.com.au once in a real Chrome browser and send its cookies with the API requests. Not needed normally (the ALDI API answers plain requests) — turn on only if the log shows blocks.

## `browserFallback` (type: `boolean`):

If fast requests keep getting blocked, load the data from inside a real browser that has aldi.com.au open (slower, but looks exactly like a visitor). Recommended.

## `maxPagesPerSearch` (type: `integer`):

Safety limit on result pages read per search term or list (up to 60 products per page). Mostly matters with "Only specials", where many pages may be checked to find enough specials.

## `maxRetries` (type: `integer`):

How many times a failed or blocked request is retried (with a new IP when blocked) before that search is reported as failed.

## `requestDelayMs` (type: `integer`):

Average pause between two requests. Slower is less likely to be blocked.

## `saveDebugPages` (type: `boolean`):

When ALDI answers with a block/captcha page, save up to 4 such pages (and a browser screenshot) to the run's key-value store as DEBUG-\* records. Free; helps report problems.

## `includeRaw` (type: `boolean`):

Add the original product object from the ALDI API as a "raw" field on every product (large; for debugging or fields not in the unified format).

## `apiBaseUrl` (type: `string`):

For testing only: send API requests to this address instead of https://asl.api.aldi.com.au/commerce (e.g. a local mock server). Leave empty.

## `siteBaseUrl` (type: `string`):

For testing only: open this address in the fallback browser instead of https://www.aldi.com.au. Leave empty.

## Actor input object example

```json
{
  "searchTerms": [
    "milk"
  ],
  "onlySpecials": false,
  "maxItemsPerSearch": 100,
  "sortBy": "relevance",
  "proxyConfiguration": {
    "useApifyProxy": true
  },
  "useBrowserForCookies": false,
  "browserFallback": true,
  "maxPagesPerSearch": 30,
  "maxRetries": 4,
  "requestDelayMs": 500,
  "saveDebugPages": true,
  "includeRaw": false
}
```

# Actor output Schema

## `results` (type: `string`):

All result items of this run.

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

Summary of the run with counts and download links.

# 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"
    ],
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("egra_van/aldi-au-products").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"],
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("egra_van/aldi-au-products").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"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call egra_van/aldi-au-products --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,egra_van/aldi-au-products"
        }
    }
}
```

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/9AGPU63VpIsdtcty6/builds/tFR4E4ItzFCte9NHx/openapi.json