# Coles Australia Grocery Prices & Specials Scraper (`automation-lab/coles-australia-grocery-prices`) Actor

Scrape Coles Australia grocery products by search, category, specials or link: prices, unit prices, half-price and multi-buy specials, and stock per store by store ID or postcode. Optional barcode, ingredients and nutrition.

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

## Pricing

from $1.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

## Coles Australia Grocery Prices & Specials Scraper

Export Coles Australia grocery prices, unit prices, specials and **store-level stock** from coles.com.au. Search by keyword, list whole categories, pull the half-price and multi-buy specials, or paste any Coles link, for one store, many stores, or Coles' default online prices. Add barcodes, ingredients, allergens and nutrition when you need them.

- 🔍 Search terms, 🗂️ categories, 🏷️ specials pages, 🔗 Coles links
- 🏪 Prices and stock **per store**, by store ID or postcode
- 💲 Price, was price, unit price, half-price and multi-buy offers
- 🧾 Optional barcode (GTIN), ingredients, allergens, nutrition and origin
- ⚡ About 48 products per request, no browser, no login

### What does the Coles scraper do?

It reads Coles' own product listings, the same data the coles.com.au website shows a shopper, and saves one flat row per product and store. Each row has the product's identity (ID, name, brand, size, images, link), its price for that store (shelf price, was price, unit price, special type, offer text, savings, purchase limits), its availability and the stock count Coles reports for that store, and its department, category and aisle.

Choose what to collect:

1. **Search terms** such as `milk` or `tim tam`, searched like the Coles search box.
2. **Categories** such as `dairy-eggs-fridge` or `dairy-eggs-fridge/milk`, listed in full.
3. **Specials**: all specials, half price, multi-buy or online-only.
4. **Coles links**: search, category, specials or product links copied from your browser, filters included.

Then choose **where**: store IDs, postcodes, or nothing for Coles' default online prices.

### Who is it for?

- **Grocery brands and FMCG suppliers** who check shelf price, specials and stock of their range at Coles stores every week.
- **Retail and pricing analysts** who compare Coles with Woolworths and ALDI on unit price.
- **Price-tracking and deal sites** that publish the weekly half-price and multi-buy specials.
- **Researchers and journalists** who follow grocery inflation with real shelf prices over time.
- **Category managers** who watch assortment and out-of-stocks in a department across regions.

### Why use this Coles scraper?

- **Store-level stock and prices.** Prices, specials and stock differ by store. Give store IDs or postcodes and every search is collected for each store, with the store's name, suburb, state and postcode on each row.
- **Postcodes work out of the box.** Each postcode picks a real Coles supermarket from Coles' own directory of about 860 stores.
- **Specials in one field set.** Half price, percentage off, multi-buy (quantity and total price) and reduced-to-clear all land in the same columns.
- **Unit prices you can compare.** `unitPrice` with `unitOfMeasure` (1L, 1kg, 100g, 1ea) and Coles' own text, including products sold by weight.
- **Product details only when you want them.** Barcode, ingredients, allergens, dietary claims, storage, origin and nutrition cost a little more and are off by default.
- **Honest status.** The run ends with "Got X of Y products" and the reason it stopped.

### What data can I extract from Coles?

