# Coles Products Scraper — Prices, Specials & Store Stock (`fetch_cat/coles-products-scraper`) Actor

Collect Coles grocery prices, specials, nutrition and store availability. Search, browse categories, compare stores and export public store details with the required connection included.

- **URL**: https://apify.com/fetch_cat/coles-products-scraper.md
- **Developed by:** [Fetch Cat](https://apify.com/fetch_cat) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.55 / 1,000 product or store results

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

Use this Coles scraper to export grocery products, AUD prices, specials and store availability for repeatable price snapshots. Search by keyword, browse departments, look up products or collect public store information.

Build a Coles products list with store-attributed shelf and unit prices. Track Coles product availability across locations, and add available barcodes, ingredients, nutrition and variants when you need full details.

### Quick start

Paste this input into the Actor, run it and open the dataset:

```json
{
  "searchTerms": ["milk"],
  "storeIds": ["584"],
  "maxItems": 60
}
```

The required Australian connection is automatic and included. You do not need proxy settings. A result limit can stop a search before every matching product has been collected.

Prefer a video guide? This short Apify walkthrough shows you how to set up and run an Actor. It uses a different Actor, but the setup steps are the same.

https://youtu.be/1OW8gOqlZbY?t=25

### What you get

| Workflow | Returned data |
| --- | --- |
| Product discovery | Search and category products, names, brands, sizes, images and links |
| Price snapshots | Store-attributed AUD prices, unit pricing, savings and available offer information |
| Product details | Available GTIN, ingredients, allergens, nutrition, country information and size or variety alternatives |
| Store directory | Store IDs, names, addresses, coordinates, contact information, services and opening hours |
| Completion information | A run summary with per-input outcomes, source totals and reasons for stopping early |

### Who is it for?

- **Retail price analysts** comparing Coles product and unit prices across stores.
- **Grocery comparison services** matching products using source IDs and available GTINs.
- **Inventory researchers** studying public product availability and store coverage.

### Input settings and example inputs

Choose at least one search, product, category, specials, catalogue or store-directory workflow. Arrays contain strings, including numeric IDs.

| Setting | Purpose |
| --- | --- |
| `searchTerms` | Up to 30 grocery searches |
| `startUrls` | Up to 100 public Coles product, category, search, brand, specials or numbered store links |
| `productIds` | Up to 100 direct product IDs. Direct products return full details |
| `departments` | Up to 30 source category IDs or browse paths, such as `dairy-eggs-fridge` |
| `storeIds` | Store IDs for product comparisons or explicit directory lookups. Product workflows default to store `584` when no location is supplied |
| `postcodes` | Up to 20 Australian postcodes. Product searches use the nearest returned store for each matched locality |
| `storeDirectory` | Return store records. With postcodes, collect nearby stores. Without a location, use the published national store index |
| `allStores` | Apply the selected product workflow across indexed stores. Combine with a meaningful result limit |
| `fullCatalog` | Browse all departments, subject to your limits |
| `includeDetails` | Add full details to search/category results |
| `specials` | `none`, `allspecials`, `halfprice`, `multibuy` or `onlineonly` |
| `brands`, `dietary`, `allergens` | Source facet names or IDs. Use source-supported labels such as `Coles`, `Vegan` or `Lactose Free` |
| `sortBy` | `relevance`, `priceAscending`, `priceDescending`, `productNameAscending` or `productNameDescending` |
| `maxItems` | Global product/store result limit, default 100 and maximum 50,000 |
| `maxRequests` | Source request limit, default 1,000 and maximum 5,000 |
| `maxRunSeconds` | Processing limit from 30 to 1,800 seconds, default 1,800 |

Use the input form for the complete constraints. Unknown fields and connection overrides are rejected. Supported URL parameters include `q`, `sortBy` and source facet filters. Collection starts from the first matching page rather than resuming at a URL's `page` value.

**Compare one product across stores:**

```json
{
  "productIds": ["8150288"],
  "storeIds": ["584", "313"],
  "maxItems": 2
}
```

**Find nearby public stores:**

```json
{
  "storeDirectory": true,
  "postcodes": ["3000"],
  "maxItems": 30
}
```

**Collect dairy half-price offers:**

```json
{
  "departments": ["dairy-eggs-fridge"],
  "specials": "halfprice",
  "storeIds": ["584"],
  "sortBy": "priceAscending",
  "maxItems": 50
}
```

### Output data

The dataset contains `product` and/or `store` records, distinguished by `recordType`. A product observed at two stores produces two records. The same product/store identity is not saved again when inputs overlap.

| Fields | Meaning |
| --- | --- |
| `recordType`, `storeId`, `name` | Record type and source identity |
| `productId`, `url`, `brand`, `size`, `images` | Product identity and presentation |
| `currency`, `price`, `previousPrice`, `savings`, `savingsPercent` | AUD shelf-price and savings information, nullable when unavailable |
| `unitPrice`, `unitPriceText`, `unitPricing` | Source unit-price values and their measurement basis |
| `available`, `availabilityStatus`, `availableQuantity` | Source availability. A price alone does not mean the product is in stock |
| `offer`, `purchaseLimits`, `locations` | Available promotion, purchase and aisle information |
| `detailsIncluded`, `gtin`, `ingredients`, `allergens`, `nutrition`, `variants` | Detail coverage and available enrichment |
| `address`, `position`, `hours`, `services` | Store-only information |
| `sourceContext`, `scrapedAt` | Input attribution and collection time |

For example, a captured full-detail observation for product `8150288` at store `584` included `currency: "AUD"`, `price: 4.95`, `unitPrice: 1.65` and `gtin: "9300601186945"`. This is a historical observation, not a current price quote.

Open the run's `SUMMARY` record for input outcomes and coverage. A legitimate no-match or unavailable target can return no rows. A result, request, time or buyer-budget limit can produce incomplete coverage. Check `complete`, `stopReason` and per-input outcomes before treating a snapshot as exhaustive.

#### Download your results

Open your run's dataset, choose **Export** and select JSON, CSV or Excel. JSON keeps nested fields together. CSV and Excel are useful when you want to review the records in a spreadsheet.

See [Apify's download and export guide](https://docs.apify.com/storage/dataset#apify-console) for the available formats and field options.

### Pricing

The `apify-actor-start` startup charge applies when a run starts, including a run that produces no results. The `result` event charges for each saved product or store record. The `details` event adds a charge for each saved product with full details, including direct product lookups.

The `source-request` event charges for each completed source request, including searches, product/store lookups, category discovery and initial setup. A completed request is chargeable even when nothing matches. Cached lookups and transport failures are not charged as completed work. Work completed before a later extraction or storage failure remains chargeable. Open `WORK_RECEIPT` and `SUMMARY` to review completed work and charge counts.

No-match diagnostics and unavailable targets are not billed as product or store records. The required connection is included in these charges. Use the request and result limits together with Apify's run charge limit to bound your purchase.

See the [live Pricing tab](https://apify.com/fetch_cat/coles-products-scraper/pricing) for current rates and discounts.

### Tips for best results

- **Choose an explicit store.** Keep the same store IDs when comparing snapshots over time.
- **Start with a small sample.** Inspect product matches and unit-price measurements before expanding the workload.
- **Add details when you need matching or nutrition.** Listing-only snapshots are enough for many price comparisons.
- **Check completion before analysis.** A bounded snapshot is not necessarily the complete category or catalogue.

### Limits and caveats

- Only public Coles storefront data is collected. This is not an official Coles service.
- Prices, offers, stock and store hours can change. Availability is not a reservation or checkout guarantee.
- Missing detail fields remain absent or null. Review text and reverse-barcode product discovery are not supported promises.
- Postcode discovery uses the source's returned localities and nearby stores. A capped directory is not a complete national directory.
- Blocking, unexpected source responses, storage faults and billing faults fail the run rather than being presented as no matches. Useful records already saved remain accessible.

### Automation and integrations

#### Save your settings for next time

Once you have an input that works for you, [save it as an Apify task](https://docs.apify.com/actors/running/tasks). This keeps your settings together so you can use them again without filling in the form from scratch.

#### Run on a schedule

You can configure [Apify schedules](https://docs.apify.com/actors/running/schedules) in your own account when you want recurring snapshots. The Actor does not create or enable schedules for you.

Each run collects a new snapshot. Compare records by product and store in your own workflow to identify price changes.

#### Send results to your other tools

Use **n8n, Make or Zapier** to connect this scraper to the rest of your workflow. For example, pass results to an AI assistant or append them to a spreadsheet. Follow the [Apify integration guides](https://docs.apify.com/integrations) for your chosen tool.

An [Apify webhook](https://docs.apify.com/integrations/webhooks) can notify your app when a run finishes or fails. Your app can then fetch results or handle the failure.

### API usage

Collect grocery snapshots from your app using the same input as the Console. The Node.js and Python examples wait for completion, then read the dataset. The cURL example starts a run. Follow that run to completion and fetch its `defaultDatasetId` rather than launching it again.

See Apify's [JavaScript client guide](https://docs.apify.com/api/client/js), [Python client guide](https://docs.apify.com/api/client/python) and [Actor runs API reference](https://docs.apify.com/api/v2/acts-runs-post).

#### cURL

```bash
curl --request POST \
  'https://api.apify.com/v2/acts/fetch_cat~coles-products-scraper/runs' \
  --header "Authorization: Bearer $APIFY_TOKEN" \
  --header 'Content-Type: application/json' \
  --data '{"searchTerms":["milk"],"storeIds":["584"],"maxItems":60}'
```

#### Node.js

```javascript
import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('fetch_cat/coles-products-scraper').call({
  searchTerms: ['milk'], storeIds: ['584'], maxItems: 60,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

#### Python

```python
import os
from apify_client import ApifyClient
client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('fetch_cat/coles-products-scraper').call(run_input={
    'searchTerms': ['milk'], 'storeIds': ['584'], 'maxItems': 60,
})
print(client.dataset(run['defaultDatasetId']).list_items().items)
```

### MCP and AI agents

Use the [Apify MCP server](https://mcp.apify.com/) to let a compatible assistant discover the Actor, inspect its input and retrieve results. Discovery depends on the Actor's public availability and current platform permissions. Follow the [official setup and sign-in guide](https://docs.apify.com/mcp).

The [official Apify plugin](https://docs.apify.com/agents/plugins) can help set up supported coding assistants. Alternatively, use [Apify AI in Console](https://docs.apify.com/account/apify-ai), currently in beta. Normal run charges apply.

Client setup guides:

- **Claude and Claude Code:** [Apify setup](https://docs.apify.com/integrations/claude).
- **ChatGPT and Codex:** [Apify setup](https://docs.apify.com/integrations/openai).
- **Grok Bot:** [Apify plugin guide](https://docs.apify.com/integrations/grok-bot).
- **Gemini CLI:** [MCP server configuration](https://geminicli.com/docs/tools/mcp-server/).

For a focused setup exposing only this Actor in a compatible client:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=fetch_cat/coles-products-scraper"
    }
  }
}
```

Sign in when your client asks. If it uses a Bearer token, keep that token in its secure configuration.

Already using `https://mcp.apify.com`? Ask the assistant to find `fetch_cat/coles-products-scraper`, inspect its settings and run a bounded request. Both options use Apify's shared hosted server. Read results from the returned run and dataset. Follow an existing running operation instead of creating duplicates.

**Example requests:**

- “Collect 60 milk products at Coles Burwood East and make a spreadsheet of shelf and unit prices.”
- “Get the full details of Coles product 8150288 at stores 584 and 313, then compare the returned prices and availability.”
- “Find public Coles stores near postcode 3000 and summarize their addresses and opening hours.”

The scraper retrieves data. Comparison, summaries and spreadsheet preparation are performed by your assistant. Review the [live Pricing tab](https://apify.com/fetch_cat/coles-products-scraper/pricing) before authorizing charges.

### Pay with x402

A funded agent can use [Apify's experimental x402 flow](https://docs.apify.com/integrations/x402) to obtain a prepaid, spend-capped API token through [Apify AGI](https://agi.apify.com/). It can then use the API or a supported authenticated MCP connection, subject to current Actor access permissions.

Direct per-request MCP payments are a different option with separate eligibility requirements. Check the official guide rather than assuming every payment route is available. Apify handles payment. Keep wallet keys and payment tokens in secure configuration, not prompts or input examples.

For other supported payment methods, see the [agentic payment guide](https://docs.apify.com/agents/payments).

### FAQ

**Can I compare prices across stores?** Yes. Supply explicit `storeIds`. Each product/store combination has its own row. Set a global result limit large enough for the stores you want to compare.

**Do I need proxy credentials?** No. The required connection is included and automatic. Connection replacement and disable controls are not accepted.

**Can I get ingredients and nutrition?** Enable `includeDetails` for listing workflows or use a direct product ID/URL. Available source fields are returned. Some products do not provide every detail.

**Why is the dataset empty?** Check `SUMMARY`. A supported no-match or unavailable target can legitimately return nothing. Startup and completed-request charges can still apply. Blocking or an unexpected response is reported as a failure, not as proof that no products exist.

### Related Actors

- [ALDI Australia Products & Prices Scraper](https://apify.com/fetch_cat/aldi-australia-products-scraper) — Collect Australian ALDI grocery prices, categories and specials for another retailer's snapshot.
- [Walmart Products Scraper](https://apify.com/fetch_cat/walmart-products-scraper) — Collect Walmart search products, prices and availability for US retail research.
- [Amazon Products & Search Scraper](https://apify.com/fetch_cat/amazon-products-search-scraper) — Retrieve Amazon product search results and details across supported marketplaces.
- [Costco Products Scraper](https://apify.com/fetch_cat/costco-products-scraper) — Collect public Costco products, prices and stock information for warehouse-retail research.
- [Walmart Reviews Scraper](https://apify.com/fetch_cat/walmart-reviews-scraper) — Export public Walmart reviews and ratings when product feedback, rather than grocery pricing, is your goal.

### Support and feedback

For custom additions or integrations, email <hello@fetchcat.dev>.

Found an error or have a feature request? Open an issue from the Actor page with the run URL, a non-sensitive input example and what you expected.

Need help sharing it? See [Apify’s guide to sharing a run when reporting an issue](https://docs.apify.com/account/collaboration/general-resource-access#automatically-sharing-runs-via-actor-issues). Sharing a run can give the developer access to its input, logs and results, so use a run that contains no sensitive data. Please leave out API tokens, passwords, cookies, private documents and personal data. Use a public sample URL or a redacted example instead.

Tried this scraper? [Leave an honest review from the Actor page](https://apify.com/fetch_cat/coles-products-scraper). Your feedback helps other users choose the right tool and helps us improve it. Your feedback means a lot to us.

Made with care for curious people, AI agents and the possibilities in data. ♥

# Changelog

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

# Actor input Schema

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

Product searches such as milk or Tim Tam. Choose at least one search, URL, product ID, department, specials, full catalogue or store directory workflow.

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

HTTPS Coles product, browse category, brand, search/products?q=, on-special or numbered store links. Source sortBy and filter_Brand, filter_Dietary, filter_Allergen and filter_Special parameters are preserved. Store links select those stores.

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

Numeric Coles product IDs with 4 to 7 digits. Direct product lookups always include full details and incur both result and detail events.

## `departments` (type: `array`):

Coles category paths such as dairy-eggs-fridge or dairy-eggs-fridge/milk, or a source category ID. The current taxonomy is also saved as CATEGORIES-STOREID when browsing.

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

Collect these specials, or apply this source filter to selected searches/categories. none disables the specials filter.

## `fullCatalog` (type: `boolean`):

Traverse the current online departments. Global item, request and runtime limits still apply. SUMMARY identifies truncation. This is the online catalogue, not a printed catalogue PDF or a promise of every physical-store item.

## `storeDirectory` (type: `boolean`):

Export public Coles supermarket addresses, coordinates, services and trading hours. With postcodes, include stores within 25 km, up to 100 per postcode. Without locations, enumerate Coles supermarket stores from Coles' public store sitemap and retrieve each store's details in bounded batches. SUMMARY reports the published-index count, actual processed stores and any truncation. This is published Coles coverage, not an inferred nearest-store sample.

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

Numeric Coles supermarket IDs. For example 584 is Burwood East, 313 is Karratha. Omitted locations use store 584. Each product/store pair is a separate result.

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

Four-digit Australian postcodes. Select the nearest matching Coles within 100 km for product prices. Unmatched postcodes are reported, never silently replaced with a default location.

## `allStores` (type: `boolean`):

Resolve the Australian Coles directory and collect selected products/searches at each returned store. This can multiply output and costs. maxItems remains global; check SUMMARY for store resolution and truncation.

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

Add source GTIN, ingredients, allergens, dietary notes, nutrition, country and available size/variety records. Each detailed product/store row incurs one detail event in addition to its result event. Variation count may exceed returned variant records.

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

Order products using Coles' native sort within each search/category/store, not a combined cross-input sort.

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

Source brand names or numeric facet IDs. Names are resolved against actual source facets; unavailable filter names produce a useful error.

## `dietary` (type: `array`):

Source dietary names or numeric facet IDs, such as Vegan. Availability varies by search/category.

## `allergens` (type: `array`):

Source allergen facet names or numeric IDs, such as Lactose Free. These are source labels, not medical advice.

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

Hard total across products, stores, inputs and locations. Duplicated product/store pairs are emitted and billed once. Directory rows also count. Larger values are bounded by the request and runtime limits.

## `maxRequests` (type: `integer`):

Hard network cap including public bootstrap, store/category resolution, facet lookups and product detail batches. An exhausted cap stops further requests and reports truthful truncation in SUMMARY, not a genuine empty result.

## `maxRunSeconds` (type: `integer`):

Independent elapsed-time limit, at most 30 minutes even when the platform timeout is unlimited. A resurrected run cannot restart extraction. Request timeouts are capped at 25 seconds without blind retries.

## Actor input object example

```json
{
  "searchTerms": [
    "milk"
  ],
  "startUrls": [],
  "productIds": [],
  "departments": [],
  "specials": "none",
  "fullCatalog": false,
  "storeDirectory": false,
  "storeIds": [],
  "postcodes": [],
  "allStores": false,
  "includeDetails": false,
  "sortBy": "relevance",
  "brands": [],
  "dietary": [],
  "allergens": [],
  "maxItems": 100,
  "maxRequests": 1000,
  "maxRunSeconds": 1800
}
```

# Actor output Schema

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

No description

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

No description

## `workReceipt` (type: `string`):

No description

# 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"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("fetch_cat/coles-products-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": ["milk"] }

# Run the Actor and wait for it to finish
run = client.actor("fetch_cat/coles-products-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": [
    "milk"
  ]
}' |
apify call fetch_cat/coles-products-scraper --silent --output-dataset

```

## MCP server setup

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