# 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, 100.0% 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 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

Scrape public ProductReview.com.au listings, ratings, review counts, and review metadata from category, search, and listing pages.

Use it to monitor Australian product reputation, compare brands, collect review signals, and build reporting datasets from ProductReview.com.au.

### At a glance

- **Extracts:** listings, ratings, review counts, category data, reviewer names, dates, review ratings, review titles, review text, and source URLs.
- **Inputs:** ProductReview.com.au category URLs, search/listing URLs, search query, row limits, review toggle, review-per-listing limit, and proxy settings.
- **Best for:** reputation monitoring, product-category research, competitor comparison, review evidence collection, and Australian market reporting.
- **Exports:** Apify dataset rows downloadable as CSV, JSON, Excel, XML, RSS, or available through the API.
- **Login:** no ProductReview.com.au account is required for public pages.

### Ready-to-run examples

Use these saved Store examples as starting points. Open any example to prefill the Actor input, then adjust URLs, keywords, limits, or filters for your own run.

- **[Search ProductReview for NBN providers](https://apify.com/fetch_cat/productreview-com-au-scraper/examples/search-productreview-for-nbn-providers)**
- **[Research electric car reviews in Australia](https://apify.com/fetch_cat/productreview-com-au-scraper/examples/research-electric-car-reviews-australia)**
- **[Scrape vacuum cleaner review data](https://apify.com/fetch_cat/productreview-com-au-scraper/examples/scrape-vacuum-cleaner-review-data)**
- **[Monitor car reviews in Australia](https://apify.com/fetch_cat/productreview-com-au-scraper/examples/monitor-car-reviews-australia)**
- **[Export iPhone 14 product reviews](https://apify.com/fetch_cat/productreview-com-au-scraper/examples/export-iphone-14-product-reviews)**
- **[Track health insurance reviews in Australia](https://apify.com/fetch_cat/productreview-com-au-scraper/examples/track-health-insurance-reviews-australia)**
- **[View all ready-to-run examples](https://apify.com/fetch_cat/productreview-com-au-scraper/examples)** (8 examples)

### What can it do?

ProductReview.com.au Scraper turns public ProductReview.com.au pages into structured dataset rows.

- **Scrape category pages:** start from pages such as mobile phones, insurance, appliances, or services.
- **Scrape search results:** use a keyword when you do not already have exact ProductReview URLs.
- **Scrape direct listings:** monitor specific products or businesses repeatedly.
- **Save listing rows:** collect listing names, brands, categories, ratings, review counts, URLs, images, and timestamps.
- **Save review rows:** optionally collect visible review metadata and text from listing pages.
- **Audit every row:** keep source URLs and scrape timestamps in the dataset.

### Who is it for?

- **Ecommerce teams:** track how products are reviewed in Australia.
- **Brand managers:** compare product lines, competitors, and rating trends.
- **Reputation analysts:** collect review evidence for dashboards and reports.
- **Product teams:** find positive and negative customer feedback signals.
- **Retail teams:** monitor categories and competitor listings.
- **Automation teams:** feed review data into BI tools, CRMs, and alerts.

### Why use this scraper?

- **Australian review source:** ProductReview.com.au is useful for local consumer reputation research.
- **Structured exports:** avoid slow copy-paste and get clean rows for CSV, JSON, Excel, and API workflows.
- **Cost control:** cap total rows with `maxItems` and cap review rows with `maxReviewsPerListing`.
- **Flexible depth:** include listing-level data only or add visible review rows when you need text and reviewer context.
- **Scheduling:** run manually or schedule repeat monitoring jobs on Apify.

### Output fields

| Field | Description |
| --- | --- |
| `recordType` | `listing` or `review` |
| `sourceUrl` | Page where the row was found |
| `listingUrl` | ProductReview listing URL |
| `listingName` | Product or business name |
| `brand` | Brand when visible |
| `category` | Category breadcrumb when visible |
| `rating` | Aggregate listing rating |
| `reviewCount` | Number of reviews shown for the listing |
| `productUrl` | External product or brand URL when visible |
| `imageUrl` | Listing image URL when visible |
| `mpn` | Product model number when visible |
| `position` | Listing or review position on the page |
| `reviewerName` | Reviewer display name |
| `reviewerLocation` | Reviewer location when visible |
| `reviewDate` | Review publication date |
| `reviewRating` | Individual review star rating |
| `reviewTitle` | Review headline when visible |
| `reviewText` | Review body when visible |
| `verified` | Verified flag when visible |
| `fairIncentive` | Incentivized review flag when visible |
| `scrapedAt` | Timestamp of extraction |

### Pricing

The actor uses pay-per-event pricing.

| Event | When charged | Price |
| --- | --- | --- |
| `start` | Once when a run starts | `$0.005` per run |
| `item` | Each listing or review row saved to the dataset | BRONZE `$0.001` per saved row, about `$1.00` per 1,000 saved rows |

The default input is intentionally small so your first run is inexpensive.

Use `maxItems` to control the maximum number of exported rows.

### Quick start

1. Open the actor on Apify.

2. Paste one or more ProductReview.com.au URLs into **Start URLs**.

3. Optionally enter a **Search query**.

4. Set **Maximum rows**.

5. Choose whether to **Include reviews**.

6. Click **Start**.

7. Download the dataset as CSV, JSON, Excel, XML, or RSS.

### Input configuration

| Setting | JSON key | Description |
| --- | --- | --- |
| Start URLs | `startUrls` | ProductReview.com.au category, search, or listing URLs such as `https://www.productreview.com.au/c/mobile-phones`. |
| Search query | `query` | Optional keyword such as `iphone`, `insurance`, or `coffee machine`. If URLs and query are both supplied, the actor processes both. |
| Maximum rows | `maxItems` | Total listing and review rows saved to the dataset. Listing rows and review rows both count toward this limit. |
| Include reviews | `includeReviews` | Save review rows from listing pages when review metadata is available. Turn off for listing-level ratings only. |
| Maximum reviews per listing | `maxReviewsPerListing` | Limit review rows saved from each listing page. Useful when monitoring many listings at once. |
| Proxy configuration | `proxyConfiguration` | Optional Apify Proxy settings. Leave disabled unless your network or workload requires it. |

### Output example

```json
{
  "recordType": "listing",
  "sourceUrl": "https://www.productreview.com.au/c/mobile-phones",
  "listingUrl": "https://www.productreview.com.au/listings/apple-iphone-14",
  "listingName": "Apple iPhone 14",
  "brand": "Apple",
  "category": "Best Mobile Phones",
  "rating": 4.1,
  "reviewCount": 69,
  "scrapedAt": "2026-06-28T00:00:00.000Z"
}
````

### Tips for better results

- **Use category pages for discovery:** category URLs are best when you want multiple listings.
- **Use listing pages for repeatability:** direct listing URLs are best for dashboards and monitoring.
- **Start small:** use a low `maxItems` value for test runs.
- **Scale after checking output:** increase `maxItems` for scheduled monitoring after reviewing sample rows.
- **Use search for exploration:** queries are useful when you do not know exact listing URLs yet.

### Common workflows

- **Category monitoring:** monitor a product category weekly.
- **Rating tracking:** track star ratings for a shortlist of listings.
- **Reputation evidence:** collect review authors, dates, titles, and text for analysis.
- **Competitor comparison:** build a comparison dataset across brands or product lines.
- **Alerts:** send rating changes to Slack or email using Apify integrations.
- **Analytics:** export reviews to a warehouse for sentiment analysis.

### Integrations

- Use Apify schedules to run the actor automatically.
- Use webhooks to notify your app when a run finishes.
- Use dataset exports for Google Sheets, Excel, Airtable, and BI tools.
- Use the Apify API to trigger runs from your own backend.
- Use Make, Zapier, or n8n to connect datasets to downstream tools.

### API usage with 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({
  startUrls: [{ url: 'https://www.productreview.com.au/c/mobile-phones' }],
  maxItems: 25,
  includeReviews: true
});
console.log(run.defaultDatasetId);
```

### API usage with Python

```python
from apify_client import ApifyClient

client = ApifyClient('MY-APIFY-TOKEN')
run = client.actor('fetch_cat/productreview-com-au-scraper').call(run_input={
    'startUrls': [{'url': 'https://www.productreview.com.au/c/mobile-phones'}],
    'maxItems': 25,
    'includeReviews': True,
})
print(run['defaultDatasetId'])
```

### API usage with cURL

```bash
curl -X POST 'https://api.apify.com/v2/acts/fetch_cat~productreview-com-au-scraper/runs?token=MY-APIFY-TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"startUrls":[{"url":"https://www.productreview.com.au/c/mobile-phones"}],"maxItems":25,"includeReviews":true}'
```

### MCP and AI agents

Use this actor with Apify MCP tools in Claude Code or Claude Desktop.

MCP URL:

`https://mcp.apify.com/?tools=fetch_cat/productreview-com-au-scraper`

Add it in Claude Code:

```bash
claude mcp add apify-productreview "https://mcp.apify.com/?tools=fetch_cat/productreview-com-au-scraper"
```

Claude Desktop JSON configuration:

```json
{
  "mcpServers": {
    "apify-productreview": {
      "url": "https://mcp.apify.com/?tools=fetch_cat/productreview-com-au-scraper"
    }
  }
}
```

Example prompts:

- "Run ProductReview.com.au Scraper for this category and summarize the highest-rated listings."

- "Collect 50 ProductReview rows for mobile phones and export the dataset URL."

- "Compare ratings and review counts for these ProductReview listing URLs."

### Scheduling

Create an Apify schedule for weekly category monitoring.

Keep the same start URLs for comparable reports.

Send finished-run webhooks to your reporting workflow.

Store historical datasets to track changes over time.

### Troubleshooting

#### Why did I get fewer rows than requested?

The page may expose fewer listings or reviews than your limit.

The actor stops when it reaches the available visible rows or your `maxItems` value.

#### Why is review text empty for some rows?

Some public metadata includes review rating, date, and author without the full body text.

The actor saves fields that are visible in the page data.

#### Can I scrape private account data?

No. This actor is designed for public ProductReview.com.au pages only.

### Limits

The actor is not affiliated with ProductReview.com.au.

Only scrape data you are allowed to use.

Respect ProductReview.com.au terms and applicable laws.

Use reasonable run sizes for monitoring.

Do not overload any website with unnecessary repeated runs.

### Legality

This actor extracts publicly available information.

You are responsible for ensuring your use case complies with laws, platform terms, and privacy requirements.

Avoid collecting or processing personal data unless you have a lawful basis.

If in doubt, consult your legal team before running large-scale monitoring.

### Related actors

More actors from fetch\_cat:

- [Google Play Reviews Scraper](https://apify.com/fetch_cat/google-play-reviews-scraper)
- [Shopify App Reviews Scraper](https://apify.com/fetch_cat/shopify-app-reviews-scraper)
- [Trustpilot Reviews Scraper](https://apify.com/fetch_cat/trustpilot-reviews-scraper)
- [Agoda Reviews Scraper](https://apify.com/fetch_cat/agoda-reviews-scraper)
- [Stack Exchange Questions Scraper](https://apify.com/fetch_cat/stack-exchange-questions-scraper)

### FAQ

#### Does it support category pages?

Yes. Paste a ProductReview.com.au category URL into Start URLs.

#### Does it support direct listing pages?

Yes. Direct listing pages are useful when you already know the product or business.

#### Does it support search?

Yes. Use a ProductReview search URL or the Search query input.

#### Can I export to CSV?

Yes. Apify datasets support CSV, JSON, Excel, XML, RSS, and API access.

#### Can I run it every day?

Yes. Use Apify schedules and keep limits appropriate for your monitoring need.

#### Is a proxy required?

Usually no. Leave proxy disabled unless your run environment needs one.

### Support

If a run fails, returns no data, or a field looks wrong, open an issue from the Actor page.

Please include the Apify run ID or run URL, input JSON, one example public URL, query, or input item, what you expected, and what the dataset returned. Small reproducible inputs make parsing or site-layout issues much faster to fix.

### Changelog

- `0.1` - Initial version for category, search, and listing URLs with listing rows and optional review rows.

# 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

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "ProductReview.com.au Scraper",
        "description": "Scrape public ProductReview.com.au listings, ratings, reviews, categories, and reviewer details from category, search, or listing URLs.",
        "version": "0.1",
        "x-build-id": "na3u2OW65GhVgQGdy"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/fetch_cat~productreview-com-au-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-fetch_cat-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/fetch_cat~productreview-com-au-scraper/runs": {
            "post": {
                "operationId": "runs-sync-fetch_cat-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/fetch_cat~productreview-com-au-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-fetch_cat-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": "Start URLs",
                        "type": "array",
                        "description": "ProductReview.com.au category, search, or listing URLs to scrape.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "query": {
                        "title": "Search query",
                        "type": "string",
                        "description": "Optional ProductReview search term. Use this when you do not have a start URL."
                    },
                    "maxItems": {
                        "title": "Maximum rows",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum listing and review rows to save in the dataset.",
                        "default": 20
                    },
                    "includeReviews": {
                        "title": "Include reviews",
                        "type": "boolean",
                        "description": "Save review rows from listing pages when review data is available.",
                        "default": true
                    },
                    "maxReviewsPerListing": {
                        "title": "Maximum reviews per listing",
                        "minimum": 0,
                        "maximum": 200,
                        "type": "integer",
                        "description": "Limit review rows saved from each listing page.",
                        "default": 10
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Optional Apify proxy settings. Leave disabled unless ProductReview blocks your network."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