| Field | Example | Notes |
|---|---|---|
| `productId` | `8150288` | Coles product number |
| `name`, `brand`, `size` | `Full Cream Milk`, `Coles`, `3L` | |
| `price` | `4.95` | AUD, for the row's store; null when not sold there now (`isAvailable: false` rows carry no price) |
| `wasPrice` | `9.9` | Before the special |
| `isOnSpecial`, `specialType` | `true`, `PERCENT_OFF` | Also `MULTI_SAVE`, `REDUCED_TO_CLEAR`, `SPECIAL` |
| `priceDescription`, `offerDescription` | `1/2 Price`, `Pick any 2 for $54` | Coles' wording |
| `saveAmount`, `savePercent`, `isHalfPrice` | `4.95`, `50`, `true` | |
| `multiBuyQuantity`, `multiBuyPrice` | `2`, `54` | Multi-buy offers |
| `unitPrice`, `unitOfMeasure`, `comparablePrice` | `1.65`, `1L`, `$1.65/ 1L` | |
| `isAvailable`, `stockQuantity` | `true`, `288` | Stock Coles reports for the store |
| `retailLimit`, `promotionalLimit` | `20`, `12` | Units per order |
| `department`, `category`, `aisle` | `Dairy, Eggs & Fridge`, `Milk`, `Full Cream Milk` | |
| `storeId`, `storeName`, `storeSuburb`, `storeState`, `storePostcode` | `584`, `Coles Burwood East`, ... | Null for default online prices |
| `imageUrl`, `url` | product image and link | |
| `sourceType`, `sourceInput`, `position` | `search`, `milk`, `1` | Where the row came from |
| `gtin`, `ingredients`, `allergens`, `dietary`, `storage`, `countryOfOrigin`, `originStatement`, `longDescription`, `nutrition` | `9300601186945`, ... | With **Include product details** or a product link |

### How do I scrape Coles prices?

1. Open the Actor and enter one or more **Search terms** (the prefill searches `milk`).
2. Optional: add **Categories**, a **Specials** page or **Coles links**.
3. Optional: add **Store IDs** or **Postcodes** for store prices and stock.
4. Set **Max products per search**, and the sort order if it matters.
5. Click **Start**. Rows appear in the dataset as pages arrive; export them as JSON, CSV or Excel.

### Input parameters

| Parameter | Type | Default | What it does |
|---|---|---|---|
| `searchTerms` | array of strings | | Searches on coles.com.au, one per entry |
| `categories` | array of strings | | Category slugs after `/browse/`, or browse links |
| `specials` | `none`, `allspecials`, `halfprice`, `multibuy`, `onlineonly` | `none` | Adds Coles' specials page |
| `startUrls` | array of links | | Search, browse, on-special or product links |
| `storeIds` | array of strings | | Coles store numbers, such as `584` |
| `postcodes` | array of strings | | Australian postcodes; each picks one store |
| `maxItems` | integer | `50` | Most products per search, category or specials page, per store |
| `sortBy` | `relevance`, `salesDescending`, `priceAscending`, `priceDescending`, `unitPriceAscending`, `productNameAscending`, `productNameDescending` | `relevance` | Order Coles lists products in |
| `includeDetails` | boolean | `false` | Adds barcode, ingredients, allergens and nutrition |

The limit is **per search and per store**: 2 search terms × 3 stores × 50 = up to 300 rows. A product link always gives one row.

Example input for weekly half-price specials at two stores:

```json
{
    "specials": "halfprice",
    "postcodes": ["2000", "3029"],
    "maxItems": 500,
    "sortBy": "priceAscending"
}
```

### Example output

```json
{
    "productId": "7752580",
    "name": "One Adult Hairball Cat Food With Chicken Pouch",
    "brand": "Purina",
    "size": "70g",
    "url": "https://www.coles.com.au/product/purina-one-adult-hairball-cat-food-with-chicken-pouch-70g-7752580",
    "imageUrl": "https://cdn.productimages.coles.com.au/productimages/7/7752580.jpg",
    "price": 0.95,
    "wasPrice": 1.9,
    "isOnSpecial": true,
    "specialType": "PERCENT_OFF",
    "priceDescription": "1/2 Price",
    "offerDescription": null,
    "saveAmount": 0.95,
    "savePercent": 50,
    "isHalfPrice": true,
    "isOnlineSpecial": false,
    "multiBuyQuantity": null,
    "multiBuyPrice": null,
    "unitPrice": 1.36,
    "unitOfMeasure": "100g",
    "comparablePrice": "$1.36/ 100g",
    "isWeighted": false,
    "isAvailable": true,
    "availabilityType": "InStoreAndOnline",
    "stockQuantity": 78,
    "retailLimit": 20,
    "promotionalLimit": 12,
    "department": "Pet",
    "category": "Cat & Kitten",
    "aisle": "Trays & Cans Cat Food",
    "categoryId": "68523",
    "isSponsored": false,
    "storeId": "527",
    "storeName": "Coles Wyndham Village",
    "storeSuburb": "Tarneit",
    "storeState": "VIC",
    "storePostcode": "3029",
    "sourceType": "specials",
    "sourceInput": "halfprice",
    "position": 1,
    "scrapedAt": "2026-11-18T08:43:41.069Z"
}
```

