# Coles Scraper: Prices, Specials, Nutrition & Store Stock (`apimy/coles-scraper`) Actor

Scrape Coles Australia (coles.com.au): product, brand, size, price, was-price, specials, unit price, stock and category by keyword, category page or product link. Add nutrition labels, aisle and shelf stock for your store, or watch prices and get only what changed.

- **URL**: https://apify.com/apimy/coles-scraper.md
- **Developed by:** [Nikita Iakovlev](https://apify.com/apimy) (community)
- **Categories:** E-commerce, Automation
- **Features:** Limited permissions
- **Stats:** 2 total users, 0 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $0.79 / 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 Scraper** reads coles.com.au and hands back one clean table: product, brand, size, price, was-price, special flag, discount, price per unit, stock, category, photo and link. Search by keyword, walk a whole category page, pull this week's specials, or paste product links.

**$0.99 per 1,000 products** on the Apify free plan — you pay for delivered rows, nothing else. No start fee. Higher Apify plans pay less, down to $0.79.

Three things it does beyond a plain price list. It reads the **label** — ingredients, allergens, dietary claims, the nutrition panel, country of origin and GTIN. It turns the national range into **your own store**: the aisle a product sits in and how many are on that shelf. And it can **watch prices**: name a run, schedule it, and every later run returns only what moved — dropped, risen, gone on special, come back in stock.

No login, no API key, no browser. Blocked pages and errors are never billed, and a watch that finds nothing new costs nothing.

### What data does Coles Scraper return?

| Field | Example |
|---|---|
| `name`, `brand`, `size` | Coles Full Cream Milk · Coles · 3L |
| `sizeNormalised` | `3000ml` — the pack size in grams or millilitres |
| `price`, `wasPrice`, `isOnSpecial` | 6.50 · 11.00 · true |
| `savings`, `savingsPercent` | 4.50 · 41 |
| `specialType`, `offerDescription` | MULTI_SAVE · `Pick any 2 for $23` |
| `multiBuyQuantity`, `multiBuyUnitPrice` | 2 · 11.50 |
| `unitPrice`, `unitMeasure`, `unitPriceText` | 1.65 · 1l · `$1.65/ 1L` |
| `inStock`, `availability`, `purchaseLimit` | true · InStoreAndOnline · 20 |
| `category`, `subCategory`, `department` | Milk · Full Cream Milk · DAIRY |
| `description` | the product blurb from the Coles page |
| `url`, `imageUrl`, `productId` | link to the product page, its photo, the Coles product id |
| `aisle`, `availableQuantity`, `storeId` | Dairy · 260 · 0584 — when a store number is set |
| `ingredients`, `allergensContains`, `dietaryClaims`, `nutrition`, `servingSize`, `servingsPerPackage`, `countryOfOrigin`, `storageInstructions`, `gtin` | the label — when asked for |
| `watchName`, `changeType`, `previousPrice`, `priceChange`, `priceChangePercent` | weekly-shop · price-drop · 4.10 · -0.70 · -17 — on a watch |
| `query`, `scrapedAt` | the keyword that found the row, and when it was read |

Every row has the same columns whether it came from a search, a category page, the specials list or a product link, so runs can be appended to one sheet or one database table.

### How to scrape Coles prices

1. Type one or more **keywords** — `milk`, `tim tam`, `olive oil` — or paste **Coles category pages** such as `https://www.coles.com.au/browse/dairy-eggs-fridge/milk`, or **Coles product URLs**.
2. Set **Products per keyword or category** — 30 is a quick look, 500 sweeps a big aisle.
3. Press **Start**. Rows appear as they are read; download them as JSON, CSV or Excel, or read them through the API.

Leave everything empty and the Actor runs a demo search for `milk`.

### This week's Coles specials

Switch on **This week's Coles specials** and the Actor walks the Coles *On special* list — half price, down-downs, multi-buys — without a keyword. A price cut carries `wasPrice`, `savings` and `savingsPercent`; a multi-buy carries `offerDescription` ("Pick any 2 for $23"), `multiBuyQuantity` and `multiBuyUnitPrice` — Coles gives no was-price for those, so they have no discount percentage. To keep only deep price cuts, set **Minimum discount, %** to 40 or 50 (this drops multi-buys).

The same filters work on any search: **Only products on special**, **Minimum discount**, **Maximum price**, **Only what is in stock**. Rows a filter removes are not billed.

### Whole aisles, not just keywords

A keyword search returns what Coles' own search thinks is relevant. A category page returns the aisle. Paste the link from your browser (`https://www.coles.com.au/browse/pantry/breakfast`) or just the path after `/browse/` (`pantry/breakfast`), and the Actor pages through it — Coles shows 48 products a page.

### Ingredients, allergens and nutrition

Turn on **Ingredients, allergens and nutrition** and each product gains `ingredients`, `allergensContains`, `dietaryClaims`, `nutrition` (the panel per serving and per 100 g, with % daily intake), `servingSize`, `servingsPerPackage`, `countryOfOrigin`, `storageInstructions` and `gtin`.

Coles keeps the label on the product page, so each product found by a search or a category needs one more request. That request is charged as its own small add-on and capped by **Maximum label lookups per run**. Products you give as **product URLs** are read from the product page anyway and carry the label at no extra charge. Coles does not publish a label for every product — on a test of ten Tim Tam varieties, four came back with the full label and one with the GTIN only. Columns Coles leaves blank stay empty rather than being guessed.

### Aisle and shelf stock at your Coles store

Without a store, Coles answers with the national online range. Put a store number into **Coles store number** and the rows become local: `aisle` says where in the shop the product sits, and `availableQuantity` is that store's count instead of a warehouse figure.

Prices do **not** change with the store: Coles publishes one national online price, and this Actor does not pretend otherwise.

Do not know the store number? Set **What a row should be** to *One Coles store per row*, give a **postcode** (or latitude and longitude), and you get the Coles supermarkets near that point, nearest first: name, address, suburb, state, postcode, phone, distance in kilometres, whether it is open now, today's hours — and `storeId`, the number to paste back in. Coles publishes only today's trading hours to a visitor, so hours for the days ahead are left empty.

### Track Coles price changes

Give the run a **Watch name** — `weekly-shop`, `dairy` — and put it on an Apify schedule. The first run delivers the current prices as a baseline (or stays silent, your choice). Every later run under the same name delivers only products that changed, each with a `changeType`:

`price-drop` · `price-rise` · `special-started` · `special-ended` · `back-in-stock` · `out-of-stock` · `new`

along with `previousPrice`, `priceChange` and `priceChangePercent`. A run where nothing moved delivers nothing and bills nothing. **Forget the prices this watch remembers** starts a new baseline.

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

| What you get | Free plan | Bronze | Silver | Gold and above |
|---|---|---|---|---|
| Product row, per 1,000 | $0.99 | $0.95 | $0.89 | $0.79 |
| Store row, per 1,000 | $0.99 | $0.95 | $0.89 | $0.79 |
| Label lookup (add-on), per 1,000 | $0.49 | $0.45 | $0.39 | $0.35 |

There is no start fee and no charge for proxy traffic or compute — the row price is the whole price. 100 products cost about 10 cents on the free plan. Error rows, filtered rows, duplicates and unchanged products on a watch are free. **Max cost per run** in the run options is respected: the Actor stops when the ceiling is reached and says so.

### Input example

```json
{
  "keywords": ["milk", "olive oil"],
  "maxProductsPerKeyword": 50,
  "onSpecialOnly": false,
  "includeNutrition": false
}
```

Specials with at least 40% off, with shelf stock at one store:

```json
{
  "specials": true,
  "maxProductsPerKeyword": 200,
  "minDiscountPercent": 40,
  "colesStoreId": "0584"
}
```

### Output example

```json
{
  "type": "product",
  "chain": "coles",
  "chainName": "Coles",
  "productId": "8150288",
  "name": "Coles Full Cream Milk",
  "brand": "Coles",
  "size": "3L",
  "sizeNormalised": "3000ml",
  "url": "https://www.coles.com.au/product/coles-full-cream-milk-3l-8150288",
  "imageUrl": "https://productimages.coles.com.au/productimages/8/8150288.jpg",
  "price": 4.95,
  "wasPrice": null,
  "isOnSpecial": false,
  "savings": null,
  "savingsPercent": null,
  "unitPrice": 1.65,
  "unitMeasure": "1l",
  "unitPriceText": "$1.65/ 1L",
  "currency": "AUD",
  "inStock": true,
  "availability": "InStoreAndOnline",
  "department": "DAIRY",
  "category": "Milk",
  "subCategory": "Full Cream Milk",
  "description": "COLES FULL CREAM MILK 3L",
  "purchaseLimit": 20,
  "availableQuantity": 3146,
  "query": "milk",
  "scrapedAt": "2026-11-17T02:38:32.264Z"
}
```

The last row of every run is a free `type: "notice"` line with the run summary — filter it out with `type != "notice"`.

### Things worth knowing

- **Barcodes.** Coles search does not match barcodes, even of products it sells. Search by product name; `gtin` is returned with the label when Coles publishes it.
- **Loose search.** Coles search is forgiving: a misspelt or very long keyword still returns the nearest products rather than nothing. Check `name` against what you asked for, or use a category page when you need a precise aisle. A keyword that finds nothing at all gets its own free notice line.
- **Bot check.** Coles sits behind a bot check and turns most datacenter and foreign addresses away. The Actor retries through Australian residential addresses on its own; you do not pay for retries. If Coles refuses for a long stretch, the searches it could not reach are listed in the `NOT_ATTEMPTED` record so you can run them again, and they are not charged.
- **No Health Star Rating.** Coles does not publish it on its site, so there is no such column.
- **Unavailable products.** Coles shows no price for a product it currently cannot supply: `price` is empty and `inStock` is false. Use **Only what is in stock** to drop them.
- **Online range.** Prices and specials are the ones on coles.com.au. Catalogue-only or in-store-only promotions that the site does not show are not in the data.

### Use it from code or from an AI agent

The Actor runs through the Apify API, the Apify clients for Python and JavaScript, Make, n8n and Zapier, and it is available to AI agents through the Apify MCP server. The input is plain JSON, and the output rows are flat — one product, one object.

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_API_TOKEN>")
run = client.actor("apimy/coles-scraper").call(run_input={"keywords": ["milk"], "maxProductsPerKeyword": 30})
for row in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(row["name"], row["price"], row["unitPriceText"])
```

### FAQ

**Is it legal to scrape Coles?** The Actor reads only what coles.com.au shows to any visitor without an account: products, prices and store addresses. It collects no personal data. How you use the data is your responsibility — check the terms that apply to your project.

**Do prices differ by state or store?** Coles publishes one national online price. A store number changes the aisle and the shelf quantity, not the price.

**How fresh is the data?** Every run reads the live site; nothing is served from a cache. `scrapedAt` is the moment the row was read.

**How many products can one run return?** Up to **Maximum rows per run** (5,000 by default; raise it for a full sweep). A keyword or a category gives as many products as Coles lists for it.

**Something is missing or wrong?** Open an issue on the Issues tab with the run ID — it is read daily.

# Changelog

This Actor's version history is a separate document: https://apify.com/apimy/coles-scraper/changelog.md

# Actor input Schema

## `keywords` (type: `array`):

Products to search on coles.com.au — <b>milk</b>, <b>nappies</b>, <b>tim tam</b>, <b>olive oil</b>. One search per keyword; each product comes back as one row with price, was-price, unit price, stock and category.

## `specials` (type: `boolean`):

Walk the Coles <b>On special</b> list (half price, down-downs, multi-buys) without typing a keyword. Depth is set by <b>Products per keyword or category</b>.

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

Whole aisles instead of a keyword. Paste a Coles category link such as <b>https://www.coles.com.au/browse/dairy-eggs-fridge/milk</b>, or just the path after /browse/ (<b>dairy-eggs-fridge/milk</b>). The Actor pages through the aisle up to <b>Products per keyword or category</b>.

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

Specific products instead of, or alongside, a search. Paste Coles product links, e.g. <b>https://www.coles.com.au/product/coles-full-cream-milk-2l-8150288</b>. A product page also carries the label: ingredients, allergens, nutrition panel.

## `maxProductsPerKeyword` (type: `integer`):

How deep to go for each keyword, category page or the specials list. Thirty is a fast look; raise it to sweep a whole aisle (Coles shows 48 products a page).

## `output` (type: `string`):

<b>One product per row</b> — prices, specials, stock, category (the default). <b>One Coles store per row</b> — the Coles supermarkets near a postcode or a pair of coordinates, nearest first, with the store number you can paste into "Coles store number".

## `colesStoreId` (type: `string`):

Set it and product rows come back with the aisle the product sits in and the quantity that store has on the shelf, instead of the national range. Get the number from a store row of this Actor (<b>One Coles store per row</b>), or from the URL of your store on the Coles site.

## `includeNutrition` (type: `boolean`):

Adds ingredients, allergens, dietary claims, the nutrition panel, serving size, country of origin and GTIN to every product found by search or category. Coles keeps the label on the product page, so each product needs one extra request, charged as a separate add-on. Products given as product URLs carry the label anyway, at no extra charge.

## `maxNutritionLookups` (type: `integer`):

A ceiling on the extra label requests, so a large sweep cannot surprise you.

## `postcode` (type: `string`):

An Australian postcode, used to find the Coles stores near it when rows are stores. Coordinates can be given instead.

## `latitude` (type: `string`):

Coordinates instead of a postcode, e.g. <b>-33.8688</b>. Both latitude and longitude must be given.

## `longitude` (type: `string`):

The matching longitude, e.g. <b>151.2093</b>.

## `watchName` (type: `string`):

Give this run a name — <b>weekly-shop</b>, <b>dairy</b> — and every later run under the same name returns only products whose price moved, that went on or off special, that came back in stock, or that are new. Leave empty to get everything found, every time.

## `deliverBaseline` (type: `boolean`):

The first run of a new watch has nothing to compare against. Leave this on to receive the current prices as the starting point; turn it off to start silently and hear only about movements from now on.

## `resetWatch` (type: `boolean`):

Wipe this watch's memory and start a new baseline on this run.

## `onSpecialOnly` (type: `boolean`):

Keep only products with a was-price or a special flag.

## `minDiscountPercent` (type: `integer`):

Keep only products discounted by at least this much. Zero means no minimum.

## `maxPrice` (type: `integer`):

Ignore anything dearer than this. Zero means no limit.

## `inStockOnly` (type: `boolean`):

Drop products Coles reports as unavailable.

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

A hard ceiling on what one run delivers and bills.

## `concurrency` (type: `integer`):

How many Coles requests to run at once.

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

Apify Proxy with residential addresses is on by default, because Coles refuses most datacenter traffic. The Actor still tries the cheaper datacenter pool first and moves to Australian residential addresses as soon as it is refused. You are not billed for proxy traffic separately.

## Actor input object example

```json
{
  "keywords": [
    "milk"
  ],
  "specials": false,
  "categories": [],
  "productUrls": [],
  "maxProductsPerKeyword": 30,
  "output": "products",
  "colesStoreId": "",
  "includeNutrition": false,
  "maxNutritionLookups": 200,
  "postcode": "",
  "latitude": "",
  "longitude": "",
  "watchName": "",
  "deliverBaseline": true,
  "resetWatch": false,
  "onSpecialOnly": false,
  "minDiscountPercent": 0,
  "maxPrice": 0,
  "inStockOnly": false,
  "maxItems": 5000,
  "concurrency": 3,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

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

One row per Coles product — name, brand, size, price, was-price, discount, unit price, availability, category and link — or one row per Coles store when store rows are chosen.

## `runSummary` (type: `string`):

JSON summary of the run: rows delivered, rows filtered out, failed inputs (free) and request statistics.

## `notAttempted` (type: `string`):

JSON list of inputs the run did not reach (time limit or "Max cost per run"). Not charged — pass them as input to a new run to continue. Present only when the run stopped early.

# 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 = {
    "keywords": [
        "milk"
    ],
    "maxProductsPerKeyword": 30,
    "output": "products",
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("apimy/coles-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 = {
    "keywords": ["milk"],
    "maxProductsPerKeyword": 30,
    "output": "products",
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("apimy/coles-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 '{
  "keywords": [
    "milk"
  ],
  "maxProductsPerKeyword": 30,
  "output": "products",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call apimy/coles-scraper --silent --output-dataset

```

## MCP server setup

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