# Realtor.ca Property Listings Scraper (`automation-lab/realtor-ca-property-listings-scraper`) Actor

Extract Canadian Realtor.ca listings: prices, MLS IDs, addresses, photos, agents, brokerages, coordinates, and listing URLs.

- **URL**: https://apify.com/automation-lab/realtor-ca-property-listings-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Real estate
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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

## Realtor.ca Property Listings Scraper

Extract Canadian property listings from Realtor.ca search areas with prices, MLS numbers, addresses, photos, agents, and brokerage details.

### What does Realtor.ca Property Listings Scraper do?

Realtor.ca Property Listings Scraper turns public Realtor.ca map searches into structured datasets.

It collects property records from Canadian search areas and saves them in a table that can be exported as JSON, CSV, Excel, XML, or used directly through the Apify API.

Use it to monitor Canadian real-estate inventory, price changes, agent leads, brokerage activity, and local housing market supply.

### Who is it for?

- 🏘️ Real-estate investors tracking listings in target Canadian markets.
- 🏢 Brokerages monitoring competitor inventory and agents.
- 📊 Market analysts building housing dashboards.
- 🧩 Proptech teams enriching internal property databases.
- 📬 Lead-generation teams collecting agent and brokerage contact context.

### Why use this scraper?

Realtor.ca data is spread across interactive map pages.

This actor gives you repeatable extraction without manually opening each listing.

You can schedule it daily, compare datasets over time, and plug the results into your CRM or BI stack.

### What data can it extract?

| Field | Description |
| --- | --- |
| `propertyId` | Realtor.ca property ID |
| `mlsNumber` | MLS listing number when available |
| `listingUrl` | Public Realtor.ca listing page |
| `price` | Display price |
| `priceUnformatted` | Numeric price |
| `propertyType` | Apartment, house, townhouse, land, etc. |
| `addressText` | Full listing address text |
| `latitude`, `longitude` | Map coordinates |
| `bedrooms`, `bathrooms` | Bedroom and bathroom counts |
| `sizeInterior`, `lotSize` | Building and lot sizes when available |
| `photos` | Listing image URLs |
| `agentNames` | Listing agent names |
| `brokerageNames` | Brokerages attached to the listing |
| `phones` | Agent phone numbers from the search payload |
| `sourceSearch` | Search area that produced the record |
| `scrapedAt` | Extraction timestamp |

### How much does it cost to scrape Realtor.ca listings?

The actor uses pay-per-event pricing.

You pay a small run-start fee plus a per-listing event for each saved property record.

The exact price is shown on the Apify Store pricing panel before you start a run.

Use a small `maxItems` value for a first test, then scale after confirming that the selected map area returns the data you need.

### How to use Realtor.ca Property Listings Scraper

1. Open the actor on Apify.
2. Keep the default Toronto search area or add your own Canadian bounding box.
3. Set `maxItems` to the number of listings you need.
4. Optionally add price filters.
5. Run the actor.
6. Download the dataset or connect it to your workflow.

### Input: search areas

The most reliable input is `locations`.

Each location needs:

- `name`
- `latitudeMin`
- `latitudeMax`
- `longitudeMin`
- `longitudeMax`

Example:

```json
{
  "locations": [
    {
      "name": "Toronto, ON",
      "latitudeMin": 43.55,
      "latitudeMax": 43.9,
      "longitudeMin": -79.75,
      "longitudeMax": -79.1
    }
  ],
  "maxItems": 100
}
````

### Input: start URLs

You can also pass Realtor.ca map URLs in `startUrls` if the URL contains map-bound parameters such as `LatitudeMin`, `LatitudeMax`, `LongitudeMin`, and `LongitudeMax`.

The actor extracts those bounds and uses them as search areas.

### Input: filters

Available filters include:

- `maxItems`
- `recordsPerPage`
- `minPrice`
- `maxPrice`
- `transactionTypeId`
- `propertyTypeGroupId`
- `propertySearchTypeId`
- `proxyCountryCode`

### Output example

```json
{
  "propertyId": "29974459",
  "mlsNumber": "W13508020",
  "listingUrl": "https://www.realtor.ca/real-estate/29974459/example",
  "price": "$495,000",
  "priceUnformatted": 495000,
  "propertyType": "Apartment",
  "addressText": "530 - 3100 KEELE STREET|Toronto, Ontario",
  "bedrooms": "2",
  "bathrooms": "2",
  "agentNames": ["Example Agent"],
  "brokerageNames": ["Example Brokerage"],
  "sourceSearch": "Toronto, ON",
  "scrapedAt": "2026-07-01T00:00:00.000Z"
}
```

### Tips for best results

- Start with one city or neighborhood bounding box.
- Use `maxItems` 25-100 for initial tests.
- Increase gradually for scheduled monitoring.
- Keep the proxy country set to `CA` for Canadian listings.
- Use smaller map boxes for neighborhood-level dashboards.

### Common use cases

- Track new listings in Toronto, Vancouver, Calgary, Ottawa, or Montreal.
- Build a daily property inventory database.
- Monitor price bands for investment criteria.
- Collect agent and brokerage lead context.
- Compare listing counts between neighborhoods.

### Integrations

Use Apify integrations to move the dataset into:

- Google Sheets for market watchlists.
- Zapier or Make for lead workflows.
- BigQuery or Snowflake for analytics.
- Webhooks for daily alerts.
- Custom APIs through the Apify client.

### API usage with Node.js

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/realtor-ca-property-listings-scraper').call({
  locations: [{
    name: 'Toronto, ON',
    latitudeMin: 43.55,
    latitudeMax: 43.9,
    longitudeMin: -79.75,
    longitudeMax: -79.1,
  }],
  maxItems: 100,
});
console.log(run.defaultDatasetId);
```

