# Commercialrealestate Au Scraper (`crawlerbros/commercialrealestate-au-scraper`) Actor

Scrape commercial property listings from Australia's leading commercial real estate portal. Extract for-sale, for-lease, sold, and business listings with addresses, prices, property types, agency details, images, and GPS coordinates.

- **URL**: https://apify.com/crawlerbros/commercialrealestate-au-scraper.md
- **Developed by:** [Crawler Bros](https://apify.com/crawlerbros) (community)
- **Categories:** Automation, Real estate, Agents
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
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/docs.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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

## CommercialRealEstate.com.au Scraper

Extract commercial property listings from [commercialrealestate.com.au](https://www.commercialrealestate.com.au) — Australia's premier commercial real estate portal. Scrape for-sale, for-lease, sold, and business listings with addresses, prices, property types, agency details, images, and GPS coordinates.

### Features

- **4 listing types**: For Sale, For Lease, Sold, Business
- **State/territory filtering**: All 8 Australian states & territories
- **11 property type categories**: Offices, Industrial/Warehouse, Retail, Development Land, Rural/Farming, Showrooms, Medical, Hotel/Leisure, Parking, Serviced Offices, Other
- **Location search**: Filter by state or specific location slug (e.g. `sydney-nsw`, `melbourne-vic-3000`)
- **Keyword search**: Find listings by keyword (e.g. `warehouse`, `childcare`, `petrol station`), combinable with state and/or property type in a single search
- **Dual modes**: Build a search from filters, or provide your own CRE.com.au URLs
- **30+ output fields** per listing including GPS coordinates, all images, agent details

### Input Parameters

| Parameter | Type | Description |
|-----------|------|-------------|
| `mode` | String | `search` (build from filters) or `startUrls` (your own URLs) |
| `listingMode` | String | `for-sale`, `for-lease`, `sold`, or `business` |
| `states` | Array | One or more: NSW, VIC, QLD, SA, WA, TAS, ACT, NT |
| `propertyType` | String | Property category (see full list below). Not applicable to `business` listings. |
| `locationSlug` | String | Specific location slug from a CRE URL (e.g. `sydney-nsw`). Overrides `states`/`propertyType`/`keyword` — CRE's location resolver only accepts a single path segment. |
| `keyword` | String | Keyword to search (e.g. `warehouse`, `childcare`). Combines with `states` and/or `propertyType` when set. |
| `startUrls` | Array | CRE.com.au URLs to process directly |
| `maxItems` | Integer | Maximum listings to return (default: 20, max: 10,000) |
| `proxyConfiguration` | Object | Apify proxy config — recommended for `for-sale`, `for-lease`, and `business` listing types |

#### Property Type Values

| Value | Label |
|-------|-------|
| `offices` | Offices |
| `industrial-warehouse` | Industrial / Warehouse |
| `retail` | Shop & Retail |
| `development-land` | Development / Land |
| `rural-commercial-farming` | Rural Commercial / Farming |
| `showrooms-bulky-goods` | Showrooms / Bulky Goods |
| `medical-consulting` | Medical / Consulting |
| `hotel-leisure` | Hotel / Leisure |
| `parking-car-space` | Parking / Car Space |
| `serviced-offices` | Serviced Offices |
| `other` | Other |

### Output Fields

Each record includes:

| Field | Description |
|-------|-------------|
| `adID` | Unique numeric listing ID |
| `url` | Full URL to the property detail page |
| `headline` | Listing title/headline |
| `description` | Short property description |
| `displayableAddress` | Full formatted address |
| `street` | Street address |
| `suburb` | Suburb name |
| `state` | State/territory code (NSW, VIC, etc.) |
| `postcode` | Australian postcode |
| `region` | Geographic region (e.g. Eastern Suburbs) |
| `area` | Local government area |
| `price` | Price string (e.g. `$1,200,000` or `Contact Agent`) |
| `saleType` | Listing type (For Sale, Leased, Sold, etc.) |
| `saleMethod` | Method of sale (Auction, EOI, Private Treaty) |
| `listingStatus` | Status flag (New, Updated) |
| `soldLeasedDate` | Date sold or leased (ISO format) |
| `soldLeasedPricing` | Disclosed sale/lease price |
| `auctionDate` | Scheduled auction date |
| `areaDisplay` | Property area display (e.g. `994 m²`) |
| `mainCategory` | Primary property category |
| `propertyTypes` | All property type labels for this listing |
| `isUnderOffer` | Boolean — currently under offer |
| `hasVideo` | Boolean — video tour available |
| `hasVirtualTour` | Boolean — virtual tour available |
| `cardImageUrl` | Primary listing image URL |
| `images` | Array of all image URLs |
| `agencyName` | Real estate agency name |
| `agencyLogoUrl` | Agency logo image URL |
| `agents` | Array of `{name, photo}` agent objects |
| `latitude` | Property latitude |
| `longitude` | Property longitude |

### Usage Examples

#### Sold offices in NSW (no proxy needed — recommended default)
```json
{
  "mode": "search",
  "listingMode": "sold",
  "states": ["NSW"],
  "propertyType": "offices",
  "maxItems": 20
}
````

#### Sold warehouses in NSW (state + keyword combined)

```json
{
  "mode": "search",
  "listingMode": "sold",
  "states": ["NSW"],
  "keyword": "warehouse",
  "maxItems": 20
}
```

#### For-lease warehouses across Australia

```json
{
  "mode": "search",
  "listingMode": "for-lease",
  "propertyType": "industrial-warehouse",
  "maxItems": 20,
  "proxyConfiguration": {"useApifyProxy": true, "apifyProxyGroups": ["AUTO"], "apifyProxyCountry": "AU"}
}
```

#### Specific URL scraping

```json
{
  "mode": "startUrls",
  "startUrls": [
    {"url": "https://www.commercialrealestate.com.au/sold/sydney-nsw/offices/"}
  ],
  "maxItems": 20
}
```

#### Keyword search

```json
{
  "mode": "search",
  "listingMode": "for-sale",
  "keyword": "childcare",
  "maxItems": 20
}
```

### Notes on Proxy

- **`sold`** listings work reliably with **no proxy** from any IP — this is the recommended default and requires no configuration.
- **`for-sale`**, **`for-lease`**, and **`business`** listing types are behind commercialrealestate.com.au's Akamai bot protection. Setting `proxyConfiguration` with an Australian datacenter IP (`apifyProxyGroups: ["AUTO"]`, `apifyProxyCountry: "AU"`) sometimes bypasses it, but Akamai also blocks by IP reputation independent of geography, so results on these three modes are **not guaranteed** even with proxy enabled — a run may legitimately return 0 records. If you need consistent access to these modes, supply your own residential proxy via `proxyConfiguration`.
- All individual property detail page URLs (`url` field) are also behind the same Akamai protection — they open fine in a real browser, but a bare `curl`/script request (even with a browser User-Agent) will get HTTP 403. This is expected and not a broken link.

### Limitations

- **~20 listings per filter combination.** commercialrealestate.com.au renders each search URL server-side with a fixed page of 20 results; it does not expose a page/offset query parameter that returns a *different* page of the *same* filter combination (verified: `/sold/nsw/offices/2/`, `/sold/nsw/offices/?page=2`, and `/sold/nsw/offices/list-2` are each interpreted by the site's router as an entirely different search, not "page 2" of the original one). Raising `maxItems` above ~20 for a single state/type/keyword combination will not return more results for that combination.
  - **Workaround:** select multiple `states` (each state is its own URL, up to 20 more per state) or narrow with a specific `locationSlug` (suburb/postcode) to get a different, smaller result set.
- **`locationSlug` cannot be combined** with `states`, `propertyType`, or `keyword`. It's a single resolved path segment on CRE's site, and the site's router silently drops the location filter when any other segment follows it. Use `locationSlug` on its own for suburb/postcode-level searches.
- **`propertyType` does not apply to `business` listings** — business listings use a separate, unexposed category taxonomy (e.g. "Food, Beverage & Hospitality") rather than the commercial property types.

### FAQ

**Q: Why do I only get up to ~20 results per search?**
Each search URL is rendered server-side with a fixed page of 20 listings, and the site doesn't expose a working page/offset parameter for a single filter combination (see Limitations above). For more coverage, select multiple states, or use a specific location slug.

**Q: How do I find location slugs?**
Copy the URL slug from a commercialrealestate.com.au search page, e.g. from `https://www.commercialrealestate.com.au/for-sale/sydney-nsw/` use `sydney-nsw`.

**Q: Does this require authentication?**
No. All listing data is publicly accessible without login.

**Q: Why did my for-sale / for-lease / business run return 0 results?**
Those three listing types are protected by Akamai bot detection that blocks by IP reputation, not just geography — even an Australian-flagged Apify proxy IP can be blocked. Try again (proxy IPs rotate) or supply your own residential proxy. `sold` listings are unaffected and always reliable.

**Q: How current is the data?**
Data is fetched live from commercialrealestate.com.au at scrape time.

# Actor input Schema

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

Choose how to find listings: build a search from filters, or provide specific URLs.

## `listingMode` (type: `string`):

Which type of listings to scrape (used in Search mode).

## `states` (type: `array`):

Limit results to one or more Australian states/territories (used in Search mode). Leave empty for all of Australia.

## `propertyType` (type: `string`):

Filter by commercial property category (used in Search mode). Leave empty for all types.

## `locationSlug` (type: `string`):

Specific location slug from a CRE URL, e.g. 'sydney-nsw', 'melbourne-vic-3000', or 'brisbane-qld'. Overrides States filter.

## `keyword` (type: `string`):

Keyword to search for in listing titles and descriptions, e.g. 'warehouse', 'childcare', 'petrol station'.

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

List of commercialrealestate.com.au URLs to scrape (used in Start URLs mode). Can be search result pages, individual property pages, agent profiles, or agency pages.

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

Maximum number of listings to return. Each search URL returns up to 20 listings.

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

Apify proxy settings. Recommended for for-sale, for-lease, and business listing types — commercialrealestate.com.au's Akamai bot protection blocks most non-Australian and datacenter IPs on those paths, so results are not guaranteed even with proxy enabled. Not needed for sold listings, which work reliably with no proxy. Left empty by default so the default (sold) run has zero proxy dependency.

## Actor input object example

```json
{
  "mode": "search",
  "listingMode": "sold",
  "startUrls": [
    {
      "url": "https://www.commercialrealestate.com.au/sold/nsw/offices/"
    }
  ],
  "maxItems": 20
}
```

# Actor output Schema

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

Dataset containing all scraped commercial property listings.

# API

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

## JavaScript example

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

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

// Prepare Actor input
const input = {
    "mode": "search",
    "listingMode": "sold",
    "startUrls": [
        {
            "url": "https://www.commercialrealestate.com.au/sold/nsw/offices/"
        }
    ],
    "maxItems": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/commercialrealestate-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 = {
    "mode": "search",
    "listingMode": "sold",
    "startUrls": [{ "url": "https://www.commercialrealestate.com.au/sold/nsw/offices/" }],
    "maxItems": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("crawlerbros/commercialrealestate-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 '{
  "mode": "search",
  "listingMode": "sold",
  "startUrls": [
    {
      "url": "https://www.commercialrealestate.com.au/sold/nsw/offices/"
    }
  ],
  "maxItems": 20
}' |
apify call crawlerbros/commercialrealestate-au-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Commercialrealestate Au Scraper",
        "description": "Scrape commercial property listings from Australia's leading commercial real estate portal. Extract for-sale, for-lease, sold, and business listings with addresses, prices, property types, agency details, images, and GPS coordinates.",
        "version": "1.0",
        "x-build-id": "LFgTwgJ3NAobymRj6"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/crawlerbros~commercialrealestate-au-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-crawlerbros-commercialrealestate-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/crawlerbros~commercialrealestate-au-scraper/runs": {
            "post": {
                "operationId": "runs-sync-crawlerbros-commercialrealestate-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/crawlerbros~commercialrealestate-au-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-crawlerbros-commercialrealestate-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": {
                    "mode": {
                        "title": "Mode",
                        "enum": [
                            "search",
                            "startUrls"
                        ],
                        "type": "string",
                        "description": "Choose how to find listings: build a search from filters, or provide specific URLs.",
                        "default": "search"
                    },
                    "listingMode": {
                        "title": "Listing Type",
                        "enum": [
                            "for-sale",
                            "for-lease",
                            "sold",
                            "business"
                        ],
                        "type": "string",
                        "description": "Which type of listings to scrape (used in Search mode).",
                        "default": "sold"
                    },
                    "states": {
                        "title": "States / Territories",
                        "type": "array",
                        "description": "Limit results to one or more Australian states/territories (used in Search mode). Leave empty for all of Australia.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "NSW",
                                "VIC",
                                "QLD",
                                "SA",
                                "WA",
                                "TAS",
                                "ACT",
                                "NT"
                            ],
                            "enumTitles": [
                                "New South Wales",
                                "Victoria",
                                "Queensland",
                                "South Australia",
                                "Western Australia",
                                "Tasmania",
                                "Australian Capital Territory",
                                "Northern Territory"
                            ]
                        }
                    },
                    "propertyType": {
                        "title": "Property Type",
                        "enum": [
                            "offices",
                            "industrial-warehouse",
                            "retail",
                            "development-land",
                            "rural-commercial-farming",
                            "showrooms-bulky-goods",
                            "medical-consulting",
                            "hotel-leisure",
                            "parking-car-space",
                            "serviced-offices",
                            "other"
                        ],
                        "type": "string",
                        "description": "Filter by commercial property category (used in Search mode). Leave empty for all types."
                    },
                    "locationSlug": {
                        "title": "Location Slug",
                        "type": "string",
                        "description": "Specific location slug from a CRE URL, e.g. 'sydney-nsw', 'melbourne-vic-3000', or 'brisbane-qld'. Overrides States filter."
                    },
                    "keyword": {
                        "title": "Keyword",
                        "type": "string",
                        "description": "Keyword to search for in listing titles and descriptions, e.g. 'warehouse', 'childcare', 'petrol station'."
                    },
                    "startUrls": {
                        "title": "Start URLs",
                        "type": "array",
                        "description": "List of commercialrealestate.com.au URLs to scrape (used in Start URLs mode). Can be search result pages, individual property pages, agent profiles, or agency pages.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxItems": {
                        "title": "Max Items",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of listings to return. Each search URL returns up to 20 listings.",
                        "default": 20
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Apify proxy settings. Recommended for for-sale, for-lease, and business listing types — commercialrealestate.com.au's Akamai bot protection blocks most non-Australian and datacenter IPs on those paths, so results are not guaranteed even with proxy enabled. Not needed for sold listings, which work reliably with no proxy. Left empty by default so the default (sold) run has zero proxy dependency."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
