# ProductReview.com.au Scraper (`fetch_cat/productreview-com-au-scraper`) Actor

Scrape public ProductReview.com.au listings, ratings, reviews, categories, and reviewer details from category, search, or listing URLs.

- **URL**: https://apify.com/fetch\_cat/productreview-com-au-scraper.md
- **Developed by:** [Hanna Nosova](https://apify.com/fetch_cat) (community)
- **Categories:** E-commerce, Automation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 89.7% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.60 / 1,000 dataset item saveds

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

## ProductReview.com.au Scraper

Scrape public ProductReview.com.au product and business pages for listing details, ratings, review counts, and visible review text. Use it for reputation monitoring, competitive analysis, product research, and category-level market snapshots in Australia.

The Actor accepts ProductReview.com.au category pages, search terms, and listing URLs. It saves a flat dataset that can be exported to JSON, CSV, Excel, Google Sheets, or your own API pipeline.

### Who is it for?

This Actor is useful for teams that monitor Australian customer feedback and product reputation.

- Ecommerce and retail teams tracking product ratings
- Consumer brands following review trends
- Agencies producing category reports
- Market researchers comparing competitors
- Support and CX teams collecting public review samples
- Data teams that need ProductReview.com.au rows in a repeatable workflow

### What you get

Each run can return two row types in the default dataset.

- `listing` rows for products, services, or businesses found on ProductReview.com.au pages
- `review` rows for visible reviews on listing pages when review extraction is enabled

Common fields include:

- `recordType`
- `sourceUrl`
- `listingUrl`
- `listingName`
- `brand`
- `category`
- `rating`
- `reviewCount`
- `position`
- `reviewerName`
- `reviewDate`
- `reviewRating`
- `reviewTitle`
- `reviewText`
- `scrapedAt`

### Input options

Use `startUrls` when you already know the ProductReview.com.au pages you want to scrape.

Use `query` when you want the Actor to start from a ProductReview.com.au search page.

Use `maxItems` to cap the total number of saved listing and review rows.

Use `includeReviews` to include or skip visible review rows.

Use `maxReviewsPerListing` to limit review rows from each listing page.

Use `proxyConfiguration` only if your network or workload needs proxy routing.

### Example inputs

The examples below are copy-paste input recipes for local runs, Apify Console runs, or API calls. They are intentionally shown as JSON snippets rather than Store task links.

### Example: search by keyword

```json
{
  "query": "iphone",
  "maxItems": 20,
  "includeReviews": true,
  "maxReviewsPerListing": 10
}
```

### Example: scrape known pages

```json
{
  "startUrls": [
    { "url": "https://www.productreview.com.au/c/mobile-phones" },
    { "url": "https://www.productreview.com.au/listings/apple-iphone-14" }
  ],
  "maxItems": 50,
  "includeReviews": true
}
```

### Example: listings only

```json
{
  "startUrls": [
    { "url": "https://www.productreview.com.au/c/mobile-phones" }
  ],
  "maxItems": 100,
  "includeReviews": false
}
```

### Output dataset

The default dataset is flat and export-friendly. The `recordType` field tells you whether a row describes a listing or a review.

Listing rows focus on product or business summary data.

Review rows focus on reviewer and review content visible on the public page.

The `sourceUrl` field shows where the row was found, and `scrapedAt` records when the row was saved.

### API usage

Run the Actor with the Apify API by passing the same JSON input you use in Console. After the run succeeds, read rows from the default dataset.

#### Node.js

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('fetch_cat/productreview-com-au-scraper').call({
  query: 'iphone',
  maxItems: 20,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

#### Python

```python
from apify_client import ApifyClient
import os

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('fetch_cat/productreview-com-au-scraper').call(run_input={
    'query': 'iphone',
    'maxItems': 20,
})
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

#### cURL

```bash
curl -X POST "https://api.apify.com/v2/acts/fetch_cat~productreview-com-au-scraper/runs?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"query":"iphone","maxItems":20}'
```

### MCP usage

If you use Apify MCP tools, call this Actor by its full name `fetch_cat/productreview-com-au-scraper` and pass one of the JSON inputs above. The resulting dataset can then be summarized, filtered, or joined with other review datasets inside your MCP workflow.

Add the Apify MCP server to Claude Desktop or Claude Code with a command like this:

```bash
claude mcp add apify -- npx -y @apify/actors-mcp-server --actors fetch_cat/productreview-com-au-scraper
```

A JSON MCP configuration can look like this:

```json
{
  "mcpServers": {
    "apify": {
      "command": "npx",
      "args": [
        "-y",
        "@apify/actors-mcp-server",
        "--actors",
        "fetch_cat/productreview-com-au-scraper"
      ],
      "env": {
        "APIFY_TOKEN": "YOUR_APIFY_TOKEN"
      }
    }
  }
}
```

Example prompts for MCP usage:

- "Run the ProductReview.com.au Scraper for the mobile phones category and summarize the top-rated listings."
- "Search ProductReview.com.au for iPhone, return 20 rows, and group the dataset by rating."
- "Scrape this ProductReview.com.au listing and extract visible review themes from the dataset."

### Pricing and cost expectations

The Actor uses pay-per-event pricing: a small run-start charge plus a per-item charge for each saved listing or review row.

Set `maxItems` to control total spend before running broad categories.

Disable `includeReviews` when you only need listing summaries.

Lower `maxReviewsPerListing` when you need a balanced sample across many listings.

### Data quality notes

ProductReview.com.au page layouts can vary by category and listing type.

Some pages expose rich rating and review information in public HTML.

Other pages may expose only links and summary text.

The Actor saves available public data and finishes gracefully when optional fields are absent.

### Limits and pagination

The Actor follows visible ProductReview.com.au listing links and next-page links when present.

It stops as soon as `maxItems` is reached.

If a page has no visible pagination, the Actor saves what is available and completes.

### Legality and responsible use

This Actor is designed for public ProductReview.com.au pages.

Use the data in line with ProductReview.com.au terms, applicable privacy rules, and your own compliance requirements.

Do not use scraped data for spam, harassment, or decisions that require verified personal information.

### Troubleshooting

If a run returns fewer rows than expected, check whether the page has public listing links or public review text.

If a page is temporarily unavailable, retry with a smaller `maxItems` value.

If you do not need review rows, set `includeReviews` to false for a faster listing-only run.

### FAQ

**Does this require a ProductReview.com.au account?**\
No. It extracts data available in public page HTML.

**Can it scrape both listings and reviews?**\
Yes. Listing rows are always saved when found, and review rows are added for listing pages when `includeReviews` is true.

**Can I control the maximum number of results?**\
Yes. Set `maxItems` to the maximum number of dataset rows you want.

**What if ProductReview.com.au changes its layout?**\
The Actor skips pages it cannot read and continues with the remaining queue. Open an issue if expected public data is missing.

### Related actors

For broader review intelligence, combine this dataset with other review, ecommerce, or search-result scrapers in your Apify workflows.

You can also join ProductReview.com.au results with ecommerce product, search-result, or brand-monitoring datasets for richer reporting.

# Actor input Schema

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

ProductReview.com.au category, search, or listing URLs to scrape.

## `query` (type: `string`):

Optional ProductReview search term. Use this when you do not have a start URL.

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

Maximum listing and review rows to save in the dataset.

## `includeReviews` (type: `boolean`):

Save review rows from listing pages when review data is available.

## `maxReviewsPerListing` (type: `integer`):

Limit review rows saved from each listing page.

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

Optional Apify proxy settings. Leave disabled unless ProductReview blocks your network.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.productreview.com.au/c/mobile-phones"
    },
    {
      "url": "https://www.productreview.com.au/listings/apple-iphone-14"
    }
  ],
  "query": "iphone",
  "maxItems": 20,
  "includeReviews": true,
  "maxReviewsPerListing": 10,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# 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 = {
    "startUrls": [
        {
            "url": "https://www.productreview.com.au/c/mobile-phones"
        },
        {
            "url": "https://www.productreview.com.au/listings/apple-iphone-14"
        }
    ],
    "query": "iphone",
    "maxItems": 20,
    "includeReviews": true,
    "maxReviewsPerListing": 10,
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("fetch_cat/productreview-com-au-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 = {
    "startUrls": [
        { "url": "https://www.productreview.com.au/c/mobile-phones" },
        { "url": "https://www.productreview.com.au/listings/apple-iphone-14" },
    ],
    "query": "iphone",
    "maxItems": 20,
    "includeReviews": True,
    "maxReviewsPerListing": 10,
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("fetch_cat/productreview-com-au-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 '{
  "startUrls": [
    {
      "url": "https://www.productreview.com.au/c/mobile-phones"
    },
    {
      "url": "https://www.productreview.com.au/listings/apple-iphone-14"
    }
  ],
  "query": "iphone",
  "maxItems": 20,
  "includeReviews": true,
  "maxReviewsPerListing": 10,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call fetch_cat/productreview-com-au-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

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