### API usage with Python

```python
from apify_client import ApifyClient

client = ApifyClient('MY-APIFY-TOKEN')
run = client.actor('automation-lab/realtor-ca-property-listings-scraper').call(run_input={
    'locations': [{
        'name': 'Toronto, ON',
        'latitudeMin': 43.55,
        'latitudeMax': 43.9,
        'longitudeMin': -79.75,
        'longitudeMax': -79.1,
    }],
    'maxItems': 100,
})
print(run['defaultDatasetId'])
```

### API usage with cURL

```bash
curl -X POST 'https://api.apify.com/v2/acts/automation-lab~realtor-ca-property-listings-scraper/runs?token=MY-APIFY-TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"locations":[{"name":"Toronto, ON","latitudeMin":43.55,"latitudeMax":43.9,"longitudeMin":-79.75,"longitudeMax":-79.1}],"maxItems":100}'
```

### MCP integration

Use this actor from Claude through the Apify MCP server.

MCP URL:

```text
https://mcp.apify.com/?tools=automation-lab/realtor-ca-property-listings-scraper
```

Add the actor to Claude Code:

```bash
claude mcp add apify-realtor-ca "https://mcp.apify.com/?tools=automation-lab/realtor-ca-property-listings-scraper"
```

Example MCP JSON config:

```json
{
  "mcpServers": {
    "apify-realtor-ca": {
      "url": "https://mcp.apify.com/?tools=automation-lab/realtor-ca-property-listings-scraper"
    }
  }
}
```

Example prompts:

- "Scrape 100 Realtor.ca listings in Toronto and summarize average price by property type."
- "Run the Realtor.ca scraper for this bounding box and export the agent names."
- "Compare today's listings with yesterday's Realtor.ca dataset."

### Scheduling

Schedule the actor daily or weekly to build a historical property inventory.

Use a consistent bounding box and store each run's dataset ID.

Then compare MLS numbers across runs to detect new or removed listings.

### Data quality notes

Realtor.ca fields vary by listing.

Some listings may not include every size, postal code, phone, or description field in the search payload.

The actor keeps optional fields as `null` or empty arrays instead of guessing.

### Troubleshooting

If a run returns fewer listings than expected, increase the map area or remove price filters.

If a run fails with an anti-bot response, retry with `proxyCountryCode` set to `CA` and a smaller `recordsPerPage` value.

### Legality

This actor extracts publicly available listing information.

You are responsible for using the data in accordance with Realtor.ca terms, applicable laws, privacy rules, and your own compliance requirements.

Avoid collecting or using personal data beyond what your workflow lawfully requires.

### Related scrapers

Other automation-lab actors that may fit real-estate workflows:

- Zillow Scraper: https://apify.com/automation-lab/zillow-scraper
- Google Maps Lead Finder: https://apify.com/automation-lab/google-maps-lead-finder
- Website Contact Finder: https://apify.com/automation-lab/website-contact-finder

### FAQ

#### Can I scrape any Canadian city?

Yes, if you provide a bounding box for the target area and Realtor.ca has public listings there.

#### Does it scrape listing detail pages?

The MVP saves fields available from the public search payload, including listing URLs for detail-page follow-up.

#### Can I monitor price changes?

Yes. Schedule repeat runs and compare `mlsNumber`, `propertyId`, and `priceUnformatted` over time.

#### Does it need proxies?

Yes. Realtor.ca uses Incapsula anti-bot controls, so the actor uses Apify Residential Proxy by default.

#### Why are some fields empty?

Realtor.ca does not expose every field for every listing in the search response. Empty values are preserved as `null` or empty arrays.

# Actor input Schema

## `locations` (type: `array`):

Canadian map areas to scrape. Use latitude/longitude bounds from Realtor.ca map URLs or your own market areas.

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

Optional Realtor.ca map/search URLs containing LatitudeMin, LatitudeMax, LongitudeMin, and LongitudeMax query or hash parameters.

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

Maximum number of property listing records to save.

## `recordsPerPage` (type: `integer`):

How many Realtor.ca results to request per page. Higher values reduce requests but may be less resilient.

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

Optional minimum listing price in CAD.

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

Optional maximum listing price in CAD.

