# Woolworths Australia Scraper - Prices, Specials & Price History (`crawlplant/woolworths-au`) Actor

Woolworths AU products, prices, unit prices and specials with price history, genuine-discount checks, nutrition, allergens and barcodes. Served from a nightly-refreshed catalogue: fast, reliable, no start fee.

- **URL**: https://apify.com/crawlplant/woolworths-au.md
- **Developed by:** [Piotr Zimniak](https://apify.com/crawlplant) (community)
- **Categories:** E-commerce, Automation
- **Stats:** 2 total users, 1 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.30 / 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

## Woolworths Australia Scraper - Prices, Specials & Price History

Get prices, unit prices, specials, barcodes **and full product details** (description, ingredients, allergens, nutrition,
health stars, dietary tags, images) from **woolworths.com.au** as JSON, CSV, Excel or via API. It also gives you
**price history and genuine-discount checks**, which no other Woolworths scraper offers.

### Why this one

- **Reliable.** Results come from a catalogue we refresh every night, so a run does not depend on Woolworths answering at that
  moment. If live requests are blocked, the run still succeeds with the latest data and a warning, instead of failing.
- **Fast.** Cached queries return in 2-3 seconds; a 1,000-product live search takes about 20 seconds.
- **Price history for every product.** Each result includes the previous price, when it changed, the lowest price in 30 days and
  the 90-day average. It also says whether a "special" is a genuine discount.
- **The whole catalogue in one run.** Every product Woolworths sells (~25-30k), straight from the nightly snapshot.
- **Clean data.** Unit prices are normalised to per kg and per litre, nutrition is parsed, and Woolworths' garbled text is repaired.
- **Pay for results, not for runs.** From $0.30 per 1,000 products; the start fee is $0.00005 (a twentieth of a cent).

### What can you use it for?

- **Price monitoring**: shelf and unit prices of the products you care about, on a schedule.
- **Deal hunting and consumer research**: current specials with a check on whether the discount is real.
- **Price-change alerts**: products whose price changed since your last run, sent to email, Slack or Sheets.
- **Basket and store comparison**: barcodes, MPNs and per-kg prices make matching across stores straightforward.
- **Nutrition and allergen apps**: filter by dietary tags, allergens, health stars, sugar or protein.
- **Market and category research**: brands, pack sizes, price points, new launches, full-catalogue exports.
- **AI agents**: a fast, well-described tool for "find me the cheapest…" style questions (see [Use with AI agents](#use-with-ai-agents)).

### Quick start

1. Click **Try for free** (or **Start**), keep the default input (search for `milk`) and press **Start**.
2. Open the **Output** tab: a table of products with prices, unit prices and specials. Switch views to **Product details** or
   **Deals check**, or export as JSON, CSV or Excel.
3. Change the input using one of the [ready-to-use examples](#ready-to-use-examples) below, and save it as a **task** to reuse or schedule it.

### Modes

| Mode | What you give it | What you get |
|---|---|---|
| `search` (default) | `queries`: keywords | matching products, like the site's search |
| `category` | `categoryUrls`: any `woolworths.com.au/shop/browse/...` URL | the products in that category |
| `specials` | optional `specialsGroups` | current specials; Half Price first, then other promotions |
| `products` | `productIds`: stockcodes (the number in a product URL) | those exact products |
| `urls` | `urls`: any Woolworths product, search, category or specials URL, or a stockcode | whatever each link shows; paste links from your browser |
| `catalog` | nothing (set `maxItems` high, e.g. 30000) | the whole catalogue from the nightly snapshot; filters apply |
| `categories` | nothing | departments, categories and specials groups with their URLs |

### Ready-to-use examples

Paste any of these into the **JSON** tab of the input (or send them through the API).

**1. Price check for a shopping list:** the exact products you buy, by stockcode.

```json
{ "mode": "products", "productIds": ["88436", "888140", "6073909"] }
```

**2. Cheapest coffee per kg:** a search sorted by unit price, within a price range.

```json
{ "queries": ["coffee beans"], "sortBy": "unit_price_asc", "minPrice": 5, "maxPrice": 40, "maxItems": 50 }
```

**3. Everything in a category, cheapest first:**

```json
{ "mode": "category", "categoryUrls": ["https://www.woolworths.com.au/shop/browse/dairy-eggs-fridge/milk"], "sortBy": "price_asc", "maxItems": 500 }
```

**4. This week's half-price specials:**

```json
{ "mode": "specials", "specialsGroups": ["half-price"], "maxItems": 2000 }
```

**5. New specials only, every Wednesday:** schedule this weekly to get what just went on special.

```json
{ "mode": "specials", "onlyNewSpecials": true, "maxItems": 2000 }
```

**6. Price-drop alerts since your last run:** schedule it daily; each run returns only products whose price changed.

```json
{ "mode": "products", "productIds": ["88436", "888140", "6073909"], "changedSince": "last-run" }
```

**7. Gluten-free snacks with less than 5 g sugar per 100 g:**

```json
{ "queries": ["snacks"], "dietary": ["Gluten Free"], "maxSugarPer100g": 5, "maxItems": 100 }
```

**8. Allergy-safe: no peanuts or tree nuts, at least 4 health stars:**

```json
{ "queries": ["muesli bars"], "excludeAllergens": ["Peanut", "Tree Nut"], "minHealthStarRating": 4 }
```

**9. The whole catalogue (analytics, BI, price comparison sites):** served from the nightly snapshot in seconds.

```json
{ "mode": "catalog", "maxItems": 30000 }
```

**10. New products this week:**

```json
{ "mode": "catalog", "onlyNew": true, "maxItems": 30000 }
```

**11. 90-day price history for a few products:**

```json
{ "mode": "products", "productIds": ["88436", "888140"], "priceHistoryDays": 90 }
```

**12. Links straight from the browser:**

```json
{ "mode": "urls", "urls": [
  "https://www.woolworths.com.au/shop/productdetails/88436/dairy-farmers-full-cream-milk",
  "https://www.woolworths.com.au/shop/search/products?searchTerm=tim%20tam",
  "https://www.woolworths.com.au/shop/browse/specials/half-price"
] }
```

**13. Everyday Market (third-party sellers) with seller and delivery terms:**

```json
{ "queries": ["kettle"], "includeMarketplace": true, "sortBy": "price_asc", "maxItems": 50 }
```

### Input options

**Filters and sorting** (all modes):

- `sortBy`: `relevance`, `price_asc`, `price_desc`, `unit_price_asc`, `name`, `specials_first`. Sorting is done by Woolworths before
  paging, so you get the true cheapest products, not just a re-ordered first page.
- `specialsOnly`, `inStockOnly`, `minPrice` / `maxPrice`, `minRating` (customer stars), `excludeCategories` (department names or slugs).
- `includeMarketplace`: off by default, so only products sold by Woolworths are returned (third-party Everyday Market listings are
  excluded at the source). When it is on, marketplace items include `seller` (name, dispatch time, delivery days and fee, returns) and `mpn`.
- `specialsGroups` (specials mode): `half-price`, `buy-more-save-more`, `lower-shelf-price`, `seasonal-price`, `bundles`, `everyday-low-price`.

**Health and nutrition**: `dietary` (e.g. `["Gluten Free", "Vegan"]`, all required), `excludeAllergens` (e.g. `["Peanut", "Milk"]`),
`minHealthStarRating`, `maxSugarPer100g`, `minProteinPer100g`. Products without the data a filter needs are left out, so you
never get a product we can't confirm.

**Price history** (from our shared daily price database):

- `changedSince`: only products whose price changed since a date (`2026-09-01`) or since your previous run (`last-run`).
- `onlyNewSpecials`: only products that went on special in the last 7 days (Woolworths specials change on Wednesdays).
- `onlyNew`: only products that appeared at Woolworths in the last 7 days.
- `priceHistoryDays`: add the list of price changes from the last N days.

**Other options**:

- `maxItems`: products per query / category / URL, after filters (default 100). For specials, products and catalog it applies per run.
- `maxAgeHours`: how old cached data may be (default 12; `0` = always fetch live).
- `fetchFullDetails`: add country of origin, the nutrition panel exactly as printed and all images. It takes one extra request
  per product and is charged per product.
- `includeRaw`: add the original Woolworths payload (every attribute, including ones we don't map).

### Example output

```json
{
  "store": "woolworths",
  "productId": "88436",
  "barcode": "9310199012717",
  "name": "Dairy Farmers Full Cream Milk 2L",
  "brand": "Dairy Farmers",
  "size": "2L",
  "url": "https://www.woolworths.com.au/shop/productdetails/88436/dairy-farmers-full-cream-milk-full-cream-milk",
  "price": 4.7,
  "wasPrice": 4.7,
  "unitPrice": 2.35,
  "unitMeasure": "1L",
  "pricePerKg": null,
  "pricePerLitre": 2.35,
  "isOnSpecial": false,
  "specialType": null,
  "inStock": true,
  "categoryPath": ["Dairy, Eggs & Fridge", "Milk", "Full Cream Milk"],
  "description": "Dairy Farmers Full Cream Milk 2L is Australian owned, made and loved. ...",
  "ingredients": "Milk.",
  "allergens": { "contains": ["Milk"], "mayContain": [] },
  "nutrition": {
    "servingSize": "250.0 ML",
    "servingsPerPack": "8.0",
    "items": [{ "name": "Energy", "per100": "259.0kJ", "perServing": "648.0kJ" }, { "name": "Protein", "per100": "3.4g", "perServing": "8.5g" }]
  },
  "healthStarRating": 4,
  "dietaryTags": ["Gluten Free", "Low Salt", "Source of Protein", "Vegetarian"],
  "countryOfOrigin": "Australia",
  "images": ["https://cdn0.woolworths.media/content/wowproductimages/large/088436.jpg", "..."],
  "rating": { "average": 4.6, "count": 132 },
  "isMarketplace": false,
  "previousPrice": 4.95,
  "priceChangedAt": "2026-10-14T15:31:02.000Z",
  "firstSeenAt": "2026-09-26T15:05:01.000Z",
  "lowestPrice30d": 4.7,
  "averagePrice90d": 4.86,
  "specialStartedAt": null,
  "discountCheck": null,
  "specialCycle": null,
  "scrapedAt": "2026-10-20T15:45:14.223Z",
  "source": "cache"
}
```

### Output fields

| Group | Fields |
|---|---|
| Identity | `store`, `productId` (stockcode), `barcode` (EAN), `mpn`, `name`, `brand`, `size`, `url`, `imageUrl`, `images`, `categoryPath` |
| Price | `price`, `wasPrice`, `unitPrice` + `unitMeasure`, `pricePerKg`, `pricePerLitre`, `pricePerItem`, `inStock` |
| Specials | `isOnSpecial`, `specialType`, `specialStartedAt`, `discountCheck`, `specialCycle` |
| History | `previousPrice`, `priceChangedAt`, `lowestPrice30d`, `averagePrice90d`, `firstSeenAt`, `priceHistory` (with `priceHistoryDays`) |
| Product details | `description`, `ingredients`, `allergens`, `nutrition`, `healthStarRating`, `dietaryTags`, `storage`, `manufacturer`, `countryOfOrigin`\* |
| Reviews & seller | `rating`, `isMarketplace`, `seller` (marketplace only) |
| Freshness | `scrapedAt`, `source` (`cache` or `live`) |

\* `countryOfOrigin` needs `fetchFullDetails`. All prices are in AUD, as numbers. Detail fields are `null` (or empty lists) when
Woolworths has no data for a product.

**Deal check for specials**: `discountCheck.verdict` is:

- `genuine` when the "was" price was actually charged for at least 28 of the 90 days before the special;
- `questionable` when it was not (for example, when the price was raised shortly before the "discount");
- `insufficient-history` until we have 28 days of history for the product.

`specialCycle` shows how often a product goes on special and when the next one is expected, once we have seen 3 of its specials.

### Price alerts in 5 minutes

1. Save a **task** with the input you want to watch (examples 5 and 6 above are good starting points).
2. Add a **schedule** (for example every Wednesday morning, when specials change, or daily for price drops).
3. In the task's **Integrations** tab, send results to email, Slack, Google Sheets, Zapier, Make, n8n or a webhook.

With `changedSince: "last-run"`, each run returns only what changed since the previous one, so quiet days cost nothing.

### Run it through the API

**cURL** (runs synchronously and returns the items):

```bash
curl -X POST "https://api.apify.com/v2/acts/crawlplant~woolworths-au/run-sync-get-dataset-items?token=YOUR_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"queries": ["milk"], "maxItems": 20}'
```

**JavaScript** (`npm install apify-client`):

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

const client = new ApifyClient({ token: 'YOUR_APIFY_TOKEN' });
const run = await client.actor('crawlplant/woolworths-au').call({ mode: 'specials', specialsGroups: ['half-price'], maxItems: 200 });
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items.map((p) => `${p.name}: $${p.price} (was $${p.wasPrice})`));
```

**Python** (`pip install apify-client`):

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")
run = client.actor("crawlplant/woolworths-au").call(run_input={"queries": ["coffee"], "sortBy": "unit_price_asc", "maxItems": 20})
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["name"], item["pricePerKg"])
```

### Use with AI agents

The Actor works as a tool in the [Apify MCP server](https://mcp.apify.com): Claude, ChatGPT, Cursor, VS Code, LangChain,
CrewAI, OpenAI Agents and others. Small queries are answered from the cache in seconds, and every output field is described,
so agents understand the data without extra prompting.

To give an assistant only this tool, use this server URL:

```
https://mcp.apify.com?tools=crawlplant/woolworths-au
```

Example for Claude Desktop (`claude_desktop_config.json`):

```json
{ "mcpServers": { "woolworths": { "command": "npx", "args": ["mcp-remote", "https://mcp.apify.com?tools=crawlplant/woolworths-au"] } } }
```

Try prompts like *"find the cheapest gluten-free pasta per kg at Woolworths"*, *"which Woolworths half-price specials are genuine
this week?"* or *"what did milk cost at Woolworths over the last 90 days?"*.

### Pricing

Pay per result: you pay for the products returned, and platform usage (compute, proxies) is included.

| Event | Free plan | Starter | Scale | Business and up |
|---|---|---|---|---|
| Product (per 1,000 results) | $0.50 | $0.40 | $0.35 | $0.30 |
| Full product details (per 1,000, only with `fetchFullDetails`) | $0.50 | $0.40 | $0.35 | $0.30 |
| Actor start (per run) | $0.00005 | $0.00005 | $0.00005 | $0.00005 |

Product details, price history and deal checks are included in the product price. A failed or empty run costs only the
start fee. Example: the default run (100 products) costs $0.05 on the Free plan.

### Data freshness

Every item has `scrapedAt` (when the price was read from Woolworths) and `source`:

- `cache`: from our database, no older than your `maxAgeHours`. The whole catalogue is refreshed every night (Sydney time).
- `live`: fetched from Woolworths during your run.

If Woolworths blocks live requests, the run doesn't fail: you get the latest cached data, with a warning in the run's `OUTPUT` record.

### Troubleshooting

- **Fewer results than expected:** filters (price, dietary, allergens, ratings) leave out products that don't match or have no data.
  The `OUTPUT` record in the run's key-value store lists any warnings, e.g. when up to 30 pages were scanned without enough matches.
- **"category not found":** run mode `categories` to get the exact category URLs, then paste one into `categoryUrls`.
- **`previousPrice` is `null`:** we have not seen that product's price change since we started tracking it.
- **`onlyNew` / `onlyNewSpecials` return nothing with a warning:** these need a week of tracking history for the store; the
  warning shows the date they start working.
- **Results differ slightly between two identical runs:** Woolworths' relevance order shifts between requests. Sort by
  `name` or a price for exact, repeatable results.
- **A stockcode isn't returned:** the product no longer exists; it is listed in the run warnings and not charged.

### FAQ

**Which store's prices are these?** The default online prices Woolworths shows before you choose a store or delivery address.
Some prices differ in-store and by region.

**Why are some products missing `price`?** The product is currently unavailable online.

**How is this different from other Woolworths scrapers?** Runs don't fail when the site blocks requests, results are served from
a nightly snapshot in seconds, and every product carries price history, a genuine-discount check, normalised unit prices and
parsed nutrition. There is also a full-catalogue mode, and a start fee of just $0.00005.

**Is this legal?** The Actor reads only public product and price information that anyone can see without logging in.
It does not collect personal data. It is not affiliated with Woolworths Group.

### Limits

- With filters, up to 30 result pages (~1,000 products) are scanned per query or category; the run says so when that cap is hit.
- Relevance order on Woolworths shifts slightly between requests, so very large relevance-sorted searches can differ by a few
  products between runs. Sort by name or price for exact, repeatable results.
- Personalised prices (Everyday Rewards member prices, "My Specials") need a login, so they are not included.

### Run summary

The key-value store record `OUTPUT` shows items returned (cache vs live), invalid records skipped, blocked requests,
the proxy route used, extra events charged and any warnings.

### Privacy

The Actor only reads public product pages and does not collect personal data.
To decide which features to build next, each run sends the developer anonymous usage statistics: the mode, which options were
used (e.g. "sortBy: price\_asc", "specialsOnly: on", "2 queries"), result counts and duration.
**It never sends your search terms, URLs, product ids, results or any account information.**

# Actor input Schema

## `mode` (type: `string`):

What to fetch: keyword search, a category listing, current specials, products by stockcode, any Woolworths URLs, the list of departments / categories / specials groups, or the full catalogue from our nightly snapshot (fast; set Max items high, filters apply).

## `queries` (type: `array`):

Used in 'search' mode. Each query is searched separately.

## `categoryUrls` (type: `array`):

Used in 'category' mode, e.g. https://www.woolworths.com.au/shop/browse/dairy-eggs-fridge/milk. Tip: run mode 'List categories' to get every category URL.

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

Used in 'products' mode: the number in a product URL, e.g. 88436.

## `urls` (type: `array`):

Used in 'urls' mode: paste any product, search, category or specials page URL (or a bare stockcode). Each is fetched the right way automatically.

## `specialsGroups` (type: `array`):

Used in 'specials' mode. Empty = all groups, promotions first. Values: half-price, buy-more-save-more, lower-shelf-price, seasonal-price, bundles, everyday-low-price.

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

Maximum products per query / category / URL (after filters). For specials, products and the full catalogue: per run (the catalogue has ~25-30k products).

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

Result order, applied by Woolworths before paging. Price sorts skip products that are unavailable online (no price).

## `specialsOnly` (type: `boolean`):

Keep only products currently on special / half price.

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

Skip products currently unavailable online.

## `minPrice` (type: `number`):

Keep only products priced at or above this amount.

## `maxPrice` (type: `number`):

Keep only products priced at or below this amount.

## `minRating` (type: `number`):

Keep only products with an average customer rating of at least this many stars (0-5). Products without ratings are skipped.

## `includeMarketplace` (type: `boolean`):

Also return products sold by third-party Everyday Market sellers (furniture, electronics, ...). Off = products sold by Woolworths only.

## `excludeCategories` (type: `array`):

Departments to leave out, by name or URL slug, e.g. 'beer-wine-spirits' or 'Pet'.

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

Keep only products tagged with ALL of these, e.g. Gluten Free, Vegan, Vegetarian, Halal, Dairy Free, Low Sugar.

## `excludeAllergens` (type: `array`):

Skip products that contain or may contain any of these, e.g. Peanuts, Tree Nuts, Milk, Gluten. Products without allergen data are skipped too.

## `minHealthStarRating` (type: `number`):

Keep only products rated at least this many health stars (0.5-5).

## `maxSugarPer100g` (type: `number`):

Keep only products with at most this much sugar per 100 g/mL. Products without nutrition data are skipped.

## `minProteinPer100g` (type: `number`):

Keep only products with at least this much protein per 100 g/mL.

## `changedSince` (type: `string`):

Return only products whose price changed since this date/time (e.g. 2026-09-01), or 'last-run' for changes since your previous run with the same input. Uses our shared daily price history.

## `priceHistoryDays` (type: `integer`):

Add each product's price changes from the last N days (0 = off). Every result always includes previousPrice and priceChangedAt when known.

## `onlyNew` (type: `boolean`):

Only products that appeared at Woolworths in the last 7 days.

## `onlyNewSpecials` (type: `boolean`):

Only products that went on special in the last 7 days (specials change every Wednesday).

## `fetchFullDetails` (type: `boolean`):

Adds the printed nutrition panel (per serving and per 100 g/mL), country of origin and all product images. Needs one extra request per product, so it is slower, and it is charged as a separate event per product. Description, ingredients, allergens, health star rating and dietary tags are always included for free.

## `maxAgeHours` (type: `integer`):

Serve cached data younger than this. 0 = always fetch live.

## `includeRaw` (type: `boolean`):

Add the original Woolworths payload to each record (every attribute, including ones we don't map).

## Actor input object example

```json
{
  "mode": "search",
  "queries": [
    "milk"
  ],
  "categoryUrls": [],
  "productIds": [],
  "urls": [],
  "specialsGroups": [],
  "maxItems": 100,
  "sortBy": "relevance",
  "specialsOnly": false,
  "inStockOnly": false,
  "includeMarketplace": false,
  "excludeCategories": [],
  "dietary": [],
  "excludeAllergens": [],
  "priceHistoryDays": 0,
  "onlyNew": false,
  "onlyNewSpecials": false,
  "fetchFullDetails": false,
  "maxAgeHours": 12,
  "includeRaw": false
}
```

# Actor output Schema

## `results` (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 = {
    "queries": [
        "milk"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlplant/woolworths-au").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 = { "queries": ["milk"] }

# Run the Actor and wait for it to finish
run = client.actor("crawlplant/woolworths-au").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 '{
  "queries": [
    "milk"
  ]
}' |
apify call crawlplant/woolworths-au --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,crawlplant/woolworths-au"
        }
    }
}
```

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/ruDy78mvnvku3nbQl/builds/75tbmgwQOv3AbWVRD/openapi.json