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

\[💰 $1.0 / 1K] Scrape listings and consumer reviews from ProductReview.com.au, Australia's largest reviews portal. Get ratings, review counts, contact details, FAQs, and full review text. Browse by category, or paste category, search, and listing URLs.

- **URL**: https://apify.com/solidcode/productreview-com-au-scraper.md
- **Developed by:** [SolidCode](https://apify.com/solidcode) (community)
- **Categories:** E-commerce, Lead generation, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.00 / 1,000 reviews

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 a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use 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

Pull listings and consumer reviews from ProductReview.com.au at scale — star ratings, total review counts, full review text, reviewer names and dates, rating distributions, contact details, and FAQs across products, businesses, and services on Australia's largest reviews portal. Built for market researchers, brand managers, and Australian e-commerce teams who need real consumer sentiment in a clean spreadsheet without copy-pasting reviews one page at a time.

### Why This Scraper?

- **Australia's largest reviews portal, end to end** — covers millions of consumer reviews across thousands of brands, products, businesses, and services, all from ProductReview.com.au in one run.
- **Two clean record types** — a `listing` row for every product or business plus a flat `review` row for every individual review, each linking back to its parent via `listingId` and `listingName`. No nested blobs to flatten yourself.
- **Full review text, not just star averages** — every review row carries the reviewer's `rating`, `title`, `body`, submission date, verified-purchase flag, and author display name and location.
- **Per-listing review depth you control** — `maxReviewsPerListing` pulls anywhere from a quick sample of 20 up to thousands of reviews per listing (safety ceiling 5,000), instead of being stuck at a 10-review preview.
- **Four native sort modes** — Most relevant, Highest rated, Most reviewed, or Newest, applied at the source so you get the slice you actually want.
- **Rating distribution on every listing** — the full 1-to-5-star breakdown, total review count, and Q&A question count, ideal for sentiment and CSAT analysis.
- **Business contact details and FAQs** — phone, email, and website plus frequently-asked-question blocks captured for service and business listings, not just product specs.
- **Three ways to target** — paste category, search, or direct listing URLs, browse by category keyword, or narrow by Australian state and on-page keyword — mix and match in a single run.
- **Verified-purchase and reviewer-location signals** — filter for `hasVerifiedPurchase` reviews and segment sentiment by reviewer location for trustworthy, geo-aware insight.

### Use Cases

**Market Research**
- Track average ratings and review volume across an entire product category
- Measure share of voice by comparing review counts between competing brands
- Map the full 1–5 star distribution to understand sentiment spread, not just the average
- Surface the newest reviews to catch emerging product issues early

**Brand & Reputation Monitoring**
- Pull every review for your own listings to monitor sentiment over time
- Flag low-star reviews the moment they appear for fast customer-service follow-up
- Track verified-purchase reviews separately from unverified opinions
- Watch your rating distribution shift after a product launch or recall

**Competitor Analysis**
- Benchmark your star rating and review count against rivals in the same category
- Read competitors' one-star reviews to find unmet customer needs
- Compare verified-purchase ratios across competing products
- Identify which competitor features customers praise or complain about most

**Product & CX Insight**
- Mine full review text for recurring complaints, feature requests, and praise
- Feed review bodies into sentiment or keyword analysis pipelines
- Segment feedback by reviewer location to spot region-specific issues
- Quantify how verified buyers rate a product versus the overall crowd

**Lead Generation**
- Build contact lists of Australian businesses with phone, email, and website
- Target service providers by category and state across the country
- Prioritise outreach by rating and review volume

### Getting Started

#### Scrape a single listing and its reviews

The simplest start — paste one ProductReview.com.au listing URL:

```json
{
    "startUrls": ["https://www.productreview.com.au/listings/toyota-corolla"],
    "maxReviewsPerListing": 50
}
````

#### Browse a category, top-rated first

```json
{
    "category": "Coffee Machines",
    "sortBy": "rating",
    "maxResults": 25,
    "maxReviewsPerListing": 30
}
```

#### Listings only, no reviews (faster and cheaper)

```json
{
    "category": "Real Estate Agents",
    "location": "Victoria",
    "includeReviews": false,
    "maxResults": 30
}
```

#### Full-featured run

```json
{
    "category": "Cars",
    "searchTerm": "Toyota",
    "location": "New South Wales",
    "sortBy": "review_count",
    "maxResults": 50,
    "includeReviews": true,
    "maxReviewsPerListing": 200
}
```

### Input Reference

#### What to Scrape

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `startUrls` | array | `[]` | Paste one or more ProductReview.com.au URLs — category pages, search-result pages, or direct listing pages. The quickest way to get exactly the listings you want. Leave empty to use the search options below. |
| `category` | string | `""` | Browse a ProductReview category, for example "Cars", "Coffee Machines", or "Real Estate Agencies". Only used when no URLs are pasted. |
| `searchTerm` | string | `""` | Optional keyword to narrow results within the chosen category, for example "Toyota" or "espresso". Leave empty to include everything in the category. |
| `location` | string | `""` | Optional Australian state or region to filter by, for example "Victoria" or "New South Wales". Best for businesses and services. |

#### Options

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `sortBy` | select | `Most relevant` | How to order the listings collected: Most relevant, Highest rated, Most reviewed, or Newest. |
| `maxResults` | integer | `100` | Maximum number of listings to collect. Set to 0 for no limit. A limit keeps runs fast and affordable. |
| `includeReviews` | boolean | `true` | Also collect each listing's consumer reviews. Turn off for faster, cheaper runs when you only need listing details and ratings. |
| `maxReviewsPerListing` | integer | `20` | Maximum reviews to collect per listing. Set to 0 for all available reviews (up to a safety maximum of 5,000 per listing). Only applies when reviews are on. |

### Output

Every row carries a `recordType` field — `"listing"` or `"review"` — so you can filter the two apart. The Overview tab holds everything; the Listings and Reviews tabs are clean, pre-filtered subsets of the same run.

#### Listing record

```json
{
    "recordType": "listing",
    "id": "toyota-corolla",
    "name": "Toyota Corolla",
    "slug": "toyota-corolla",
    "detailsUrl": "https://www.productreview.com.au/listings/toyota-corolla",
    "brand": "Toyota",
    "rating": 4.2,
    "reviewCount": 12553,
    "ratingDistribution": { "1": 412, "2": 380, "3": 901, "4": 3120, "5": 7740 },
    "questionCount": 318,
    "categories": ["Cars", "Hatchbacks", "Sedans"],
    "locations": [],
    "address": null,
    "contact": { "website": "https://www.toyota.com.au" },
    "description": "The Toyota Corolla is one of Australia's best-selling small cars...",
    "faqs": [{ "question": "Is the Corolla reliable?", "answer": "Owners consistently rate reliability highly." }],
    "logoUrl": "https://cdn.productreview.com.au/resize/brand-logo/abc123?width=1200&height=630",
    "pictureUrl": "https://cdn.productreview.com.au/resize/listing-picture/def456?width=1200&height=630",
    "isDiscontinued": false,
    "reviewsCollected": 50,
    "scrapedAt": "2026-06-26T14:30:00Z"
}
```

##### Listing Fields

| Field | Type | Description |
|-------|------|-------------|
| `recordType` | string | Always `"listing"`. |
| `id` | string | Listing identifier on ProductReview. |
| `name` | string | Listing (product, business, or service) name. |
| `slug` | string | URL slug for the listing. |
| `detailsUrl` | string | Canonical listing URL. |
| `brand` | string | Brand or company name, when present. |
| `rating` | number | Average star rating. |
| `reviewCount` | number | Total number of reviews on the site. |
| `ratingDistribution` | object | Review count per star bucket, keyed `1`–`5`. |
| `questionCount` | number | Number of Q\&A questions, when present. |
| `categories` | array | Category names the listing appears under. |
| `locations` | array | Location names served, when applicable. |
| `address` | object/string | Physical address, for business listings. |
| `contact` | object | Phone, email, and website, when present. |
| `description` | string | Listing description or about text. |
| `faqs` | array | Frequently-asked-question blocks (`question`, `answer`). |
| `logoUrl` | string | Brand logo image URL. |
| `pictureUrl` | string | Primary picture image URL. |
| `isDiscontinued` | boolean | Whether the listing is marked discontinued. |
| `reviewsCollected` | number | How many reviews were pulled for this listing this run. |
| `scrapedAt` | string | ISO timestamp of extraction. |

#### Review record

```json
{
    "recordType": "review",
    "id": "rv_98217634",
    "rating": 5,
    "title": "Best small car I've owned",
    "body": "Three years in and zero issues. Fuel economy is excellent and it's a breeze to park.",
    "submittedAt": "2026-05-18T09:12:00Z",
    "hasVerifiedPurchase": true,
    "author": {
        "displayName": "Sarah M.",
        "locationName": "Melbourne, VIC",
        "avatarUrl": "https://cdn.productreview.com.au/resize/avatar/u789?width=200&height=200"
    },
    "subject": {
        "id": "acd742bd-fb96-49d8-99dc-f203ea724128",
        "name": "Toyota Corolla E210 Hatch Petrol Ascent Sport",
        "slug": "toyota-corolla-e210-hatch-petrol-ascent-sport",
        "shortName": "Ascent Sport"
    },
    "images": ["https://cdn.productreview.com.au/resize/review-attachment/img001?width=1200&height=630"],
    "attachments": [{ "id": "img001" }],
    "comments": [],
    "listingId": "toyota-corolla",
    "listingName": "Toyota Corolla",
    "listingUrl": "https://www.productreview.com.au/listings/toyota-corolla",
    "scrapedAt": "2026-06-26T14:30:00Z"
}
```

##### Review Fields

| Field | Type | Description |
|-------|------|-------------|
| `recordType` | string | Always `"review"`. |
| `id` | string | Review identifier. |
| `rating` | number | Star rating the reviewer gave. |
| `title` | string | Review title or headline. |
| `body` | string | Full review text. |
| `submittedAt` | string | ISO submission date. |
| `hasVerifiedPurchase` | boolean | Whether the review is a verified purchase. |
| `author` | object | Reviewer `displayName`, `locationName`, and `avatarUrl`. |
| `subject` | object | The exact product variant the review is about (`name`, `slug`, `shortName`) — useful for multi-variant listings like cars and phones. `null` when the listing has no variants. |
| `images` | array | Reviewer-attached image URLs. |
| `attachments` | array | Raw attachment objects on the review. |
| `comments` | array | Replies and owner responses on the review. |
| `listingId` | string | Parent listing identifier (back-reference). |
| `listingName` | string | Parent listing name. |
| `listingUrl` | string | Parent listing URL. |
| `scrapedAt` | string | ISO timestamp of extraction. |

### Tips for Best Results

- **Category browse returns up to 30 listings per category page.** To go deeper, add a `searchTerm` keyword, use a more specific sub-category, scope the category to a `location`, or paste several listing URLs in `startUrls` — each URL is collected independently with no shared cap.
- **Paste direct listing URLs for pinpoint control** — when you know the exact products or businesses you want, listing URLs skip category browsing entirely and go straight to the data.
- **Turn off `includeReviews` for a fast inventory pass** — when you only need names, ratings, and review counts, skipping reviews makes runs dramatically faster and cheaper. Switch it back on once you've shortlisted the listings worth deep-diving.
- **Cap `maxReviewsPerListing` on popular listings** — flagship cars, telcos, and banks can carry tens of thousands of reviews. A cap of 50–200 gives a representative sample fast; set it to 0 only when you genuinely need every review (up to the 5,000-per-listing safety ceiling).
- **Use `sortBy: "review_count"` to find the heavy hitters** — surface the most-reviewed listings in a category first when you want the richest sentiment data.
- **`location` works best on service categories** — real estate agents, trades, and local businesses honour the state filter; product categories such as Cars apply nationally, so leave `location` empty for them.
- **Filter on `hasVerifiedPurchase` after the run** — verified-purchase reviews carry the most weight for trust analysis; the flag is on every review row so you can split verified from unverified in your spreadsheet.

### Pricing

**From $1.00 per 1,000 reviews** (plus $2.50 per 1,000 listings) — a pay-per-result model with no compute or time-based charges. You are charged per listing collected plus per review collected; reviews are the bulk of most runs, so the per-review rate is what drives your bill. Bronze, Silver, and Gold loyalty subscribers pay progressively less, applied automatically.

#### Reviews — cost per volume

| Reviews | No discount | Bronze | Silver | Gold |
|---------|-------------|--------|--------|------|
| 100 | $0.12 | $0.11 | $0.105 | $0.10 |
| 1,000 | $1.20 | $1.10 | $1.05 | $1.00 |
| 10,000 | $12.00 | $11.00 | $10.50 | $10.00 |
| 100,000 | $120.00 | $110.00 | $105.00 | $100.00 |

#### Listings — cost per volume

| Listings | No discount | Bronze | Silver | Gold |
|----------|-------------|--------|--------|------|
| 100 | $0.30 | $0.28 | $0.265 | $0.25 |
| 1,000 | $3.00 | $2.80 | $2.65 | $2.50 |
| 10,000 | $30.00 | $28.00 | $26.50 | $25.00 |
| 100,000 | $300.00 | $280.00 | $265.00 | $250.00 |

#### Example total cost

A typical run of 100 listings averaging 50 reviews each = 100 listing charges + 5,000 review charges:

| Tier | 100 listings | 5,000 reviews | Total |
|------|--------------|---------------|-------|
| No discount | $0.30 | $6.00 | $6.30 |
| Gold | $0.25 | $5.00 | $5.25 |

Charged per listing plus per review collected. No compute or time-based charges — you pay per result, plus a small fixed per-run start fee. Tier discounts apply automatically through the Apify loyalty program.

### Integrations

Export data in JSON, CSV, Excel, XML, or RSS. Connect to 1,500+ apps via:

- **Zapier** / **Make** / **n8n** — Workflow automation
- **Google Sheets** — Direct spreadsheet export
- **Slack** / **Email** — Notifications on new results
- **Webhooks** — Trigger custom APIs on run completion
- **Apify API** — Full programmatic access

### Legal & Ethical Use

This actor is designed for legitimate market research, brand monitoring, and competitor analysis. Users are responsible for complying with applicable laws and ProductReview.com.au's Terms of Service. Collect only publicly available information, treat reviewer names and any personal data responsibly under applicable privacy laws, and do not use extracted data for spam, harassment, or any unlawful purpose. </content> </invoke>

# Actor input Schema

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

Paste one or more ProductReview.com.au URLs — category pages, search-result pages, or direct listing pages. This is the quickest way to get exactly the listings you want. Leave empty to use the search options below instead.

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

Browse a ProductReview category, for example 'Cars', 'Coffee Machines', or 'Real Estate Agencies'. Only used when no URLs are pasted above. ProductReview shows up to 30 listings per category page — to go deeper, add a search keyword, use a more specific sub-category, or paste several listing URLs. Leave empty if you are pasting URLs.

## `searchTerm` (type: `string`):

Optional keyword to narrow results within the chosen category, for example 'Toyota' or 'espresso'. Leave empty to include everything in the category. Used on its own (no category and no URLs) it matches up to 5 listings by name — pair it with a category for broader results.

## `location` (type: `string`):

Optional Australian state or region to filter by, for example 'Victoria' or 'New South Wales'. Best for businesses and services. Leave empty to include all locations.

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

How to order the listings that are collected.

## `maxResults` (type: `integer`):

Maximum number of listings to collect. Set to 0 for no limit. We recommend keeping a limit to control cost.

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

Also collect each listing's consumer reviews. Turn this off for faster, cheaper runs when you only need listing details and ratings.

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

Maximum number of reviews to collect for each listing. Set to 0 to collect all available reviews, up to a safety maximum of 5,000 per listing. Popular listings can have thousands of reviews — a limit keeps runs fast and affordable. Only applies when 'Include reviews' is on.

## Actor input object example

```json
{
  "startUrls": [],
  "sortBy": "relevance",
  "maxResults": 100,
  "includeReviews": true,
  "maxReviewsPerListing": 20
}
```

# Actor output Schema

## `overview` (type: `string`):

Every record from the run in one place — listings and reviews — distinguished by `recordType`.

## `listings` (type: `string`):

Listings only, with name, brand, rating, total review count, categories, contact, and FAQs.

## `reviews` (type: `string`):

Consumer reviews only, each linking back to its parent listing. Present only when 'Include reviews' is enabled.

# 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": [],
    "category": "",
    "searchTerm": "",
    "location": "",
    "sortBy": "relevance",
    "maxResults": 100,
    "includeReviews": true,
    "maxReviewsPerListing": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("solidcode/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": [],
    "category": "",
    "searchTerm": "",
    "location": "",
    "sortBy": "relevance",
    "maxResults": 100,
    "includeReviews": True,
    "maxReviewsPerListing": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("solidcode/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": [],
  "category": "",
  "searchTerm": "",
  "location": "",
  "sortBy": "relevance",
  "maxResults": 100,
  "includeReviews": true,
  "maxReviewsPerListing": 20
}' |
apify call solidcode/productreview-com-au-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "ProductReview.com.au Scraper",
        "description": "[💰 $1.0 / 1K] Scrape listings and consumer reviews from ProductReview.com.au, Australia's largest reviews portal. Get ratings, review counts, contact details, FAQs, and full review text. Browse by category, or paste category, search, and listing URLs.",
        "version": "1.0",
        "x-build-id": "gqnRQzjHYemmjlFTu"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/solidcode~productreview-com-au-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-solidcode-productreview-com-au-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/solidcode~productreview-com-au-scraper/runs": {
            "post": {
                "operationId": "runs-sync-solidcode-productreview-com-au-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/solidcode~productreview-com-au-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-solidcode-productreview-com-au-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "startUrls": {
                        "title": "ProductReview URLs",
                        "type": "array",
                        "description": "Paste one or more ProductReview.com.au URLs — category pages, search-result pages, or direct listing pages. This is the quickest way to get exactly the listings you want. Leave empty to use the search options below instead.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "category": {
                        "title": "Category",
                        "type": "string",
                        "description": "Browse a ProductReview category, for example 'Cars', 'Coffee Machines', or 'Real Estate Agencies'. Only used when no URLs are pasted above. ProductReview shows up to 30 listings per category page — to go deeper, add a search keyword, use a more specific sub-category, or paste several listing URLs. Leave empty if you are pasting URLs."
                    },
                    "searchTerm": {
                        "title": "Search keyword",
                        "type": "string",
                        "description": "Optional keyword to narrow results within the chosen category, for example 'Toyota' or 'espresso'. Leave empty to include everything in the category. Used on its own (no category and no URLs) it matches up to 5 listings by name — pair it with a category for broader results."
                    },
                    "location": {
                        "title": "Location",
                        "type": "string",
                        "description": "Optional Australian state or region to filter by, for example 'Victoria' or 'New South Wales'. Best for businesses and services. Leave empty to include all locations."
                    },
                    "sortBy": {
                        "title": "Sort results by",
                        "enum": [
                            "relevance",
                            "rating",
                            "review_count",
                            "newest"
                        ],
                        "type": "string",
                        "description": "How to order the listings that are collected.",
                        "default": "relevance"
                    },
                    "maxResults": {
                        "title": "Max listings",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum number of listings to collect. Set to 0 for no limit. We recommend keeping a limit to control cost.",
                        "default": 100
                    },
                    "includeReviews": {
                        "title": "Include reviews",
                        "type": "boolean",
                        "description": "Also collect each listing's consumer reviews. Turn this off for faster, cheaper runs when you only need listing details and ratings.",
                        "default": true
                    },
                    "maxReviewsPerListing": {
                        "title": "Max reviews per listing",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum number of reviews to collect for each listing. Set to 0 to collect all available reviews, up to a safety maximum of 5,000 per listing. Popular listings can have thousands of reviews — a limit keeps runs fast and affordable. Only applies when 'Include reviews' is on.",
                        "default": 20
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
