# Amazon Australia Product & Reviews Scraper (`abotapi/amazon-au-scraper`) Actor

Scrape Amazon Australia (amazon.com.au) products and customer reviews. Search by keyword or paste product, search and category URLs. Returns title, brand, price, list price, rating, review count, star distribution, availability, features, images, categories, specs, best-seller rank and seller.

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

## Pricing

from $1.50 / 1,000 product results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are 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

## Amazon Australia Product & Reviews Scraper

Scrape **[amazon.com.au](https://www.amazon.com.au)** products and customer reviews at scale. Search by keyword with filters, or paste product / search / category links (or bare ASINs). Every product comes back as one flat record with price, ratings, star distribution, images, specifications and - optionally - the customer reviews Amazon publishes on the product page.

### What it does

- **Two ways to start**
  - **Search** - one or more keywords, with sort, minimum-rating and price-range filters, walking forward through result pages.
  - **URL** - paste product pages (`/dp/<ASIN>`), search pages (`/s?k=...`), category pages, or bare 10-character ASINs.
- **Full product detail** - open each product page for brand, list price, star distribution, availability, feature bullets, description, the full image gallery, category breadcrumb, specifications, best-seller rank and seller.
- **Customer reviews** - collect the reviews Amazon publishes on each product page: star rating, title, text, author, date, verified-purchase flag and helpful votes, plus aggregate rating statistics.
- **Send results into your apps** - optional Notion / Linear / Airtable / Apify export via MCP connectors, without changing the dataset.

### Reviews: what you get

Amazon Australia shows the **aggregate rating** (average score, total ratings, and the 5-star-to-1-star distribution) and a set of **top customer reviews** to anonymous visitors - this actor captures all of them.

> **Note:** amazon.com.au requires a signed-in account to open its **full paginated review list**. This actor does not sign in, so review collection returns the top reviews Amazon exposes publicly on the product page (typically the most relevant ones), each with full title, text, rating, author, date, verified-purchase flag and helpful-vote count. The aggregate rating, total rating count and star distribution are always captured in full.

### Input

| Field | Type | Description |
|-------|------|-------------|
| `mode` | select | `search` (keyword + filters) or `url` (paste links / ASINs). |
| `queries` | string[] | Search keywords (search mode). Each keyword is searched separately. |
| `sortBy` | select | `relevance`, `price_asc`, `price_desc`, `newest`, `avg_rating`, `best_selling`. |
| `minRating` | select | Keep products rated at least `3`, `4` or `5` stars (or any). |
| `minPrice` / `maxPrice` | integer | Keep products within an AUD price range. |
| `urls` | string[] | Product / search / category URLs, or bare ASINs (url mode). |
| `fetchDetails` | boolean | Open each product page for full detail. Default `true`. |
| `fetchReviews` | boolean | Also collect customer reviews. Default `false`. |
| `maxReviewsPerProduct` | integer | Cap reviews per product (`0` = all available). Default `10`. |
| `maxItems` | integer | Max products for the whole run (`0` = unlimited). Default `20`. |
| `maxPages` | integer | Safety cap on result pages walked per keyword/URL. |
| `proxy` | object | Proxy configuration (Australian residential recommended). |
| `mcpConnectors` | array | Optional MCP connectors to export results into. |

#### Example input

```json
{
  "mode": "search",
  "queries": ["echo dot"],
  "sortBy": "avg_rating",
  "minRating": "4",
  "minPrice": 30,
  "maxPrice": 150,
  "fetchDetails": true,
  "fetchReviews": true,
  "maxReviewsPerProduct": 10,
  "maxItems": 20,
  "proxy": { "useApifyProxy": true, "apifyProxyGroups": ["RESIDENTIAL"], "apifyProxyCountry": "AU" }
}
````

### Output

One record per product. Example (values below are illustrative):

```json
{
  "asin": "B0EXAMPLE01",
  "title": "Example Smart Speaker (3rd Gen) with Voice Assistant - Charcoal",
  "url": "https://www.amazon.com.au/dp/B0EXAMPLE01",
  "brand": "ExampleBrand",
  "price": 79.0,
  "listPrice": 99.0,
  "currency": "AUD",
  "savings": 20.0,
  "savingsPercent": 20,
  "rating": 4.5,
  "reviewsCount": 1284,
  "ratingDistribution": { "5": 72, "4": 15, "3": 6, "2": 3, "1": 4 },
  "availability": "In stock",
  "inStock": true,
  "features": [
    "Rich, room-filling sound with clear vocals",
    "Ask the voice assistant to play music, set timers and control smart devices"
  ],
  "description": "A compact smart speaker for any room.",
  "categories": ["Electronics", "Smart Home", "Smart Speakers"],
  "specs": { "Model Number": "EX-3000", "Release Year": "2024", "Connectivity": "Wi-Fi, Bluetooth" },
  "bestSellersRank": 12,
  "seller": "Example Retail AU",
  "shipsFrom": "Amazon AU",
  "images": [
    "https://m.media-amazon.com/images/I/EXAMPLE01._AC_SL1000_.jpg",
    "https://m.media-amazon.com/images/I/EXAMPLE02._AC_SL1000_.jpg"
  ],
  "thumbnailImage": "https://m.media-amazon.com/images/I/EXAMPLE01._AC_SL1000_.jpg",
  "reviewsCollected": 8,
  "reviewStats": {
    "averageRating": 4.5,
    "totalRatings": 1284,
    "ratingDistribution": { "5": 72, "4": 15, "3": 6, "2": 3, "1": 4 }
  },
  "reviews": [
    {
      "reviewId": "REXAMPLE00001",
      "rating": 5.0,
      "title": "Great value",
      "body": "Easy to set up and the sound is excellent for the size.",
      "author": "Sample Reviewer",
      "date": "2025-02-14",
      "reviewedIn": "Australia",
      "verifiedPurchase": true,
      "helpfulCount": 6,
      "variation": "Colour Name: Charcoal",
      "reviewUrl": "https://www.amazon.com.au/gp/customer-reviews/REXAMPLE00001"
    }
  ],
  "searchMode": "search"
}
```

#### Field reference

| Field | Description |
|-------|-------------|
| `asin` | Amazon product identifier. |
| `title`, `brand`, `url` | Product name, brand, canonical product URL. |
| `price`, `listPrice`, `currency`, `savings`, `savingsPercent` | Current price, was-price, AUD, and computed savings. |
| `rating`, `reviewsCount`, `ratingDistribution` | Average stars, total rating count, and the 5★→1★ percentage split. |
| `availability`, `inStock` | Stock text and a boolean. |
| `features`, `description` | Feature bullets and long description. |
| `categories`, `specs`, `bestSellersRank` | Category breadcrumb, specification table, best-seller rank. |
| `seller`, `shipsFrom` | Seller / dispatch information from the buy box. |
| `images`, `thumbnailImage` | Full image gallery and the primary image. |
| `reviews`, `reviewsCollected`, `reviewStats` | Collected reviews, their count, and aggregate statistics (present when reviews are enabled). |

Whenever a value is not published for a product, the field is omitted or `null` rather than guessed.

### Proxy

Amazon Australia serves results to Australian residential connections, so the actor uses an **Australian residential** exit by default and rotates a fresh exit per request. Apify Proxy is recommended for reliable results.

### Notes

- Prices, ratings and stock are captured as shown on the storefront at scrape time.
- Filters (`minRating`, `minPrice`, `maxPrice`) are applied to each product's own values, so exact numeric ranges work independently of Amazon's coarse on-site filters.

# Actor input Schema

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

Choose 'search' to use keywords and filters, or 'url' to scrape specific Amazon Australia product, search or category URLs (or bare ASINs) you paste below.

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

One or more keywords to search, for example 'echo dot' or 'coffee machine'. Each keyword is searched separately.

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

Result ordering, as offered by Amazon.

## `minRating` (type: `string`):

Optional. Only keep products whose average customer rating is at least this many stars.

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

Optional. Only keep products priced at or above this amount.

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

Optional. Only keep products priced at or below this amount.

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

Product, search or category URLs (or bare 10-character ASINs) to scrape, for example https://www.amazon.com.au/s?k=echo+dot or a product page ending in /dp/<ASIN>. Multiple entries supported.

## `fetchDetails` (type: `boolean`):

Open each product page to collect its full detail (brand, list price, star distribution, availability, feature bullets, description, all images, category path, specifications, best-seller rank, seller). Adds one page fetch per product.

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

Also collect the customer reviews Amazon publishes on each product page (star rating, title, text, author, date, verified-purchase flag, helpful votes) plus aggregate rating statistics. Uses the same product-page fetch as details. Note: Amazon Australia gates its full paginated review list behind sign-in for anonymous visitors, so this returns the top reviews Amazon exposes publicly.

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

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

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

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

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

Optional safety bound on result pages walked per keyword/URL. Leave empty for the deepest Amazon serves (about 20 pages). This does NOT cap the number of products — the run stops at Max products.

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

Apify Proxy is required for reliable results. The actor connects through an Australian residential exit by default.

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

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

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

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

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

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

## Actor input object example

```json
{
  "mode": "search",
  "queries": [
    "echo dot"
  ],
  "sortBy": "relevance",
  "minRating": "0",
  "urls": [
    "https://www.amazon.com.au/s?k=echo+dot"
  ],
  "fetchDetails": true,
  "fetchReviews": false,
  "maxReviewsPerProduct": 10,
  "maxItems": 20,
  "proxy": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "AU"
  },
  "maxNotifyListings": 50
}
```

# Actor output Schema

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

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

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

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "queries": [
        "echo dot"
    ],
    "urls": [
        "https://www.amazon.com.au/s?k=echo+dot"
    ],
    "proxy": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "apifyProxyCountry": "AU"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("abotapi/amazon-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 = {
    "queries": ["echo dot"],
    "urls": ["https://www.amazon.com.au/s?k=echo+dot"],
    "proxy": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "AU",
    },
}

# Run the Actor and wait for it to finish
run = client.actor("abotapi/amazon-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 '{
  "queries": [
    "echo dot"
  ],
  "urls": [
    "https://www.amazon.com.au/s?k=echo+dot"
  ],
  "proxy": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "AU"
  }
}' |
apify call abotapi/amazon-au-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Amazon Australia Product & Reviews Scraper",
        "description": "Scrape Amazon Australia (amazon.com.au) products and customer reviews. Search by keyword or paste product, search and category URLs. Returns title, brand, price, list price, rating, review count, star distribution, availability, features, images, categories, specs, best-seller rank and seller.",
        "version": "1.0",
        "x-build-id": "O6zdkEwbtgd5UO2Qa"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/abotapi~amazon-au-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-abotapi-amazon-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/abotapi~amazon-au-scraper/runs": {
            "post": {
                "operationId": "runs-sync-abotapi-amazon-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/abotapi~amazon-au-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-abotapi-amazon-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",
                "required": [
                    "mode"
                ],
                "properties": {
                    "mode": {
                        "title": "Mode",
                        "enum": [
                            "search",
                            "url"
                        ],
                        "type": "string",
                        "description": "Choose 'search' to use keywords and filters, or 'url' to scrape specific Amazon Australia product, search or category URLs (or bare ASINs) you paste below.",
                        "default": "search"
                    },
                    "queries": {
                        "title": "Search keywords",
                        "type": "array",
                        "description": "One or more keywords to search, for example 'echo dot' or 'coffee machine'. Each keyword is searched separately.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "sortBy": {
                        "title": "Sort by",
                        "enum": [
                            "relevance",
                            "price_asc",
                            "price_desc",
                            "newest",
                            "avg_rating",
                            "best_selling"
                        ],
                        "type": "string",
                        "description": "Result ordering, as offered by Amazon.",
                        "default": "relevance"
                    },
                    "minRating": {
                        "title": "Minimum average rating",
                        "enum": [
                            "0",
                            "3",
                            "4",
                            "5"
                        ],
                        "type": "string",
                        "description": "Optional. Only keep products whose average customer rating is at least this many stars.",
                        "default": "0"
                    },
                    "minPrice": {
                        "title": "Minimum price (AUD)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Optional. Only keep products priced at or above this amount."
                    },
                    "maxPrice": {
                        "title": "Maximum price (AUD)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Optional. Only keep products priced at or below this amount."
                    },
                    "urls": {
                        "title": "Amazon Australia URLs / ASINs",
                        "type": "array",
                        "description": "Product, search or category URLs (or bare 10-character ASINs) to scrape, for example https://www.amazon.com.au/s?k=echo+dot or a product page ending in /dp/<ASIN>. Multiple entries supported.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "fetchDetails": {
                        "title": "Fetch product details",
                        "type": "boolean",
                        "description": "Open each product page to collect its full detail (brand, list price, star distribution, availability, feature bullets, description, all images, category path, specifications, best-seller rank, seller). Adds one page fetch per product.",
                        "default": true
                    },
                    "fetchReviews": {
                        "title": "Fetch customer reviews",
                        "type": "boolean",
                        "description": "Also collect the customer reviews Amazon publishes on each product page (star rating, title, text, author, date, verified-purchase flag, helpful votes) plus aggregate rating statistics. Uses the same product-page fetch as details. Note: Amazon Australia gates its full paginated review list behind sign-in for anonymous visitors, so this returns the top reviews Amazon exposes publicly.",
                        "default": false
                    },
                    "maxReviewsPerProduct": {
                        "title": "Max reviews per product",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Cap on reviews collected per product when 'Fetch customer reviews' is on. Use 0 for all publicly available reviews on the product page.",
                        "default": 10
                    },
                    "maxItems": {
                        "title": "Max products",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum number of products to return across the whole run. Use 0 for unlimited.",
                        "default": 20
                    },
                    "maxPages": {
                        "title": "Max pages per search",
                        "minimum": 0,
                        "maximum": 20,
                        "type": "integer",
                        "description": "Optional safety bound on result pages walked per keyword/URL. Leave empty for the deepest Amazon serves (about 20 pages). This does NOT cap the number of products — the run stops at Max products."
                    },
                    "proxy": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Apify Proxy is required for reliable results. The actor connects through an Australian residential exit by default.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ],
                            "apifyProxyCountry": "AU"
                        }
                    },
                    "mcpConnectors": {
                        "title": "Pipe results into your apps (optional)",
                        "type": "array",
                        "description": "Optionally send results into the apps you already use, via Model Context Protocol (MCP) connectors. Authorize one under Apify, Settings, API & Integrations, then select it here. Notion gets a rich page-per-item export; other connectors get a best-effort write/digest. Leave empty to skip; never changes the dataset output. Supported: Notion (https://mcp.notion.com/mcp), Linear (https://mcp.linear.app/sse), Airtable (https://mcp.airtable.com/mcp), Apify (https://mcp.apify.com)."
                    },
                    "notionParentPageUrl": {
                        "title": "Notion parent page (Notion connector only)",
                        "type": "string",
                        "description": "URL or id of the Notion page under which item pages are created. Required to enable the Notion export; ignored by other connectors."
                    },
                    "maxNotifyListings": {
                        "title": "Max items to export per connector",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Cap on items written to each connector per run. Does not affect the dataset.",
                        "default": 50
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