## `transactionTypeId` (type: `integer`):

Realtor.ca transaction type. 2 is for-sale listings; other values may represent rent or alternative workflows.

## `propertyTypeGroupId` (type: `integer`):

Realtor.ca property group. 1 returns residential property listings.

## `propertySearchTypeId` (type: `integer`):

Realtor.ca search type. 1 is the normal property search.

## `proxyCountryCode` (type: `string`):

Country code for Apify Residential Proxy. Canada is recommended for Realtor.ca.

## Actor input object example

```json
{
  "locations": [
    {
      "name": "Toronto, ON",
      "latitudeMin": 43.55,
      "latitudeMax": 43.9,
      "longitudeMin": -79.75,
      "longitudeMax": -79.1
    }
  ],
  "startUrls": [],
  "maxItems": 20,
  "recordsPerPage": 50,
  "transactionTypeId": 2,
  "propertyTypeGroupId": 1,
  "propertySearchTypeId": 1,
  "proxyCountryCode": "CA"
}
```

# 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 = {
    "locations": [
        {
            "name": "Toronto, ON",
            "latitudeMin": 43.55,
            "latitudeMax": 43.9,
            "longitudeMin": -79.75,
            "longitudeMax": -79.1
        }
    ],
    "startUrls": [],
    "maxItems": 20,
    "recordsPerPage": 50,
    "transactionTypeId": 2,
    "propertyTypeGroupId": 1,
    "propertySearchTypeId": 1,
    "proxyCountryCode": "CA"
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/realtor-ca-property-listings-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 = {
    "locations": [{
            "name": "Toronto, ON",
            "latitudeMin": 43.55,
            "latitudeMax": 43.9,
            "longitudeMin": -79.75,
            "longitudeMax": -79.1,
        }],
    "startUrls": [],
    "maxItems": 20,
    "recordsPerPage": 50,
    "transactionTypeId": 2,
    "propertyTypeGroupId": 1,
    "propertySearchTypeId": 1,
    "proxyCountryCode": "CA",
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/realtor-ca-property-listings-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 '{
  "locations": [
    {
      "name": "Toronto, ON",
      "latitudeMin": 43.55,
      "latitudeMax": 43.9,
      "longitudeMin": -79.75,
      "longitudeMax": -79.1
    }
  ],
  "startUrls": [],
  "maxItems": 20,
  "recordsPerPage": 50,
  "transactionTypeId": 2,
  "propertyTypeGroupId": 1,
  "propertySearchTypeId": 1,
  "proxyCountryCode": "CA"
}' |
apify call automation-lab/realtor-ca-property-listings-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Realtor.ca Property Listings Scraper",
        "description": "Extract Canadian Realtor.ca listings: prices, MLS IDs, addresses, photos, agents, brokerages, coordinates, and listing URLs.",
        "version": "0.1",
        "x-build-id": "qTYh6cqk0lMmm8ykm"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~realtor-ca-property-listings-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-realtor-ca-property-listings-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/automation-lab~realtor-ca-property-listings-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-realtor-ca-property-listings-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/automation-lab~realtor-ca-property-listings-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-realtor-ca-property-listings-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": {
                    "locations": {
                        "title": "Map bounding boxes",
                        "type": "array",
                        "description": "Canadian map areas to scrape. Use latitude/longitude bounds from Realtor.ca map URLs or your own market areas."
                    },
                    "startUrls": {
                        "title": "Start URLs with map bounds",
                        "type": "array",
                        "description": "Optional Realtor.ca map/search URLs containing LatitudeMin, LatitudeMax, LongitudeMin, and LongitudeMax query or hash parameters.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxItems": {
                        "title": "Maximum listings",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of property listing records to save.",
                        "default": 20
                    },
                    "recordsPerPage": {
                        "title": "Records per API page",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "How many Realtor.ca results to request per page. Higher values reduce requests but may be less resilient.",
                        "default": 50
                    },
                    "minPrice": {
                        "title": "Minimum price",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Optional minimum listing price in CAD."
                    },
                    "maxPrice": {
                        "title": "Maximum price",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Optional maximum listing price in CAD."
                    },
                    "transactionTypeId": {
                        "title": "Transaction type ID",
                        "type": "integer",
                        "description": "Realtor.ca transaction type. 2 is for-sale listings; other values may represent rent or alternative workflows.",
                        "default": 2
                    },
                    "propertyTypeGroupId": {
                        "title": "Property type group ID",
                        "type": "integer",
                        "description": "Realtor.ca property group. 1 returns residential property listings.",
                        "default": 1
                    },
                    "propertySearchTypeId": {
                        "title": "Property search type ID",
                        "type": "integer",
                        "description": "Realtor.ca search type. 1 is the normal property search.",
                        "default": 1
                    },
                    "proxyCountryCode": {
                        "title": "Residential proxy country",
                        "type": "string",
                        "description": "Country code for Apify Residential Proxy. Canada is recommended for Realtor.ca.",
                        "default": "CA"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
