# ALDI Australia Scraper — Products, Prices & Special Buys (`fabrikit/aldi-australia-scraper`) Actor

Scrape aldi.com.au without a browser: keyword search, any category, every Special Buys week or the full catalogue. Price, unit price, pack size, brand, category, on-sale date, images and link; optional description and ingredients. From US$0.40 per 1,000 products.

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

## Pricing

from $0.40 / 1,000 product scrapeds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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 — Products, Prices & Special Buys

**ALDI Australia Scraper extracts products and prices from aldi.com.au**: run a keyword search, list any department or category, pull every Special Buys week ALDI has announced, or read the whole catalogue of about 3,000 products. Each product becomes one flat JSON row with the shelf price in AUD, the unit price (per 100 g, per 1 L ...), pack size, brand, category path, Special Buys on-sale date, images and the product link. It works over plain HTTP against the same data the ALDI website loads, so no browser and no login are needed, and the default run finishes in a few seconds.

### Data you get

- **Product:** SKU, name, brand, pack size, selling unit, whether it is priced by weight, discontinued flag, product link, main image and all image links.
- **Price:** `price` (number, AUD) and the text ALDI shows (`$17.99`), unit price as a number plus its measure (`1.8` per `100 g`) and as text, and, when ALDI prints them, per-piece price, was price, savings text, price notes and container deposit.
- **Special Buys:** `isSpecialBuy`, the on-sale date (`2026-11-04`) and the label from the tile ("On Sale Wed 04 Nov", "While Stocks Last").
- **Category:** department, category, full path (`Pantry > Tea, Coffee & Hot Chocolate`) and ALDI's category key.
- **Liquor:** minimum age and alcohol content when published.
- **Details add-on (optional):** description as plain text, ingredients, storage and usage instructions, country of origin, allergens, claims such as "May contain", and warnings. ALDI fills these unevenly: most products have a description, many also have storage instructions, fewer have ingredients or allergens.

Every run also writes a `SUMMARY` record: products saved per input line, how many products ALDI lists for each, errors, and request statistics.

### How to use it

Fill one or more inputs; they can be combined in one run and duplicates are skipped.

| Input | What it does |
|---|---|
| `searchTerms` | One ALDI search per keyword: `coffee`, `nappies`, `olive oil`. |
| `categories` | Names, slugs or links: `Pantry`, `freezer`, `dairy-eggs-fridge/cheese`, `Lower Prices`, `Limited Time Only`, or a link such as `https://www.aldi.com.au/products/bakery/k/920000000`. |
| `specialBuys` | `all`, `upcoming`, `on-sale-now`, a date like `2026-11-04`, or a Special Buys link, optionally with a theme (`?theme=Liquor`). |
| `productUrls` | Product links or SKUs. These rows always include the details at no extra cost. |
| `scrapeAllProducts` | Walk the full catalogue. With no other input, this is what the run does. |
| `brands` | Keep only these brands (ALDI filters them for you). |
| `productType` | All products, only Special Buys, or only the regular range. |
| `sortBy` | Relevance, price or name order. |
| `includeDetails` | Adds the details listed above (one extra request per product, billed as an add-on). |
| `maxItems`, `maxItemsPerQuery` | Exact limits for the run and for each input line. |

**Quick search (the default input):**

```json
{ "searchTerms": ["coffee"], "maxItems": 50 }
```

**Everything in the next Special Buys weeks, with descriptions:**

```json
{ "specialBuys": ["upcoming"], "includeDetails": true, "maxItems": 500 }
```

**Price tracking for two aisles, cheapest first:**

```json
{
  "categories": ["dairy-eggs-fridge/cheese", "https://www.aldi.com.au/products/pantry/k/970000000"],
  "sortBy": "priceAsc",
  "maxItemsPerQuery": 200,
  "maxItems": 400
}
```

**One brand across the catalogue:**

```json
{ "scrapeAllProducts": true, "brands": ["LAZZIO"], "maxItems": 100 }
```

### Example output

A real row from a test run (23 October 2026, four of the image links shortened to one):

```json
{
  "sku": "000000000000366741",
  "name": "Coffee Beans Medium 1kg",
  "brand": "LAZZIO",
  "packSize": "1 kg",
  "price": 17.99,
  "priceText": "$17.99",
  "currency": "AUD",
  "unitPrice": 1.8,
  "unitPriceText": "$1.80 per 100 g",
  "unitPriceMeasure": "100 g",
  "wasPriceText": null,
  "containerDeposit": null,
  "sellingUnit": "ea",
  "isSoldByWeight": false,
  "isSpecialBuy": false,
  "specialBuyDate": null,
  "availabilityText": null,
  "badges": [],
  "department": "Pantry",
  "category": "Tea, Coffee & Hot Chocolate",
  "categoryPath": "Pantry > Tea, Coffee & Hot Chocolate",
  "categoryKey": "1111111175",
  "ageRestriction": null,
  "imageUrl": "https://dm.apac.cms.aldi.cx/is/image/aldiprodapac/product/jpg/scaleWidth/1500/96f09a52-56d0-4d04-9a60-2f9b69bab9c6/lazzio-coffee-beans-medium-1kg",
  "url": "https://www.aldi.com.au/product/lazzio-coffee-beans-medium-1kg-000000000000366741",
  "source": "category:pantry",
  "scrapedAt": "2026-10-23T05:21:44.381Z"
}
```

A Special Buys row carries, for example, `"isSpecialBuy": true`, `"specialBuyDate": "2026-10-24"` and `"availabilityText": "On Sale Sat 24 Oct"`.

### Good to know

