# ALDI Australia Grocery Category Products & Prices (`automation-lab/aldi-australia-grocery-products-prices`) Actor

Export public ALDI Australia grocery category product cards with brand, pack size, displayed AUD price, unit price, and source URL for assortment snapshots. Category URLs only; no keyword search.

- **URL**: https://apify.com/automation-lab/aldi-australia-grocery-products-prices.md
- **Developed by:** [Automation Lab](https://apify.com/automation-lab) (community)
- **Categories:** E-commerce
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.91 / 1,000 item extracteds

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 Grocery Category Products & Prices

Export public **ALDI products** from Australian grocery category pages into a structured price snapshot. Supply ALDI Australia category URLs and receive one row per unique product card with its name, brand, pack size, displayed price in AUD, comparison/unit price, product URL, source category and collection time. This is a category URL exporter, **not keyword search**, a checkout-price quote or a historical price database.

### Who is it for?

- Grocery analysts comparing the visible milk or cheese assortment with another retailer's public catalogue.
- Budget and basket researchers who need the price and unit-price text shown on a category page.
- Data teams scheduling repeat snapshots and comparing exports in their own database or spreadsheet.

### Why use this category exporter?

The Actor accepts one or more category URLs, walks category pagination, deduplicates the same product URL across input categories and stops at `maxItems`. It reads public category cards directly; no account, store postcode, paid ALDI API, image download or browser session is required for the tested categories. Each row retains the originating category and timestamp so a later export can be compared outside the Actor.

### What data is returned?

| Field | Meaning |
| --- | --- |
| `productId` | Identifier on the category card. |
| `name`, `brand` | Product name and brand; brand can be null. |
| `packSize` | Displayed package size; can be null. |
| `price`, `displayedPrice` | Numeric AUD price and original displayed price string. |
| `unitPrice` | Original comparison-price text, for example `($1.70 per 1 L)`; can be null. |
| `productUrl`, `categoryUrl` | Public source URLs. |
| `scrapedAt` | UTC collection timestamp. |

For example, the public milk category returned Farmdale Full Cream Milk 2L with `price: 3.39`, `displayedPrice: "$3.39"`, `packSize: "2 L"` and `unitPrice: "($1.70 per 1 L)"` during development. Prices can change; the example is not a current-price guarantee.

### Getting started

1. Open an ALDI Australia grocery category, such as [Milk](https://www.aldi.com.au/products/dairy-eggs-fridge/milk/k/1111111160), and copy its `/products/.../k/<id>` URL.
2. Add that URL under `startUrls`. Add more category URLs to combine their results.
3. Choose a `maxItems` limit and run. Download the default dataset in JSON, CSV or Excel from Apify.
4. Schedule runs in Apify if you need fresh snapshots, then compare datasets externally by `productId` or `productUrl`. The Actor does not compute changes or send alerts.

### Input

```json
{
  "startUrls": [
    {"url": "https://www.aldi.com.au/products/dairy-eggs-fridge/milk/k/1111111160"}
  ],
  "maxItems": 10
}
```

`startUrls` is required and accepts only HTTPS URLs on `aldi.com.au` or `www.aldi.com.au` following `/products/.../k/<number>`. Individual product URLs, keyword search and URL query strings are rejected. `maxItems` defaults to 10 and must be an integer from 1 to 10,000; it limits **unique** records across all categories. Input order is preserved. Pagination is limited to 100 pages per category.

### Output example

The default dataset contains rows like this (captured during a local milk-category run):

```json
{
  "productId": "000000000000398689",
  "name": "Full Cream Milk 2L",
  "brand": "FARMDALE",
  "packSize": "2 L",
  "price": 3.39,
  "displayedPrice": "$3.39",
  "unitPrice": "($1.70 per 1 L)",
  "productUrl": "https://www.aldi.com.au/product/farmdale-full-cream-milk-2l-000000000000398689",
  "categoryUrl": "https://www.aldi.com.au/products/dairy-eggs-fridge/milk/k/1111111160",
  "scrapedAt": "2026-09-26T06:10:37.009Z"
}
```

This row was captured in a local run on 2026-09-26; inspect the live dataset for current prices.

### How much does it cost to export ALDI Australia category products?

This Actor bills one `start` event per execution and one `item` event per output row under Apify pay-per-event pricing. The tier applicable to your account determines your price. Check the live Pricing tab before starting; runtime/proxy charges and platform pricing can change. No chargeable item is emitted for a rejected or duplicate row. At the BRONZE spend tier, the current price is $0.005 per start plus $0.001516 per delivered row: a 10-row milk export is approximately $0.02016 and a 64-row cheese export approximately $0.102024. At the GOLD, PLATINUM and DIAMOND tiers, the per-row price is $0.0009096; the same 64-row export is approximately $0.0632144 including the start. Spend tiers depend on your qualifying aggregate monthly Apify Store spend, **not** on the number of results in this Actor. These are billing estimates, not guaranteed invoices; check the live Pricing tab and account-specific fees. Revenue/payout estimates for the publisher can later change due to adjustments, refunds, fraud, disputes, taxes, corrections and contractual clawbacks. Promotional User payouts follow Apify's highest discount tier, not the base tier. The Actor has no separate charge for categories or page requests.

### Integration recipes

For a spreadsheet, schedule a bounded category run and download the default dataset as CSV. For a data pipeline, fetch the dataset JSON with your Apify token, store each row with `scrapedAt`, and compare source IDs and prices from successive runs. To build a dairy basket, include both milk and cheese categories in one input. Comparisons and notifications are downstream tasks, not Actor output.

### Apify API: cURL

```bash
curl -X POST 'https://api.apify.com/v2/acts/automation-lab~aldi-australia-grocery-products-prices/run-sync-get-dataset-items?token=YOUR_APIFY_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"startUrls":[{"url":"https://www.aldi.com.au/products/dairy-eggs-fridge/milk/k/1111111160"}],"maxItems":10}'
```

Keep your token in an environment variable or secret store rather than committed source.

### Apify API: JavaScript

```js
import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/aldi-australia-grocery-products-prices').call({
  startUrls: [{ url: 'https://www.aldi.com.au/products/dairy-eggs-fridge/milk/k/1111111160' }],
  maxItems: 10,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

### Apify API: Python

```python
import os
from apify_client import ApifyClient
client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/aldi-australia-grocery-products-prices').call(run_input={
    'startUrls': [{'url': 'https://www.aldi.com.au/products/dairy-eggs-fridge/milk/k/1111111160'}],
    'maxItems': 10,
})
for item in client.dataset(run['defaultDatasetId']).iterate_items():
    print(item['name'], item['price'])
