# Australia Grocery Prices Scraper: Coles, Woolworths & ALDI (`amitaviv/australia-grocery-prices-scraper`) Actor Coles, Woolworths and ALDI prices by search term or category/specials page: price, was-price, specials, multibuys, unit price per kg/L, size, brand, barcode, stock, image. Compare mode finds the same product at each chain and marks the cheapest. Price-change monitoring. - **URL**: https://apify.com/amitaviv/australia-grocery-prices-scraper.md - **Developed by:** [Amit Aviv](https://apify.com/amitaviv) (community) - **Categories:** E-commerce, Automation, Business - **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks - **User rating**: No ratings yet ## Pricing from $0.64 / 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 ## Australia Grocery Prices Scraper: Coles, Woolworths & ALDI Get current supermarket prices from Coles, Woolworths and ALDI Australia in one dataset, by search term or by category and specials page: price, was-price, specials and multibuys, unit price per kg or litre, pack size, brand, barcode (Woolworths), availability, category, image and product link. A **compare mode** finds the same product at two or three of the chains and marks the cheapest, and a **price-change mode** delivers only what is new or re-priced since your last run. Plain HTTP, no browser; you pay for delivered products (and, in price monitoring, a small fee per product checked), and a run that delivers nothing because of an error ends as Failed, never as a green empty run (in price monitoring, a run whose other searches were checked ends as Succeeded and names the search that failed). ### What you get - Retailer, product id, name, brand, pack size - Price, was-price and saving, special flag, promotion text ("2 for $10.00", "Save $0.50", "Half price", "Pick any 2 for $9"), multibuy quantity and price - Unit price as the shop shows it ("$1.65 / 1L") plus the same restated per kg, per litre or per each, so products of different sizes and shops compare directly - Availability (Coles, Woolworths), barcode/GTIN (Woolworths), category path, product URL, image URL - Compare mode: match group, which retailers sell it, cheapest retailer(s) and price, `isCheapest`, `priceAboveCheapest` - Price-change mode: `changeType` (new, price-down, price-up, price-added, promotion-change), `previousPrice`, `priceChange` - One record per product per retailer, as JSON, CSV or Excel, or through the API, and a run summary (`OUTPUT_SUMMARY` in the run's key-value store): what was requested, delivered and charged, which inputs failed or were ignored, and why the run stopped. What it does not return: reviews or ratings, nutrition panels and ingredients, store-specific prices (each site's default online price is returned), anything behind a login, and no personal data of any kind. ### How to use 1. Type what you want to price in **Search terms** (e.g. `milk`, `vegemite`, `coca cola`), or paste a category or specials page from one of the sites into **Category or specials URLs**. 2. Pick the **Retailers** (all three by default) and set **Max products per search term per retailer**. 3. Optional: tick **Compare mode** or **Only new or re-priced products**. 4. Press Start, then download the results from the Output tab or read them from the API. ### Input | Field | Type | Default | What it does | |---|---|---|---| | `searchTerms` | list of text | none | Products to search for. Each term is searched at every selected retailer. Search-result URLs of the three sites are accepted too. | | `retailers` | list | coles, woolworths, aldi | Which supermarkets to search. | | `categoryUrls` | list of URLs | none | Coles `/browse//...` and `/on-special`; Woolworths `/shop/browse/...` (the main specials page `/shop/browse/specials` is read as its sub-pages: half price, lower shelf price, buy more save more, …); ALDI `/products/.../k/`. Each URL goes to its own retailer. | | `maxItemsPerQuery` | number | 100 | Stop after this many products for each search term at each retailer, and for each URL (across all sub-pages of the Woolworths specials page). | | `includeMarketplace` | yes/no | no | Woolworths also lists third-party "Everyday Market" goods; off = Woolworths's own range only. | | `compare` | yes/no | no | Match the same product across retailers (at least two selected) and mark the cheapest. See "Compare mode". | | `compareIncludeUnmatched` | yes/no | no | In compare mode, also deliver products found at only one retailer. | | `onlyChanges` | yes/no | no | Deliver only products that are new to the monitor or whose price or multibuy changed since the last run. See "Price monitoring". | | `monitorKey` | text | empty | Name of the price-monitoring memory, to keep two schedules apart. | | `proxyConfiguration` | proxy | Apify residential, Australia | Coles is read through this proxy from the first request. Woolworths and ALDI are asked directly first and switch to the proxy only if that shop refuses a request. Keep the default. | ```json { "searchTerms": ["weet-bix", "coca cola", "tim tam"], "compare": true, "maxItemsPerQuery": 60 } ``` ### Example result From run `C5GX2geDauf8MONMA` (compare mode, the input above) on 2026-10-14, unedited: ```json { "id": "aldi:000000000000366359", "retailer": "aldi", "productId": "000000000000366359", "name": "Tim Tam Original Chocolate Biscuits 200g", "brand": "ARNOTT'S", "size": "200 g", "price": 4.49, "wasPrice": null, "savings": null, "isOnSpecial": false, "promotion": null, "multibuyQuantity": null, "multibuyPrice": null, "unitPrice": 2.25, "unitPriceMeasure": "100g", "unitPriceText": "$2.25 per 100 g", "pricePerStandardUnit": 22.5, "standardUnit": "kg", "available": null, "barcode": null, "category": "Pantry > Biscuit & Cookies", "url": "https://www.aldi.com.au/product/arnott-s-tim-tam-original-chocolate-biscuits-200g-000000000000366359", "imageUrl": "https://dm.apac.cms.aldi.cx/is/image/aldiprodapac/product/jpg/scaleWidth/500/cec1353f-da14-4739-9fa5-8865ebb0b0c9/arnott-s-tim-tam-original-chocolate-biscuits-200g", "marketplaceSeller": null, "query": "tim tam", "queryType": "keyword", "changeType": null, "previousPrice": null, "priceChange": null, "matchGroup": "coles:329607+woolworths:36066+aldi:000000000000366359", "matchedRetailers": ["coles", "woolworths", "aldi"], "cheapestRetailer": "aldi", "cheapestRetailers": ["aldi"], "cheapestPrice": 4.49, "isCheapest": true, "priceAboveCheapest": 0, "scrapedAt": "2026-10-14T17:44:52.368Z" } ``` In the same group, Coles had this pack at $6.00 (`priceAboveCheapest` 1.51) and Woolworths at $4.50 (0.01). | Field | Meaning | |---|---| | `id` | `retailer:productId`, stable between runs. | | `price`, `wasPrice`, `savings` | AUD. `wasPrice` only when the shop shows a higher previous price. | | `isOnSpecial`, `promotion` | The shop's special flag, or a was-price or multibuy; `promotion` is the shop's own deal wording (tags that are not deals, such as "Designs May Vary", are left out). | | `multibuyQuantity`, `multibuyPrice` | "2 for $10" = 2 and 10. | | `unitPrice`, `unitPriceMeasure`, `unitPriceText` | The unit price exactly as the shop shows it. | | `pricePerStandardUnit`, `standardUnit` | The shop's unit price restated per `kg`, `L` or `each` (e.g. $2.25 per 100 g = 22.5 per kg). | | `available` | Coles and Woolworths: can be ordered online. ALDI sells in store only and publishes no stock: `null`. | | `barcode` | GTIN, Woolworths only. | | `query`, `queryType` | The search term or URL that found the product. | | `cheapestRetailer`, `cheapestRetailers` | Compare mode: the retailer with the lowest shelf price; on a tie `cheapestRetailer` is `null` and `cheapestRetailers` lists all tied retailers. | | `changeType`, `previousPrice`, `priceChange` | Price monitoring: what changed since this monitor last delivered the product. | Fields a shop does not provide for a product are `null`, never missing. ### Pricing Pay per event. You pay for what is delivered, not for time or memory. | Event | Free | Bronze | Silver | Gold and above | |---|---|---|---|---| | Actor start (once per run, at the default 512 MB) | $0.0036 | $0.003 | $0.0027 | $0.0024 | | Product delivered | $0.00096 | $0.0008 | $0.00072 | $0.00064 | | Product checked, unchanged (price monitoring only) | $0.00012 | $0.0001 | $0.00009 | $0.00008 | Worked examples (Bronze): - 3 search terms at all three retailers, up to 100 each, delivers at most 900 products: 900 × $0.0008 + $0.003 = $0.723. - A daily price-monitoring run that reads 2,000 products and finds 20 changed: 20 × $0.0008 + 1,980 × $0.0001 + $0.003 = $0.217. A run with no change: 2,000 × $0.0001 + $0.003 = $0.203. Reading costs the same whether or not a price moved, which is what the small "checked" event pays for; it is an eighth of the product price. - Products that were not delivered are not charged as products. A product returned by two of your searches is delivered and charged once per run; in price monitoring a product read by two searches is charged as checked once. - In compare mode each product row is one product event; products left out (found at only one retailer) are not charged. - The maximum total charge you set for a run is respected: the actor stops before it would go over, keeps what was delivered, and says so (run `qEenayPHN94GeMlUB`: limit $0.0086 = start + 7 products, 7 delivered, Succeeded). ### Compare mode For each search term the actor reads every selected retailer (at least two), then joins products that have: - the same brand ("a2" matches "a2 Milk"; a shop's own label never matches another shop's), or one shop's brand opening the other shop's product name (Coles files Weet-Bix under "Sanitarium", Woolworths under "Weet-Bix"), - the same pack size after normalisation (3L = 3 l = 3000 mL; "6 x 375mL" = 2.25 L; weighed goods are never matched), - names that are mostly the same words once brand, size and filler words are removed. Each group holds at most one product per retailer. The comparison is on shelf price; multibuys are shown but not used to pick the cheapest. When two retailers share the lowest price (common between Coles and Woolworths), both rows have `isCheapest: true`, `cheapestRetailers` lists both and `cheapestRetailer` is `null`. Matching is a heuristic. In run `C5GX2geDauf8MONMA` it formed 38 groups for "weet-bix", "coca cola" and "tim tam" (13 Weet-Bix pairs at Coles and Woolworths, Tim Tam Original at all three; 21 of the 38 were ties), and we found no wrong pair on reading them. ALDI names are short ("Nutella 400g", "Weet-Bix 375g"), so ALDI products are often left unmatched, and a group without ALDI can name Coles or Woolworths cheapest when ALDI is cheaper: in a review run ALDI's Nutella 400g at $6.69 stayed unmatched while Coles and Woolworths at $6.70 were marked cheapest. Tick **also deliver products found at only one retailer** to see ALDI's prices beside the groups, and give the output a glance before you publish it. ### Price monitoring: only new or re-priced products 1. Turn on **Only new or re-priced products**, set **Max products per search term per retailer** above the size of the listing, and save the input as a task. 2. Schedule the task (daily suits supermarket prices). 3. The first run delivers everything it finds with `changeType: "new"`. Every later run delivers and charges as products only the ones whose price or multibuy changed (`price-down`, `price-up`, `promotion-change`, `price-added`, with `previousPrice` and `priceChange`) and the ones this monitor has not delivered before (`new`). Every other product it reads is charged as one "product checked" event. A run with no change ends as Succeeded with `0 new or re-priced products … — N unchanged products checked`. Good to know: - `new` means new to this monitor, not newly listed by the shop. A product that sat beyond the maximum in earlier runs arrives as `new` once the listing moves it up, so keep the maximum above the listing size. - Searches that overlap (e.g. "milk" and "full cream milk") share products; each product is delivered once per run and every search remembers it (runs `FuetbcEvQ74hV78XV` then `AIUafvmLoiA3eCEaD`: 90 delivered, then 0 delivered and 90 checked, the 8 shared products included once). - A product that has no price at the moment (Woolworths shows none while it cannot sell it, and this flickers from minute to minute) is not reported; its last price is kept, and the next real price is compared with it. - Products that disappear from a search are not reported. Verified live: seed run `sUnd0YbhUV8TTQTdJ` delivered 1,866 products (Coles and Woolworths, "chocolate" and "cheese", max 500); `DGhq49brUYcAs1hMt` 3 minutes later delivered 255 (240 Woolworths products `new` because they sat beyond the first run's maximum of 500, 1 Coles product that was not in the listing 3 minutes earlier, 2 real `price-up`: Darrell Lea half price ended, $3.00 → $4.50) and checked 1,782 unchanged. That run was built before the no-price rule above, so it also reported 12 Woolworths availability flickers. The memory is a key-value store named `australia-grocery-prices-scraper-monitor` in your own account (one record per retailer, search and monitor name, up to 10,000 products each). Delete it or change **Monitor name** to start over. ### Reliability and failure behaviour | What happened | Run status | Status message | |---|---|---| | Products delivered | Succeeded | `Scraped 60 products from 3 queries` | | No shop has products for your search | Succeeded | `0 results: Coles / Woolworths / ALDI has no products for these 2 queries` | | One retailer failed, others worked | Succeeded | `Scraped 5 products from 3 queries — 1 of 3 queries failed ("Coles: milk": Coles blocked the request: …)` | | Price monitoring: one retailer failed, the others were checked | Succeeded | `0 new or re-priced products in 4 monitored queries — 33 unchanged products checked (product-checked events); 2 of 4 queries failed (…)` | | Nothing delivered because of errors or blocking | **Failed** | `No products delivered: Coles blocked every attempt; try again later. No products were charged (the start fee applies).` In price monitoring the products checked before the failure are named: `(the start fee and 48 product-checked events apply)` | | Input the actor cannot use | **Failed**, within seconds | `Nothing to do: the input has no "searchTerms". …`, `Compare mode needs at least two retailers, …` | | Maximum charge reached | Succeeded | `… — stopped at the maximum charge set for this run` | | Run timeout close | Succeeded | `… — stopped just before the run timeout; raise the timeout to get the rest` | - Requests are retried up to 3 times with increasing pauses on network errors, refusals, HTTP 429 and 5xx. After a network error or a refusal the next attempt goes out on a fresh proxy session (a new Australian residential address). Any Coles answer without its product data counts as a refusal, whatever the page looks like. Only when all attempts fail is that search reported as failed; the other retailers carry on. - Products are saved page by page. A run that is aborted, times out or is resurrected keeps what was delivered and never delivers or charges the same product twice (the platform charges the start fee again when a run is resurrected). - Measured on 2026-10-14 over 54 test runs: in every one the products charged equalled the products delivered, with no duplicates. Larger runs: `HBKbETwT19ge9GcrZ` delivered 2,425 products from 9 searches in about 6 minutes, `sUnd0YbhUV8TTQTdJ` 1,866 in 2.5 minutes, `mBG0pSTdYOu9a8EKn` 964 (Coles and ALDI) in 39 seconds. - Version 0.3 read Coles in 15 of 15 runs with the default proxy, spread over 25 minutes, with no failed request. With the proxy turned off, Coles refused 20 requests in a row from the cloud server: run `ZAczuiONGfCtf3vs9` retried each one, named the 5 failed searches, and kept the 45 products it had read before the refusals. ### Limits - Results are each shop's own search results in the shop's order. Broad words bring loosely related products further down (ALDI's "chocolate" ends with tea and coffee); Woolworths answers even made-up words with its nearest matches, so a Woolworths search is rarely empty. - Coles shows at most 100 pages (about 4,800 products) of one listing. - Woolworths mixes third-party "Everyday Market" items into its searches, not only at the end. Without `includeMarketplace`, a Woolworths search ends when it has met as many own-range products as Woolworths counts for it, or, for searches whose count is capped at 10,000 results, after 10 pages in a row with nothing else; the run message then says that more may follow. Live: "cheese" read all 36 pages and delivered 666 products; "coffee" stopped at page 29 with 413 (run `GigR6tGgXeXuzivkH`); a separate scan of "coffee" pages 30-77 found 5 more own-range products. - Prices are each site's default online prices; Coles and Woolworths prices can differ by store and state. - Speed: about 400 products a minute (48 per Coles page, 36 per Woolworths page, 60 per ALDI page, a few seconds per page). - Australia only: coles.com.au, woolworths.com.au, aldi.com.au. ### FAQ **Do I need a proxy?** Keep the default (Apify residential, Australia); the proxy traffic is included in the price. Coles refuses most requests from cloud servers, so Coles is always read through the proxy. Woolworths and ALDI are asked directly first and move to the proxy only if they refuse a request. With the proxy turned off, every request goes out directly and refused ones are only retried directly, so Coles often fails. **Why are some Woolworths products missing a price?** They are unavailable online at the moment; `price` is `null` and `available` is `false`. **Can I run it from code?** Yes: the API, the Apify clients for JavaScript and Python, Make, Zapier, n8n. The Output tab shows the URLs. **What happens when a site changes?** Runs fail loudly instead of returning empty data; report the run id under Issues. ### Legal and responsible use This actor collects product and price information that Coles, Woolworths and ALDI show publicly on their websites without a login. It returns no personal data: no reviews, no reviewer names, no customer information. For Woolworths marketplace items (off by default) it returns the selling company's trading name. It is an independent tool, not affiliated with or endorsed by Coles, Woolworths or ALDI. You are responsible for how you use the data: respect the sites' terms of use, trade marks, copyright and database rights, and the law in your country. Run it at a modest pace, and do not present scraped prices as an official price list of the retailers. If you are unsure, ask a lawyer before you build on it. ### Changelog - 2026-10-14 0.3: Coles is read through the residential proxy from the first request, and any Coles answer without its product data counts as a refusal and is retried on a fresh proxy session (before, an unrecognised Coles page failed the search at once). A refusal by one shop no longer moves the other shops to the proxy. A price-monitoring run whose other searches were checked ends as Succeeded and names the failed one; a failed run's message counts the product-checked events charged. - 2026-10-14 0.2: price monitoring charges a small event per unchanged product checked; overlapping monitored searches no longer re-deliver shared products; unavailable (no price) products are not reported as changes. Compare mode matches maker and product brands (Weet-Bix) and names ties with `cheapestRetailers`. Woolworths searches no longer stop early on marketplace stretches; the main specials page is read as its sub-pages. Search words with a dot ("1.25L") work; the Coles /browse landing page is refused with a hint. - 2026-10-14 0.1: first version: search terms and category URLs for Coles, Woolworths and ALDI; compare mode; price monitoring. ### Support Open an issue on the actor's **Issues** tab with the run id. # Actor input Schema ## `searchTerms` (type: `array`): Products to search for, e.g. milk, vegemite, coca cola 1.25L. Each term is searched at every retailer selected below. Duplicates are ignored. ## `retailers` (type: `array`): Which supermarkets to search. Category URLs always go to their own retailer. ## `categoryUrls` (type: `array`): Listing pages copied from the sites: Coles /browse//... or /on-special, Woolworths /shop/browse/... (the main specials page /shop/browse/specials is read as its sub-pages: half price, lower shelf price, buy more save more and the others), ALDI /products/.../k/. Search-result URLs of the three sites are read as search terms. ## `maxItemsPerQuery` (type: `integer`): Stop after this many products for each search term at each retailer, and for each category URL (the Woolworths main specials page counts as one URL across its sub-pages). You pay only for delivered products. Coles shows at most 100 pages (about 4,800 products) of one listing. For price monitoring, set it above the size of the listing, so that every product is watched from the first run. ## `includeMarketplace` (type: `boolean`): Woolworths also lists goods sold by third-party sellers ("Everyday Market"), and fills searches that match no grocery with them. Off by default: only Woolworths's own range. On: those items too, with the seller's business name in marketplaceSeller. ## `compare` (type: `boolean`): For each search term, match the same product (same brand, or the brand that opens the other shop's product name; same pack size; similar name) at the selected retailers (at least two) and mark the cheapest: matchGroup, cheapestRetailer (null when several share the lowest price), cheapestRetailers, cheapestPrice, isCheapest, priceAboveCheapest. Only matched products are delivered unless you tick the next box. Works with search terms, not category URLs. ## `compareIncludeUnmatched` (type: `boolean`): Only with compare mode. Off: you get (and pay for) matched products only. ## `onlyChanges` (type: `boolean`): Price monitoring. Deliver only products that are new to this monitor, or whose price or multibuy deal changed since the last run, with previousPrice, priceChange and changeType. The first run delivers everything as "new". Every product read and found unchanged is charged as a small "product checked" event (see Pricing), not as a product. The memory is a key-value store named australia-grocery-prices-scraper-monitor in your account; delete it to start over. Cannot be combined with compare mode. ## `monitorKey` (type: `string`): Only with price monitoring. Runs with the same search and the same monitor name share one memory; give two schedules different names to keep them apart. ## `proxyConfiguration` (type: `object`): Default: Apify residential proxy in Australia, which Coles and Woolworths accept. Coles is read through it from the first request (Coles refuses most requests from cloud servers). Woolworths and ALDI are asked directly first and move to the proxy only if that shop refuses a request. With the proxy off, every request goes out directly and refused ones are only retried directly, so Coles often fails. ## Actor input object example ```json { "searchTerms": [ "milk" ], "retailers": [ "coles", "woolworths", "aldi" ], "maxItemsPerQuery": 100, "includeMarketplace": false, "compare": false, "compareIncludeUnmatched": false, "onlyChanges": false, "proxyConfiguration": { "useApifyProxy": true, "apifyProxyGroups": [ "RESIDENTIAL" ], "apifyProxyCountry": "AU" } } ``` # Actor output Schema ## `results` (type: `string`): All delivered records as JSON, one object per item. ## `resultsCsv` (type: `string`): All delivered records as a CSV file. ## `summary` (type: `string`): What was requested, delivered and charged, which inputs failed or were ignored, and why the run stopped. # 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 '' with your token const client = new ApifyClient({ token: '', }); // Prepare Actor input const input = { "searchTerms": [ "milk" ], "retailers": [ "coles", "woolworths", "aldi" ], "proxyConfiguration": { "useApifyProxy": true, "apifyProxyGroups": [ "RESIDENTIAL" ], "apifyProxyCountry": "AU" } }; // Run the Actor and wait for it to finish const run = await client.actor("amitaviv/australia-grocery-prices-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 '' with your token. client = ApifyClient("") # Prepare the Actor input run_input = { "searchTerms": ["milk"], "retailers": [ "coles", "woolworths", "aldi", ], "proxyConfiguration": { "useApifyProxy": True, "apifyProxyGroups": ["RESIDENTIAL"], "apifyProxyCountry": "AU", }, } # Run the Actor and wait for it to finish run = client.actor("amitaviv/australia-grocery-prices-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" ], "retailers": [ "coles", "woolworths", "aldi" ], "proxyConfiguration": { "useApifyProxy": true, "apifyProxyGroups": [ "RESIDENTIAL" ], "apifyProxyCountry": "AU" } }' | apify call amitaviv/australia-grocery-prices-scraper --silent --output-dataset ``` ## MCP server setup ```json { "mcpServers": { "apify": { "type": "http", "url": "https://mcp.apify.com/?tools=fetch-actor-details,amitaviv/australia-grocery-prices-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 ` 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/v1v5XajFzRzQN4195/builds/nE5zWFfzQfly4OB54/openapi.json