# BIG W Marketplace Scraper - Products & Reviews (`abotapi/bigw-marketplace-scraper`) Actor

Scrape BIG W Marketplace seller listings from bigw.com.au: name, brand, price, was-price, saving, condition, category, images, specs, GTIN/EAN/MPN, rating and customer reviews. Search by keyword with brand, category, price and rating filters, or paste product / search URLs.

- **URL**: https://apify.com/abotapi/bigw-marketplace-scraper.md
- **Developed by:** [Abot API](https://apify.com/abotapi) (community)
- **Categories:** E-commerce, Automation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.00 / 1,000 product 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/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.
Actors are written with capital "A".

## 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.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

## BIG W Marketplace Scraper - Products & Reviews

Scrape third-party **BIG W Marketplace** seller listings from
[bigw.com.au](https://www.bigw.com.au/marketplace) into a clean, structured
dataset. Search by keyword with brand, category, price, deal and rating filters,
or paste product and search URLs directly. Optionally collect customer reviews
with an aggregate rating summary for every product.

BIG W Marketplace is where third-party sellers list products alongside BIG W's
own range on Australia's BIG W discount department store (Woolworths Group). This
actor focuses on those marketplace-seller listings by default, and can also
include BIG W's own listings when you want the full catalogue.

### What you get

One flat record per product, including:

- **Identity** - `name`, `title` (full canonical title), `brand`, `articleId`,
  `gtin`, `ean`, `mpn`, `barcodes`
- **Seller** - `sellerType` (Marketplace Seller vs BIG W), `sellerName` (the
  third-party seller), `productChannel`, `isMarketplace`
- **Price & specials** - `price`, `wasPrice` (original / strike-through price),
  `rrp`, `saving`, `savingsPercent`, `isOnSpecial`, `priceLabel` (offer label
  such as "1/2 Price" or "35% OFF"), `unitPrice` (per 100g / 100ml / each),
  `currency`, `clearance`, `onlineOnlyPromotion`, `promotions`,
  `paymentOptions` (Afterpay / Zip / layby)
- **Condition & availability** - `condition`, `listingStatus`, `inStock`,
  `maxQuantity`, `deliverable`, `collectable`, `limitedFreeShipping`
- **Category** - `category`, `categories`, `categoryPath` (full breadcrumb)
- **Variants** - `variants` (size / code matrix), `colours`, `sizes`
- **Media** - `imageUrl`, `images` (full gallery)
- **Description & specifications** - `description`, `specifications`
  (name/value pairs)
- **Rating** - `rating`
- **Fulfilment** - delivery / collection options, logistic type
- **Reviews** (optional) - `reviews[]` with review text, star rating, author,
  date, pros/cons, photos and helpful votes, plus `reviewStats` (review count,
  average rating, star distribution)

#### Specials, offers & was-price

For discounted products the record carries the **original / "was" price**
(`wasPrice`), the **discount** (`saving` and `savingsPercent`), the site's own
**offer label** (`priceLabel`, e.g. "1/2 Price", "35% OFF", "Special") and an
`isOnSpecial` flag. Where the site shows no offer, these fields are simply empty

- they are never fabricated. Grocery items also keep a per-unit price
  (`unitPrice`) for easy comparison. For example, a product reduced from $22.00 to
  $11.00 returns `price: 11.0`, `wasPrice: 22.0`, `saving: 11.0`,
  `savingsPercent: 50`, `priceLabel: "1/2 Price"`.

### Modes

#### Search by keyword + filters

Set **Mode = search** and add one or more **Search keywords**. Each keyword is
searched separately. Refine with:

- **Marketplace sellers only** - keep only third-party seller listings (on by
  default); turn off to include BIG W's own range
- **Specials / offers** - show only products in one of BIG W's specials views:
  On special / reduced (half-price and percentage-off deals), Clearance, Flash
  deal, Lowest price in 7 / 14 days, or New arrivals. Combine with a keyword to
  find specials in a topic, or leave the keyword empty to browse all specials
- **Brand** - keep only a given brand
- **Category id** - restrict to a BIG W category (the trailing number in a
  category URL)
- **Deal type (advanced)** - filter by a raw deal label if you need one the
  selector above doesn't list
- **Minimum / maximum price** (AUD)
- **Minimum rating** (1-5)
- **Include out-of-stock products** - on by default
- **Sort by** - relevance, price low-to-high, price high-to-low, highest rated,
  or name A-Z

Leave the keyword empty to browse the whole marketplace.

#### Scrape pasted URLs

Set **Mode = url** and paste **BIG W URLs**:

- A **product URL** (containing `/p/<id>`, e.g.
  `https://www.bigw.com.au/product/x/p/9900004603`) returns that single product.
- A **search URL** (e.g. `https://www.bigw.com.au/search?text=piano`) returns
  multiple pages of results, walking forward from the page in the URL. Append a
  `deal` value (e.g. `...&deal=Special`) to scope it to specials.

### Reviews

Turn on **Fetch customer reviews** to attach each product's reviews and an
aggregate rating summary. Use **Max reviews per product** to cap how many are
collected per product (0 = all available). Products with no reviews simply return
an empty `reviews` array. Reviews are widely available on BIG W products - for
example, product `9900004603` carries 122 reviews with an average rating of 4.7,
including review text, star rating, author and date.

### Output limits

- **Max products** - overall cap across the run (0 = unlimited)
- **Max pages per search** - optional safety cap on result pages per keyword /
  URL. Set to `0` (the default) to walk the **whole catalogue** for a keyword
  or URL - the run still stops naturally once the storefront's own result
  total is reached or a page repeats with no new products, so there is no
  artificial page cap.
- **Resume a large run:** pass a prior run's ID (or dataset ID) as
  `resumeFromRunId` and the scraper seeds its de-duplication set from that
  run, appending only products it hasn't seen - handy for topping up a
  full-catalogue crawl without re-paying for duplicates.

### Incremental & dedup mode (recurring monitoring)

`resumeFromRunId` continues **one** interrupted run. `incrementalMode` is for
running the **same search again and again** (daily/scheduled) and getting
only what changed, without pasting a run id every time - the actor remembers
the previous run of the same search itself.

Turn on **`incrementalMode`** and every product is classified against the
last run of the same search/filter setup:

- **NEW** - not seen before
- **UPDATED** - a real catalogue field changed (`changedFields` lists which)
- **UNCHANGED** - nothing changed since last time (suppressed - not
  returned or billed - unless `emitUnchanged` is on)
- **REAPPEARED** - was gone, is back
- **EXPIRED** - was tracked, no longer found (only synthesized when
  `emitExpired` is on AND the run fully scanned every keyword/URL with no
  `maxItems`/`maxPages` cap hit and no `resumeFromRunId` - a partial run
  never marks anything expired)

Every row also carries `firstSeenAt` / `lastSeenAt`. State is scoped
automatically to your exact mode/keywords/URLs/filters (two different
searches never share a baseline), or pin it yourself with **`stateKey`** to
name a monitoring campaign explicitly. `emitUnchanged` and `emitExpired` are
both off by default because they return - and bill - extra rows you already
have.

**What counts as a change:** price, was-price, saving, specials/deal flags,
stock, condition, listing status, fulfilment and the variant/colour/size
matrix are all real catalogue data and trigger UPDATED. The aggregate
**`rating`** and the **`reviews`**/**`reviewStats`** fields are driven by
other customers rather than the product itself and change far more often
than the catalogue data, so they are deliberately excluded from change
detection (still fully returned when `fetchReviews` is on) - otherwise
almost every recurring run would look like an update.

### Send results into your apps (MCP connectors)

Optionally pipe results into the apps you already use via Model Context Protocol
(MCP) connectors - Notion, Linear, Airtable or Apify. Authorize a connector under
**Apify → Settings → API & Integrations**, then select it in the input. Notion
gets a rich page-per-item export; other connectors get a best-effort write or
digest. This never changes the dataset output.

### Plan Requirement

Runs on any Apify plan. Using Apify Proxy is recommended for reliable results; on
the free plan, coverage may be limited and some runs may return fewer results.

### Example input

```json
{
  "mode": "search",
  "queries": ["chocolate"],
  "specialsCategory": "special",
  "marketplaceOnly": false,
  "sortBy": "priceAsc",
  "fetchReviews": true,
  "maxReviewsPerProduct": 10,
  "maxItems": 50,
  "proxy": { "useApifyProxy": true }
}
```

# Actor input Schema

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

Choose 'search' to use keywords and filters, or 'url' to scrape specific product or search URLs you paste below.

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

One or more keywords to search, for example 'piano keyboard' or 'garage shelving'. Each keyword is searched separately. Leave empty to browse the whole marketplace.

## `marketplaceOnly` (type: `boolean`):

Keep only listings sold by third-party marketplace sellers (exclude items sold directly by BIG W). On by default.

## `brand` (type: `string`):

Optional. Keep only products whose brand matches this value, for example 'Alpha' or 'Giantz'.

## `category` (type: `string`):

Optional. Restrict results to a BIG W category id (the trailing number in a category URL, e.g. 6822101 in /toys/lego/c/6822101).

## `specialsCategory` (type: `string`):

Optional. Show only products in one of BIG W's on-site specials views. 'On special / reduced' covers half-price and percentage-off deals; also clearance, flash deals, recent price drops and new arrivals. Leave as 'Any' for no specials filter. Combine with a keyword to find specials in a topic, or leave the keyword empty to browse all specials.

## `deal` (type: `string`):

Optional, advanced. Filter by a raw BIG W deal label, for example 'Clearance', 'Flash Deal' or 'Special'. Most users should use the 'Specials / offers' selector above instead. Combined with it when both are set.

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

Ordering applied to the collected results.

## `minPrice` (type: `integer`):

Optional. Only keep products priced at or above this amount (AUD).

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

Optional. Only keep products priced at or below this amount (AUD).

## `minRating` (type: `integer`):

Optional. Only keep products with an average customer rating at or above this value (1 to 5).

## `includeOutOfStock` (type: `boolean`):

Include products that are currently out of stock. On by default; turn off to keep only in-stock products.

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

Product or search URLs to scrape, for example https://www.bigw.com.au/product/x/p/9900004603 or https://www.bigw.com.au/search?text=piano. Multiple URLs supported.

## `fetchReviews` (type: `boolean`):

Also collect customer reviews for each product (review text, star rating, author, date, pros/cons, photos) plus an aggregate rating summary. Adds requests per product.

## `maxReviewsPerProduct` (type: `integer`):

Cap on reviews collected per product when 'Fetch customer reviews' is on. Use 0 for all available reviews.

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

Maximum number of products to return across the whole run. Use 0 for unlimited.

## `maxPages` (type: `integer`):

Optional safety cap on result pages walked per keyword / URL. 0 = unlimited (default); the walk still stops naturally once the storefront's own result total is reached, a page repeats with no new products, or Max products is hit.

## `resumeFromRunId` (type: `string`):

Optional. ID of a previous run of this actor (or a dataset ID). Products already in that dataset are skipped, so this run returns only NEW products (a delta). Combine both runs' datasets for the full set. Max products then counts only the new products. For recurring daily monitoring of the same search, use Incremental mode below instead.

## `incrementalMode` (type: `boolean`):

Turn this on for daily or recurring monitoring. The first run returns all matching products as NEW. Later runs normally return only NEW, UPDATED, and REAPPEARED products. Turn on "Emit unchanged" or "Emit expired" only when you also want those products returned (and billed). State is kept separately for each distinct search/filter setup (or by State key below). Off by default.

## `stateKey` (type: `string`):

Optional. Name this monitoring campaign to keep its state stable, or to deliberately share state across differently-configured runs. Leave empty to let the actor derive a key automatically from your search/filter settings - different searches then never mix state with each other.

## `emitUnchanged` (type: `boolean`):

Off by default. Turn on to also return products that have not changed since the last run, marked UNCHANGED. This returns - and bills - extra rows you already have, so leave it off unless you specifically want the full snapshot every run.

## `emitExpired` (type: `boolean`):

Off by default. Turn on to also return products that were present in a previous run but are no longer found, marked EXPIRED. Only produced once a run has fully scanned the tracked search - not when Max products or Max pages capped it, or when Resume was used. This returns - and bills - extra synthetic rows.

## `proxy` (type: `object`):

Apify Proxy is recommended for reliable results. On the free plan, coverage may be limited and some runs may return no results.

## `mcpConnectors` (type: `array`):

Optionally send results into the apps you already use, via Model Context Protocol (MCP) connectors. Authorize one under Apify, Settings, API & Integrations, then select it here. Notion gets a rich page-per-item export; other connectors get a best-effort write/digest. Leave empty to skip; never changes the dataset output. Supported: Notion (https://mcp.notion.com/mcp), Linear (https://mcp.linear.app/sse), Airtable (https://mcp.airtable.com/mcp), Apify (https://mcp.apify.com).

## `notionParentPageUrl` (type: `string`):

URL or id of the Notion page under which item pages are created. Required to enable the Notion export; ignored by other connectors.

## `maxNotifyListings` (type: `integer`):

Cap on items written to each connector per run. Does not affect the dataset.

## Actor input object example

```json
{
  "mode": "search",
  "queries": [
    "piano keyboard"
  ],
  "marketplaceOnly": true,
  "specialsCategory": "",
  "sortBy": "relevance",
  "includeOutOfStock": true,
  "urls": [
    "https://www.bigw.com.au/search?text=garage shelving"
  ],
  "fetchReviews": false,
  "maxReviewsPerProduct": 20,
  "maxItems": 20,
  "maxPages": 0,
  "incrementalMode": false,
  "emitUnchanged": false,
  "emitExpired": false,
  "proxy": {
    "useApifyProxy": true
  },
  "maxNotifyListings": 50
}
```

# Actor output Schema

## `overview` (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 = {
    "mode": "search",
    "queries": [
        "piano keyboard"
    ],
    "urls": [
        "https://www.bigw.com.au/search?text=garage shelving"
    ],
    "proxy": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("abotapi/bigw-marketplace-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 = {
    "mode": "search",
    "queries": ["piano keyboard"],
    "urls": ["https://www.bigw.com.au/search?text=garage shelving"],
    "proxy": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("abotapi/bigw-marketplace-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "mode": "search",
  "queries": [
    "piano keyboard"
  ],
  "urls": [
    "https://www.bigw.com.au/search?text=garage shelving"
  ],
  "proxy": {
    "useApifyProxy": true
  }
}' |
apify call abotapi/bigw-marketplace-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=abotapi/bigw-marketplace-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/NevrVHgnHEiMciEkZ/builds/z3TumfnlI3FjtHcyk/openapi.json