With **Include product details** the row also has, for example, `"gtin": "9300601186945"`, `"ingredients": "Homogenised and Pasteurised Full Cream Milk."`, `"allergens": "Contains Milk"`, `"countryOfOrigin": "Australian"` and a `nutrition` panel.

### How much does it cost to scrape Coles grocery prices?

You pay per row saved, plus a small fee per run. Platform usage and proxies are included.

| Event | Free and Starter plans | Scale plan | Business plan and above |
|---|---|---|---|
| Run start | $0.005 per run | $0.005 | $0.005 |
| Product (price, special, stock) | $0.001251 per row | $0.0011259 | $0.0010008 |
| Product with details (Include product details) | $0.001692 per row | $0.0015228 | $0.0013536 |

About $1.25 per 1,000 products on the Free and Starter plans, or $1.00 on Business plans. Examples on the Starter plan:

- The prefill (20 milk products, default prices): about **$0.03**.
- Weekly half-price specials at 2 stores, 500 each: about **$1.26**.
- 50 products with details at 1 store: about **$0.09**.

### Monitor Coles prices every week

1. Save your input as an Apify **Task** (for example, your brand's range as search terms plus your key stores).
2. Add a **Schedule** (weekly on Wednesday, when Coles specials change).
3. Send each run's dataset to Google Sheets, BigQuery or your own API with an integration or webhook.
4. Join on `productId` + `storeId` and compare `price`, `wasPrice` and `stockQuantity` over time.

### Integrations

Export the dataset as JSON, CSV, Excel, XML or RSS, or connect it to Google Sheets, Slack, Zapier, Make, Airbyte, Keboola or a webhook from the Integrations tab. The `specials` and `stock` dataset views give ready-made tables for promotions and store availability.

### Use the Coles scraper with the Apify API

#### cURL

```bash
curl -X POST "https://api.apify.com/v2/acts/automation-lab~coles-australia-grocery-prices/run-sync-get-dataset-items?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"searchTerms": ["milk"], "postcodes": ["2000"], "maxItems": 50}'
```

#### JavaScript

```javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/coles-australia-grocery-prices').call({
    searchTerms: ['tim tam'],
    storeIds: ['584'],
    includeDetails: true,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items.map((p) => `${p.name} ${p.size}: $${p.price} (${p.comparablePrice})`));
```

#### Python

```python
import os
from apify_client import ApifyClient

client = ApifyClient(os.environ["APIFY_TOKEN"])
run = client.actor("automation-lab/coles-australia-grocery-prices").call(
    run_input={"specials": "multibuy", "postcodes": ["3029"], "maxItems": 200}
)
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["name"], item["offerDescription"], item["stockQuantity"])
```

### Use with AI agents via MCP

Coles Australia Grocery Prices & Specials Scraper is available as a tool for AI assistants that support the [Model Context Protocol (MCP)](https://docs.apify.com/platform/integrations/mcp).

#### Setup for Claude Code

```bash
claude mcp add --transport http apify "https://mcp.apify.com?tools=automation-lab/coles-australia-grocery-prices"
```

#### Setup for Claude Desktop, Cursor, or VS Code

Add this to your MCP config file:

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

Your AI assistant authenticates with your Apify account through OAuth on first use. Selecting this Actor also adds the run and dataset tools (`get-actor-run`, `get-dataset-items` and others). Start the Actor once and keep the run ID. If the run is still going, check that same run with `get-actor-run` (for example after 2, 4 and 8 seconds, for at most 2 minutes) instead of starting a new one. When it has succeeded, read rows with `get-dataset-items` a page at a time (for example 20 rows, at most 100 in total), asking only for the `fields` you need, such as `name,price,unitPrice,unitOfMeasure,isOnSpecial,storeName`.

#### Example prompts

- "Use automation-lab/coles-australia-grocery-prices to find what Coles charges for 2L full cream milk at the store for postcode 3029, and what is half price in dairy there."
- "List this week's Coles multi-buy offers on coffee at store 584, cheapest unit price first."

Keep limits small when the results go into the model's context. Learn more in the [Apify MCP documentation](https://docs.apify.com/platform/integrations/mcp).

### Reliability and failure behavior

- Coles is protected by Imperva. The Actor uses Australian residential connections and retries a blocked or slow request on a new connection, up to 6 times.
- A category, link or store that Coles does not know stops only that source; the rest of the run continues, and the status names the failure.
- A wrong store ID ends the run before anything is collected or charged.
- An empty search (no products) finishes successfully with no rows.
- Rows are charged before they are saved, so you never pay for a row you did not get.

### Limits and data interpretation

- `stockQuantity` is the number Coles reports for online and in-store availability at that store. It is not an audited shelf count.
- Without a store, prices and stock are Coles' default online values, and `storeId` is null.
- `price` is null for products listed but not sold at that store now.
- Coles shows sponsored products in search results. A sponsored product that also appears in the normal results is saved once, with `isSponsored` set when it appeared first as an ad.
- A postcode with no Coles store uses the store with the nearest postcode in the same state; PO box postcodes (such as 8001 or 9001) stay in their state. The run log names each chosen store.
- A few Coles stores (6 of about 860, including the two Melbourne CBD Coles Central stores) sell nothing online, so Coles shows no prices for them. Postcodes skip them, and a store ID for one is reported in the log.
- Product details come from each product's page, one extra request per product, so they are slower.

### Tips for better results

- Use **categories** for full-range monitoring. Search terms follow Coles' relevance and can include near matches.
- Use **Sort order** "Unit price: low to high" to find the cheapest per kg or per litre within a limit.
- Paste a Coles link with filters (brand, dietary, special type) to collect exactly that filtered list.
- Keep `storeId` + `productId` as the key when you compare runs.

### Is it legal to scrape Coles?

The Actor collects publicly visible product and price information that Coles shows any visitor without logging in. It collects no personal data. Use the data in line with Coles' terms, Australian law and your own compliance rules, and keep request volumes reasonable. This is not legal advice.

### Data handling, AI and privacy

- No AI model is used: rows are parsed directly from Coles' own product data.
- The Actor collects product, price, stock and store information only; no personal data and no login.
- Your input, dataset and run log stay in your Apify account under its retention settings; nothing is kept between runs.
- If a run fails, sanitized error diagnostics (the input with secrets and URL queries removed, the error, and the run ID) go to our private GlitchTip error tracker and are kept for 30 days to fix the problem.
- This Actor is not affiliated with or endorsed by Coles Group. Coles is named only to describe where the public data comes from.

### FAQ

#### How do I find a Coles store ID?

Use **Postcodes** instead and the run log shows the chosen store's ID, name and suburb. You can then reuse that ID in **Store IDs**.

#### Why is the price different from what I see on coles.com.au?

Coles prices depend on the selected store. Set the same store in the Actor as in your browser, or compare with the default online prices by leaving the store fields empty.

#### Why did I get fewer products than my limit?

Coles had no more products for that search, category or specials page. The status message says "Got X of Y products: Coles has no more matching products."

#### A category fails with "Coles has no page"

Use the part of the link after `/browse/`, such as `dairy-eggs-fridge/milk`, or paste the full category link from coles.com.au.

#### Can I get Woolworths or ALDI prices too?

Yes, with our separate Actors below, and join on product name or barcode.

### Related Automation Lab Actors

- [Woolworths Australia Grocery Products & Prices](https://apify.com/automation-lab/woolworths-australia-grocery-products-prices)
- [ALDI Australia Grocery Products & Prices](https://apify.com/automation-lab/aldi-australia-grocery-products-prices)
- [ASDA Grocery Products & Prices Scraper](https://apify.com/automation-lab/asda-grocery-products-prices)

### Support

Found a problem or need a field? Open an issue on the Actor's Issues tab with your input and run ID, and we will look at it.

# Changelog

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

# Actor input Schema

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

Words to search on coles.com.au, one search per entry, exactly as you would type them in the Coles search box (Coles decides which products match). Each term is searched in every chosen store.

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

Coles categories to list in full, as the part of the link after /browse/: a department such as "dairy-eggs-fridge" or a narrower category such as "dairy-eggs-fridge/milk". A full coles.com.au/browse/ link also works.

## `specials` (type: `string`):

Also list Coles' specials page: all specials, only half-price, only multi-buy, or only online-only specials. "No specials page" adds nothing. Search results and categories always show each product's special anyway.

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

coles.com.au links copied from your browser: search results (/search/products?q=...), categories (/browse/...), specials (/on-special, with any filters you chose) or single products (/product/...). Filters in the link, such as brand, are kept.

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

Coles store numbers (such as 584 or 7689) whose prices and stock you want. Every search, category, specials page and link is collected once per store. Leave both store fields empty for Coles' default online prices, without a store.

## `postcodes` (type: `array`):

Australian postcodes. Each one picks one Coles supermarket: a store in that postcode, or the store with the nearest postcode in the same state when none is there. The chosen store is named in the run log and on every row. Combined with Store IDs; a store chosen twice is collected once.

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

The most products to save from each search, category or specials page, in each store. With 2 search terms and 3 stores the run can save up to 6 times this number. A product link always gives one row. Coles shows 48 products per page; the run stops earlier when Coles has no more.

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

The order Coles lists products in, which decides which products fill the limit. Applies to searches, categories and specials; product links ignore it.

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

Also open each product's page for its barcode (GTIN), ingredients, allergens, dietary claims, storage, country of origin, long description and nutrition panel. Slower, and charged as a product with details instead of a product. Product links always include these fields.

## Actor input object example

```json
{
  "searchTerms": [
    "milk",
    "tim tam"
  ],
  "categories": [
    "dairy-eggs-fridge/milk"
  ],
  "specials": "none",
  "startUrls": [
    {
      "url": "https://www.coles.com.au/on-special?filter_Special=halfprice"
    }
  ],
  "storeIds": [
    "584"
  ],
  "postcodes": [
    "2000"
  ],
  "maxItems": 20,
  "sortBy": "relevance",
  "includeDetails": false
}
```

# Actor output Schema

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

All product rows: price, was price, unit price, special, availability, stock and store.

## `specials` (type: `string`):

Discount columns: was price, savings, special type, half-price and multi-buy offers.

## `stock` (type: `string`):

Availability, stock count and purchase limit per store.

## `details` (type: `string`):

Barcode, ingredients, allergens, dietary claims and origin (with Include product details).

# 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"
    ],
    "maxItems": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/coles-australia-grocery-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 = {
    "searchTerms": ["milk"],
    "maxItems": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/coles-australia-grocery-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 '{
  "searchTerms": [
    "milk"
  ],
  "maxItems": 20
}' |
apify call automation-lab/coles-australia-grocery-prices --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,automation-lab/coles-australia-grocery-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/jYMOGAVCiAekTRPXf/builds/9UXNRn95nc4I4bx5s/openapi.json