- **Prices** are the catalogue prices published on aldi.com.au. ALDI Australia does not sell groceries online, so there are no per-store stock levels, and ALDI itself notes that a store can occasionally differ from the website.
- **Special Buys** usually have no category on the listing; with `includeDetails` some of them get one from the product page.
- **Lower Prices**, **Super Savers** and **Limited Time Only** are categories on the site, so you can list them by name.
- A broad search is capped by ALDI's own results (for example about 80 products for "coffee"); use categories or the full catalogue for complete coverage.

### Use cases

- **Price monitoring:** track shelf and unit prices of ALDI products week by week and compare them with other supermarkets.
- **Special Buys alerts:** know what goes on sale next Wednesday or Saturday, with prices, as soon as ALDI lists the week on its website.
- **Retail and FMCG analysis:** assortment by department, private-label share, pack sizes and price points.
- **Deal sites and apps:** feed product names, prices, images and links into a comparison site, newsletter or chatbot.

### Pricing

Pay per product saved, nothing per run:

- **US$0.40 per 1,000 products** (`product-result`, US$0.0004 each).
- **Details add-on: US$0.30 per 1,000 products** (`product-details`), only when `includeDetails` is on and the details were found.

Examples: 1,000 products = US$0.40; the whole catalogue (about 3,250 products) = about US$1.30, or about US$2.28 with details. Duplicates are never charged, and the run stops at the maximum charge you set.

### Compared with other options

Other ALDI Australia Actors in the Apify Store charge roughly US$0.40 to US$3.00 per 1,000 products. This one matches the lowest price and covers keyword search, categories by name or link, Special Buys weeks and themes, brand filtering, unit prices as numbers and an optional details add-on in one Actor. It is built on the same approach as our [Woolworths Australia Scraper](https://apify.com/fabrikit/woolworths-au-scraper), so you can put ALDI and Woolworths prices side by side with the same kind of rows.

### Integrations

Export results as JSON, CSV or Excel, or read them through the Apify API and the JavaScript or Python clients. Schedule a weekly run, send rows to Google Sheets, Slack or a webhook, or use the Actor inside **n8n**, **Make** and **Zapier**. AI agents can call it as a tool through the Apify **MCP** server.

### FAQ

**Is scraping ALDI legal?** The Actor reads public product information that any visitor sees without an account, at a gentle pace (about four requests per second at most). It collects no personal data. You are responsible for how you use the data and for respecting ALDI's terms.

**Do I need a proxy?** The default Apify datacenter proxy is the starting point. The ALDI data host rejects non-browser clients, so the Actor sends browser-like requests; if it is still blocked, it switches to an Australian residential proxy on its own.

**Why fewer products than `maxItems`?** The search, category or Special Buys week simply has fewer products, a brand or product-type filter removed some, or `maxItemsPerQuery` capped a line. The `SUMMARY` record shows the count ALDI reports for each input.

**Limits?** Up to 100,000 products per run. Without details the full catalogue is about 55 requests of 60 products; with details, add one request per product.

### En español

ALDI Australia Scraper extrae productos de aldi.com.au por palabra clave, categoría, semana de Special Buys o el catálogo completo (unos 3.000 productos): precio en AUD, precio por unidad (por 100 g, por 1 L), tamaño, marca, categoría, fecha de venta de Special Buys, imágenes y enlace. Opcionalmente agrega descripción, ingredientes, conservación y alérgenos. Sin navegador ni cuenta. Precio: US$0,40 por 1.000 productos; detalles US$0,30 por 1.000.

### Changelog

- **0.1 (October 2026):** first release. Keyword search, categories by name, slug, link or key, Special Buys by week and theme, product links, whole catalogue, brand and product-type filters, sorting, optional details add-on, automatic residential fallback.

# Actor input Schema

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

One ALDI search per keyword, e.g. coffee, nappies, olive oil.

## `categories` (type: `array`):

Department or category names, slugs or links, one per line: Pantry, freezer, dairy-eggs-fridge/cheese, Lower Prices, Limited Time Only, or https://www.aldi.com.au/products/bakery/k/920000000. Subcategories are included.

## `specialBuys` (type: `array`):

Special Buys weeks to collect: 'all' (every week ALDI currently lists), 'upcoming' (not on sale yet), 'on-sale-now', a date such as 2026-11-04, or a Special Buys link (with or without a theme, e.g. https://www.aldi.com.au/special-buys/2026-10-21?theme=Liquor).

## `productUrls` (type: `array`):

aldi.com.au product links (…/product/…-000000000000398689) or SKUs. These rows always include description and ingredients at no extra charge.

## `scrapeAllProducts` (type: `boolean`):

Read every product on aldi.com.au (about 3,000), page by page, up to the maximum below.

## `brands` (type: `array`):

Optional brand filter applied by ALDI to keyword, category, Special Buys and catalogue results, e.g. FARMDALE, EXPRESSI. Case does not matter.

## `productType` (type: `string`):

Keep every product, only Special Buys (products with an on-sale date) or only the regular range.

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

Order in which ALDI returns the results (matters when the maximum cuts a list).

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

One extra request per product to add description, ingredients, storage and usage instructions, country of origin, allergens and claims. Charged as the product-details event.

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

Total products to save across all inputs (exact). Duplicates are skipped and not charged.

## `maxItemsPerQuery` (type: `integer`):

Optional cap for each input line, so one broad query does not use the whole run.

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

Apify datacenter proxy by default. If ALDI blocks it, the run moves to an Australian residential proxy on its own.

## Actor input object example

```json
{
  "searchTerms": [
    "coffee"
  ],
  "scrapeAllProducts": false,
  "productType": "all",
  "sortBy": "relevance",
  "includeDetails": false,
  "maxItems": 50,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

One row per ALDI product with prices, unit price, Special Buys date and category

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

Per-query counts, errors and network statistics of the run

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

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

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

```

## MCP server setup

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