```

### MCP access

When the Actor is available in your Apify account, register its MCP tool in Claude Code:

```bash
claude mcp add --transport http apify \
  'https://mcp.apify.com?tools=automation-lab/aldi-australia-grocery-products-prices'
```

For Claude Desktop, Cursor, or VS Code, configure the same MCP server in that client's MCP settings:

```json
{"mcpServers":{"apify":{"url":"https://mcp.apify.com?tools=automation-lab/aldi-australia-grocery-products-prices"}}}
```

Example prompt: “Export up to ten products from the ALDI Australia milk category and show their displayed AUD prices and pack sizes.” Authenticate the MCP client according to Apify's instructions.

### Limitations and reliability

Only publicly rendered category product cards are exported. The Actor does not visit product details, collect product stock, promotions, branch-specific pricing or past prices. Categories with no matching priced cards return no product rows. If ALDI changes its page markup, an unrecognized category response fails rather than silently reporting success. Temporary network, HTTP 429 and server failures are retried twice, then the run fails. A category may naturally contain fewer than `maxItems` products. Different product cards may show no brand, size or unit price.

### Data handling, AI and dependencies

The Actor sends category-page requests to the public ALDI Australia website and processes product-card text in memory. It writes product rows to the run's default Apify dataset and writes request status/diagnostics to the Apify run log. It does not request customer identities, accept login credentials, persist cookies, use an AI model, call a paid third-party data API, or send input/product records to an AI provider. ALDI receives the normal HTTP request (including the request IP and headers). Apify hosts the run and its dataset/logs; storage retention and deletion follow the user's Apify account and platform settings. Delete runs and datasets in Apify when they are no longer needed. Do not place personal or secret information in category URLs. Support questions can be raised through the Actor's Apify Store issue interface after publication.

### Legality and responsible use

Use publicly accessible data in accordance with applicable law and ALDI's site terms. Choose reasonable limits and schedules, avoid excessive requests, and do not republish product imagery or imply an ALDI endorsement. Verify critical pricing on the source page before making purchasing decisions.

### Troubleshooting

**Why was my URL rejected?** Use a public category URL ending in `/k/<id>`, not a product URL, search URL or URL containing `?page=`. The Actor controls pagination itself.

**Why are there fewer records than my limit?** `maxItems` is a ceiling, not a target. The category may have fewer priced cards or overlap another category. Open the source category to check the current visible cards.

**Why did a run fail after a request?** Review the run log for HTTP status and URL; retry later for a temporary source outage. A persistent unrecognized-response error means the page structure needs maintenance.

### FAQ

**Does it search ALDI by keyword?** No. Supply category URLs only.

**Does it calculate price changes?** No. It supplies timestamped snapshots; compare successive datasets outside the Actor.

**Can I request several categories?** Yes. The dataset is deduplicated by product URL and respects one global `maxItems`.

### Related automation-lab Actors

For another Australian retailer's catalogue, see [Woolworths Australia Grocery Products & Prices](https://apify.com/automation-lab/woolworths-australia-grocery-products-prices). It is a separate source; this Actor does not combine retailers or normalize cross-store baskets.

# Changelog

This Actor's version history is a separate document: https://apify.com/automation-lab/aldi-australia-grocery-products-prices/changelog.md

# Actor input Schema

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

Public ALDI Australia grocery category pages, such as the Milk category. Product URLs and search pages are not supported.

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

Maximum unique product records across all supplied categories.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.aldi.com.au/products/dairy-eggs-fridge/milk/k/1111111160"
    }
  ],
  "maxItems": 10
}
```

# Actor output Schema

## `overview` (type: `string`):

Open the current run's product-card dataset with the overview columns.

# 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 = {
    "startUrls": [
        {
            "url": "https://www.aldi.com.au/products/dairy-eggs-fridge/milk/k/1111111160"
        }
    ],
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/aldi-australia-grocery-products-prices").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 = {
    "startUrls": [{ "url": "https://www.aldi.com.au/products/dairy-eggs-fridge/milk/k/1111111160" }],
    "maxItems": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/aldi-australia-grocery-products-prices").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 '{
  "startUrls": [
    {
      "url": "https://www.aldi.com.au/products/dairy-eggs-fridge/milk/k/1111111160"
    }
  ],
  "maxItems": 10
}' |
apify call automation-lab/aldi-australia-grocery-products-prices --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,automation-lab/aldi-australia-grocery-products-prices"
        }
    }
}
```

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/ojDdQDii5ma0vsndi/builds/h2ZeXCLbbcmRWDREZ/openapi.json