# Trade Me Property Scraper (`crawlerbros/trademe-property-scraper`) Actor

Scrape Trade Me Property, New Zealand's largest property marketplace. Search residential properties for sale or rent by region, price, bedrooms, bathrooms, and property type. Extracts address, price, features, agency, open homes, GPS coordinates, and more.

- **URL**: https://apify.com/crawlerbros/trademe-property-scraper.md
- **Developed by:** [Crawler Bros](https://apify.com/crawlerbros) (community)
- **Categories:** Real estate, Automation, Developer tools
- **Stats:** 1 total users, 0 monthly users, 100.0% runs succeeded, 7 bookmarks
- **User rating**: 5.00 out of 5 stars

## 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.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

## Trade Me Property Scraper

Extract residential property listings from [Trade Me Property](https://www.trademe.co.nz/a/property) — New Zealand's largest property marketplace. Search for homes for sale or rent across all New Zealand regions, filter by price, bedrooms, bathrooms, and property type. Enrich specific listing URLs with full details.

### What It Extracts

- **Listing details** — ID, title, URL, listing date
- **Location** — address, suburb, city (district), region, GPS coordinates (latitude/longitude)
- **Property attributes** — type (house/apartment/townhouse/etc.), bedrooms, bathrooms, garages/parking, floor area, land area
- **Pricing** — sale price, display price ("By Negotiation", "$850,000"), weekly rent for rentals
- **Agency info** — real estate agency name and agent name
- **Open homes** — upcoming open home dates and times
- **Description** — full property description text
- **Features** — amenity list (heat pump, double glazing, etc.)
- **Valuation** — rateable/council value (RV) in NZD
- **Images** — primary image URL and full list of property photos
- **Rental extras** — available-from date, pets policy

### Authentication

This actor uses the [Trade Me REST API](https://developer.trademe.co.nz/). You need a free Trade Me developer account to get a consumer key and secret:

1. Go to [https://www.trademe.co.nz/developers](https://www.trademe.co.nz/developers)
2. Register your application (takes under 1 minute)
3. Copy your **consumer key** and **consumer secret** into the actor inputs

### Input

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `consumerKey` | String | Yes | Trade Me API consumer key |
| `consumerSecret` | String | Yes | Trade Me API consumer secret |
| `mode` | Select | Yes | `searchForSale` / `searchForRent` / `byListingUrls` |
| `region` | Select | No | NZ region (default: All New Zealand) |
| `propertyType` | Select | No | Property type filter (default: all types) |
| `minPrice` | Integer | No | Minimum price in NZD |
| `maxPrice` | Integer | No | Maximum price in NZD |
| `minBedrooms` | Integer | No | Minimum number of bedrooms |
| `maxBedrooms` | Integer | No | Maximum number of bedrooms |
| `minBathrooms` | Integer | No | Minimum number of bathrooms |
| `startUrls` | String list | No | Trade Me listing URLs (mode=byListingUrls only) |
| `maxItems` | Integer | No | Maximum listings to return (default: 50, max: 5000) |

#### Modes

- **searchForSale** — Search residential properties listed for sale. Apply region, price, bedroom, and property type filters.
- **searchForRent** — Search rental properties. Results include weekly rent and availability date.
- **byListingUrls** — Enrich one or more specific Trade Me listing URLs (e.g. `https://www.trademe.co.nz/a/property/residential/sale/listing/12345678`).

#### Available Regions

| ID | Region |
|----|--------|
| 1 | Auckland |
| 2 | Bay of Plenty |
| 3 | Canterbury |
| 4 | Gisborne |
| 5 | Hawke's Bay |
| 6 | Manawatu / Whanganui |
| 7 | Marlborough |
| 8 | Nelson / Tasman |
| 9 | Northland |
| 10 | Otago |
| 11 | Southland |
| 12 | Taranaki |
| 13 | Waikato |
| 14 | Wellington |
| 15 | West Coast |
| 100 | All New Zealand |

### Output

Each record in the dataset follows this structure:

| Field | Type | Description |
|-------|------|-------------|
| `listingId` | String | Trade Me listing ID |
| `title` | String | Listing title |
| `url` | String | Canonical listing URL |
| `imageUrl` | String | Primary photo URL |
| `images` | Array | All photo URLs |
| `address` | String | Street address |
| `suburb` | String | Suburb name |
| `city` | String | City / district |
| `region` | String | NZ region name |
| `propertyType` | String | House / Apartment / Townhouse / etc. |
| `bedrooms` | Integer | Number of bedrooms |
| `bathrooms` | Integer | Number of bathrooms |
| `garages` | Integer | Number of garage / parking spots |
| `landArea` | Integer | Land area in square metres |
| `floorArea` | Integer | Floor area in square metres |
| `price` | Integer | Price in NZD (for-sale listings) |
| `priceDisplay` | String | Human-readable price text |
| `rentPerWeek` | Integer | Weekly rent in NZD (rental listings) |
| `availableFrom` | String | Available-from date (rental listings) |
| `petsOkay` | String | Pet policy: Yes / No / Negotiable (rental) |
| `agency` | String | Real estate agency name |
| `agentName` | String | Agent's full name |
| `listingDate` | String | Date first listed (ISO format) |
| `openHomeDates` | Array | Upcoming open home date/time strings |
| `description` | String | Full property description |
| `features` | Array | Amenity list (e.g. "Heat pump", "Double glazing") |
| `latitude` | Float | GPS latitude |
| `longitude` | Float | GPS longitude |
| `rateable` | Integer | Council/rateable value in NZD |
| `isBrokerMarketplace` | Boolean | Whether listed through broker marketplace |
| `recordType` | String | Always `"tradeMeProperty"` |
| `scrapedAt` | String | ISO 8601 UTC scrape timestamp |

#### Example Output

```json
{
  "listingId": "123456789",
  "title": "Charming 3-Bedroom Home with Garden",
  "url": "https://www.trademe.co.nz/a/property/residential/sale/listing/123456789",
  "imageUrl": "https://photos.trademe.co.nz/property/123/photo1_fullsize.jpg",
  "images": [
    "https://photos.trademe.co.nz/property/123/photo1_fullsize.jpg",
    "https://photos.trademe.co.nz/property/123/photo2_fullsize.jpg"
  ],
  "address": "12 Oak Street",
  "suburb": "Newtown",
  "city": "Wellington City",
  "region": "Wellington",
  "propertyType": "House",
  "bedrooms": 3,
  "bathrooms": 2,
  "garages": 1,
  "landArea": 650,
  "floorArea": 145,
  "price": 850000,
  "priceDisplay": "$850,000",
  "agency": "Ray White Wellington",
  "agentName": "Jane Smith",
  "listingDate": "2026-04-01T00:00:00",
  "openHomeDates": ["2026-05-18T11:00:00", "2026-05-25T14:00:00"],
  "description": "Beautiful home with modern kitchen, double glazing, and a sunny garden.",
  "features": ["Heat pump", "Double glazing", "Garaging: Single lock-up"],
  "latitude": -41.2924,
  "longitude": 174.7787,
  "rateable": 780000,
  "isBrokerMarketplace": false,
  "recordType": "tradeMeProperty",
  "scrapedAt": "2026-05-15T10:30:00+00:00"
}
````

### FAQ

**What regions are available?**
All 15 New Zealand regions plus "All New Zealand" are supported: Auckland, Bay of Plenty, Canterbury, Gisborne, Hawke's Bay, Manawatu/Whanganui, Marlborough, Nelson/Tasman, Northland, Otago, Southland, Taranaki, Waikato, Wellington, and West Coast. Set `region` to the region ID or leave it blank for a nationwide search.

**Can I filter by price?**
Yes. Set `minPrice` and/or `maxPrice` in New Zealand dollars. For example, `minPrice: 500000` and `maxPrice: 800000` returns properties between $500k and $800k NZD.

**How do I get rental listings?**
Set `mode` to `searchForRent`. The output will include `rentPerWeek` (weekly rent in NZD), `availableFrom` (move-in date), and `petsOkay` fields in place of sale price fields.

**How many listings can I scrape?**
Up to 5,000 per run. Trade Me returns 20 listings per page. Set `maxItems` to control the total. For large nationwide searches, start with `maxItems: 50` to preview results before running a full scrape.

**Do I need a Trade Me account?**
You need a free Trade Me developer account to obtain API credentials (consumer key + secret). Register at <https://www.trademe.co.nz/developers> — it takes under a minute and is free. The API is free for non-commercial use under Trade Me's developer terms.

**Can I scrape a specific listing?**
Yes. Set `mode` to `byListingUrls` and provide one or more listing URLs in the `startUrls` field. Both for-sale and rental listing URLs are accepted.

**What property types can I filter by?**
House, Townhouse, Apartment, Unit, Section/Land, Lifestyle, Rural, New Development, and Carpark.

**Are images included?**
Yes. The `imageUrl` field contains the primary photo, and `images` contains all available full-size photos as an array of URLs.

**Is GPS location included?**
When available from Trade Me's data, `latitude` and `longitude` are included so you can plot listings on a map.

**What is the rateable value?**
The `rateable` field is the council valuation (RV) of the property in NZD. This is the government-assessed value used for rate calculations, not the market price.

# Actor input Schema

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

What to scrape: residential properties for sale, rental listings, or enrich specific listing URLs.

## `region` (type: `string`):

New Zealand region to search. Use 'All New Zealand' for nationwide results.

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

Type of property to filter results.

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

Minimum listing price in New Zealand dollars.

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

Maximum listing price in New Zealand dollars.

## `minBedrooms` (type: `integer`):

Minimum number of bedrooms.

## `maxBedrooms` (type: `integer`):

Maximum number of bedrooms.

## `minBathrooms` (type: `integer`):

Minimum number of bathrooms.

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

Trade Me property listing URLs to enrich, e.g. https://www.trademe.co.nz/a/property/residential/sale/listing/12345678

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

Maximum number of listings to return.

## Actor input object example

```json
{
  "mode": "searchForSale",
  "region": "Auckland",
  "propertyType": "",
  "startUrls": [],
  "maxItems": 50
}
```

# Actor output Schema

## `properties` (type: `string`):

Dataset containing all scraped Trade Me 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": "searchForSale",
    "region": "Auckland",
    "propertyType": "",
    "startUrls": [],
    "maxItems": 50
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/trademe-property-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": "searchForSale",
    "region": "Auckland",
    "propertyType": "",
    "startUrls": [],
    "maxItems": 50,
}

# Run the Actor and wait for it to finish
run = client.actor("crawlerbros/trademe-property-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": "searchForSale",
  "region": "Auckland",
  "propertyType": "",
  "startUrls": [],
  "maxItems": 50
}' |
apify call crawlerbros/trademe-property-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Trade Me Property Scraper",
        "description": "Scrape Trade Me Property, New Zealand's largest property marketplace. Search residential properties for sale or rent by region, price, bedrooms, bathrooms, and property type. Extracts address, price, features, agency, open homes, GPS coordinates, and more.",
        "version": "1.0",
        "x-build-id": "0GeiWMmhYDHsPEezR"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/crawlerbros~trademe-property-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-crawlerbros-trademe-property-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~trademe-property-scraper/runs": {
            "post": {
                "operationId": "runs-sync-crawlerbros-trademe-property-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~trademe-property-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-crawlerbros-trademe-property-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": [
                            "searchForSale",
                            "searchForRent",
                            "byListingUrls"
                        ],
                        "type": "string",
                        "description": "What to scrape: residential properties for sale, rental listings, or enrich specific listing URLs.",
                        "default": "searchForSale"
                    },
                    "region": {
                        "title": "Region",
                        "enum": [
                            "Auckland",
                            "Bay of Plenty",
                            "Canterbury",
                            "Gisborne",
                            "Hawke's Bay",
                            "Manawatu / Whanganui",
                            "Marlborough",
                            "Nelson / Tasman",
                            "Northland",
                            "Otago",
                            "Southland",
                            "Taranaki",
                            "Waikato",
                            "Wellington",
                            "West Coast",
                            "All New Zealand"
                        ],
                        "type": "string",
                        "description": "New Zealand region to search. Use 'All New Zealand' for nationwide results.",
                        "default": "Auckland"
                    },
                    "propertyType": {
                        "title": "Property Type",
                        "enum": [
                            "",
                            "house",
                            "townhouse",
                            "apartment",
                            "unit",
                            "section",
                            "lifestyle",
                            "rural",
                            "newdevelopment",
                            "carpark"
                        ],
                        "type": "string",
                        "description": "Type of property to filter results.",
                        "default": ""
                    },
                    "minPrice": {
                        "title": "Minimum Price (NZD)",
                        "minimum": 0,
                        "maximum": 50000000,
                        "type": "integer",
                        "description": "Minimum listing price in New Zealand dollars."
                    },
                    "maxPrice": {
                        "title": "Maximum Price (NZD)",
                        "minimum": 0,
                        "maximum": 50000000,
                        "type": "integer",
                        "description": "Maximum listing price in New Zealand dollars."
                    },
                    "minBedrooms": {
                        "title": "Minimum Bedrooms",
                        "minimum": 1,
                        "maximum": 10,
                        "type": "integer",
                        "description": "Minimum number of bedrooms."
                    },
                    "maxBedrooms": {
                        "title": "Maximum Bedrooms",
                        "minimum": 1,
                        "maximum": 10,
                        "type": "integer",
                        "description": "Maximum number of bedrooms."
                    },
                    "minBathrooms": {
                        "title": "Minimum Bathrooms",
                        "minimum": 1,
                        "maximum": 10,
                        "type": "integer",
                        "description": "Minimum number of bathrooms."
                    },
                    "startUrls": {
                        "title": "Listing URLs (mode=byListingUrls)",
                        "type": "array",
                        "description": "Trade Me property listing URLs to enrich, e.g. https://www.trademe.co.nz/a/property/residential/sale/listing/12345678",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxItems": {
                        "title": "Max Items",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Maximum number of listings to return.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
