# Centris.ca Scraper — Quebec Real Estate Listings (`haketa/centris-scraper`) Actor

Scrape Quebec property listings from Centris.ca by city, type & price. Get address, price, bedrooms, bathrooms, living area, photos, GPS coordinates & broker for houses, condos & rentals — for real estate market research and lead generation.

- **URL**: https://apify.com/haketa/centris-scraper.md
- **Developed by:** [Haketa](https://apify.com/haketa) (community)
- **Categories:** Real estate, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.50 / 1,000 results

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

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

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## Centris.ca Scraper — Quebec Real Estate Listings

Extract structured **real-estate listings from Centris.ca**, the largest property portal in **Quebec, Canada**. Choose a city, property type and price range, and get clean records for every listing: **price, full address, bedrooms, bathrooms, living area, property type, photos, GPS coordinates and broker** — for houses, condos, plexes and rentals.

No code, no login. Run it from the Apify Console, on a schedule, or from your own app via the API. Results download as **JSON, CSV, Excel, HTML or XML**, or sync straight into Google Sheets, Airtable, HubSpot, Make, Zapier and n8n.

> **🏡 Built for real estate market research & lead generation.** Every record carries the **price, address, rooms and location** — perfect for pricing analysis, investment sourcing and building broker/agent lists across Quebec.

---

### 📋 What this scraper does

Centris.ca lists tens of thousands of Quebec properties for sale and rent. This actor turns a Centris search into a clean, structured dataset you can analyse, map or feed into a CRM.

Give it one or more cities (e.g. `Montreal`, `Quebec City`) and your filters, and it will:

- ✅ Collect every matching listing, page after page
- ✅ Return the **price**, **property type** and **for-sale / for-rent** status
- ✅ Break out **bedrooms, bathrooms and living area**
- ✅ Capture the **full address** and **city / borough**
- ✅ Include the **main photo** and a link to the listing
- ✅ Optionally enrich each listing with **GPS coordinates, broker, agency, full description, all photos and the MLS number**
- ✅ De-duplicate every listing by its Centris ID

---

### ⭐ Why choose this scraper

- **Complete Quebec coverage.** Montreal, Quebec City, Laval, Gatineau, Longueuil and every region on Centris.
- **Rich property data.** Price, rooms, area, type and location on every record — ready for analysis.
- **Precise geo data.** GPS coordinates (with enrichment) for mapping and radius search.
- **Broker leads.** Broker name and agency on every enriched listing for outreach and referral lists.
- **Fast and reliable.** Efficient extraction straight from Centris' listing feed.

---

### 💡 Popular use cases

| Use case | How this scraper helps |
| --- | --- |
| **Real estate market research** | Track prices, inventory and property types by city and neighbourhood. |
| **Investment sourcing** | Screen listings by price, type and area to find opportunities. |
| **Comparative market analysis (CMA)** | Pull comparable listings for valuations and pricing. |
| **Broker & agent lead generation** | Build lists of brokers and agencies active in each market. |
| **Price & trend monitoring** | Schedule runs to follow price changes and new listings over time. |
| **Data products & dashboards** | Feed a clean Quebec real-estate feed into BI tools, GIS or a database. |

---

### 🚀 Quick start

1. Enter one or more **Locations** (e.g. `Montreal`, `Quebec City`, `Laval`).
2. Choose **For sale** or **For rent** and the **property category**.
3. (Optional) Set a **price range** and turn on **Enrich from listing pages** for GPS, broker and full details.
4. Set **Max listings** and click **Start**.
5. Download your data from the **Storage → Dataset** tab.

---

### ⚙️ Input

| Field | Type | Description |
| --- | --- | --- |
| **Locations** | array | City or region names, e.g. `Montreal`, `Quebec City`, `Laval`, `Gatineau`. Each is resolved automatically. Empty = all Quebec. |
| **For sale or rent** | select | Scrape properties for sale or for rent. |
| **Property category** | select | Residential (houses, condos, plexes) or Commercial. |
| **Min / Max price ($)** | integer | Price range in CAD. |
| **Enrich from listing pages** | boolean | Visit each listing for GPS, broker, agency, full description, all photos and MLS number. Slower but richer. |
| **Max listings** | integer | Cap on total listings. `0` = no limit. |
| **Proxy** | object | Apify Proxy (Canadian residential recommended, on by default). |

#### Example 1 — Houses & condos for sale in Montreal

```json
{
  "locations": ["Montreal"],
  "sellingType": "sale",
  "category": "residential",
  "maxItems": 500
}
````

#### Example 2 — Rentals in Quebec City under $2,000

```json
{
  "locations": ["Quebec City"],
  "sellingType": "rent",
  "category": "residential",
  "maxPrice": 2000,
  "maxItems": 300
}
```

#### Example 3 — Multiple cities, fully enriched

```json
{
  "locations": ["Laval", "Longueuil", "Gatineau"],
  "sellingType": "sale",
  "enrichDetails": true,
  "minPrice": 300000,
  "maxItems": 400
}
```

***

### 📦 Output

Each listing becomes one dataset record:

```json
{
  "listingId": "24338005",
  "url": "https://www.centris.ca/en/houses~for-sale~quebec-beauport/24338005",
  "propertyType": "House",
  "sellingType": "sale",
  "price": 359900,
  "address": "122, Rue Saint-Théophile Québec (Beauport)",
  "city": "Québec",
  "bedrooms": 2,
  "bathrooms": 2,
  "livingArea": "864",
  "latitude": 46.88682,
  "longitude": -71.163238,
  "brokerName": "Richard Turmel",
  "brokerFirm": "VIA CAPITALE SÉLECT",
  "description": "Charming well-maintained bungalow offering 2 bedrooms...",
  "mlsNumber": "24338005",
  "mainPhoto": "https://mspublic.centris.ca/media.ashx?id=...",
  "photoCount": 33,
  "scrapedAt": "2026-07-02T00:00:00.000Z"
}
```

#### Output fields

| Field | Description |
| --- | --- |
| `listingId` | Centris listing number (used for de-duplication). |
| `url` | Listing page URL. |
| `propertyType` | House, Condo, Duplex, Triplex, Lot, etc. |
| `sellingType` | `sale` or `rent`. |
| `price` | Listing price (CAD). |
| `address` / `city` | Street address and city / borough. |
| `bedrooms` / `bathrooms` | Room counts. |
| `livingArea` | Living / net area (sqft), where listed. |
| `latitude` / `longitude` | GPS coordinates (listing enrichment). |
| `brokerName` / `brokerFirm` | Broker and agency (listing enrichment). |
| `description` | Full listing description (listing enrichment). |
| `mlsNumber` | Centris / MLS number (listing enrichment). |
| `mainPhoto` / `photoCount` | Main photo URL and number of photos. |
| `scrapedAt` | Extraction timestamp. |

***

### 🗺️ Locations you can search

Any Quebec city, region or borough on Centris — for example **Montreal, Quebec City, Laval, Gatineau, Longueuil, Sherbrooke, Trois-Rivières, Lévis, Terrebonne, Saguenay, Brossard, Repentigny** and many more. Enter the name and the actor resolves it to the right Centris area automatically.

***

### 🧭 Tips for best results

- **Search several cities at once** by adding multiple locations.
- **Use a price range** to focus on a market segment.
- **Turn on enrichment** for GPS, broker, agency, description and all photos.
- **Rank by `price`** and filter by `bedrooms` / `propertyType` for targeted lists.
- **Schedule runs** to monitor new listings and price changes over time.

***

### 🔌 Integrations & export

- **Download formats:** JSON, CSV, Excel, HTML, XML, RSS.
- **CRM / Sheets / Airtable / Make / Zapier / n8n:** push results automatically.
- **API:** run and fetch data with the Apify API or the JS / Python clients.
- **Scheduling:** run on a schedule to keep an always-fresh listings database.

***

### ❓ FAQ

**Do I need a Centris account or API key?**
No. You only need an Apify account.

**Which properties are covered?**
Residential and commercial listings for sale and for rent, across all of Quebec.

**How do I search a specific city?**
Just type its name (e.g. `Laval`) — the actor resolves it to the correct Centris area automatically.

**What extra data does enrichment add?**
GPS coordinates, broker name and agency, the full description, all photos and the MLS number.

**Does it return duplicates?**
No. Listings are de-duplicated by their Centris ID across all searches.

***

### ⚖️ Legal & responsible use

This actor collects **publicly available** listing information from Centris.ca — the same data any visitor can see. It does not log in or access private data. Respect Centris' Terms of Use and applicable law, and use the data for lawful purposes such as market research, analytics and outreach.

***

### 🛟 Support

Need an extra field or hit an issue? Open a ticket from the actor's **Issues** tab with your input configuration.

Happy sourcing! 🏡

# Actor input Schema

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

City or region names to search, e.g. "Montreal", "Quebec City", "Laval", "Gatineau". Each is resolved to a Centris geographic area. Leave empty to search all of Quebec.

## `sellingType` (type: `string`):

Whether to scrape properties for sale or for rent.

## `category` (type: `string`):

Property category to search.

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

Minimum price in CAD.

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

Maximum price in CAD.

## `enrichDetails` (type: `boolean`):

Visit each listing page for extra data (full description, GPS coordinates, broker, extra features and all photos). Slower but richer.

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

Maximum number of listings to return across all locations. Set 0 for no limit.

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

Apify Proxy settings. Canadian residential is recommended and set by default.

## Actor input object example

```json
{
  "locations": [
    "Montreal"
  ],
  "sellingType": "sale",
  "category": "residential",
  "enrichDetails": false,
  "maxItems": 100,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "CA"
  }
}
```

# Actor output Schema

## `listingId` (type: `string`):

Centris listing number

## `url` (type: `string`):

Listing page URL

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

Property type (House, Condo, ...)

## `sellingType` (type: `string`):

For sale or for rent

## `price` (type: `string`):

Listing price (CAD)

## `address` (type: `string`):

Street address

## `city` (type: `string`):

City / borough

## `bedrooms` (type: `string`):

Number of bedrooms

## `bathrooms` (type: `string`):

Number of bathrooms

## `livingArea` (type: `string`):

Living area (sqft)

## `lotArea` (type: `string`):

Lot area (sqft)

## `latitude` (type: `string`):

GPS latitude (listing enrichment)

## `longitude` (type: `string`):

GPS longitude (listing enrichment)

## `brokerName` (type: `string`):

Listing broker (enrichment)

## `brokerFirm` (type: `string`):

Broker agency (enrichment)

## `description` (type: `string`):

Listing description (enrichment)

## `mlsNumber` (type: `string`):

Centris / MLS number (enrichment)

## `mainPhoto` (type: `string`):

Main photo URL

## `photoCount` (type: `string`):

Number of photos

## `scrapedAt` (type: `string`):

Extraction timestamp

# 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": [
        "Montreal"
    ],
    "maxItems": 100,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "apifyProxyCountry": "CA"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("haketa/centris-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": ["Montreal"],
    "maxItems": 100,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "CA",
    },
}

# Run the Actor and wait for it to finish
run = client.actor("haketa/centris-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": [
    "Montreal"
  ],
  "maxItems": 100,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "CA"
  }
}' |
apify call haketa/centris-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Centris.ca Scraper — Quebec Real Estate Listings",
        "description": "Scrape Quebec property listings from Centris.ca by city, type & price. Get address, price, bedrooms, bathrooms, living area, photos, GPS coordinates & broker for houses, condos & rentals — for real estate market research and lead generation.",
        "version": "0.1",
        "x-build-id": "70bc3rIhFUhu3VlbB"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/haketa~centris-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-haketa-centris-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/haketa~centris-scraper/runs": {
            "post": {
                "operationId": "runs-sync-haketa-centris-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/haketa~centris-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-haketa-centris-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": "Locations (cities / regions)",
                        "type": "array",
                        "description": "City or region names to search, e.g. \"Montreal\", \"Quebec City\", \"Laval\", \"Gatineau\". Each is resolved to a Centris geographic area. Leave empty to search all of Quebec.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "sellingType": {
                        "title": "For sale or rent",
                        "enum": [
                            "sale",
                            "rent"
                        ],
                        "type": "string",
                        "description": "Whether to scrape properties for sale or for rent.",
                        "default": "sale"
                    },
                    "category": {
                        "title": "Property category",
                        "enum": [
                            "residential",
                            "commercial"
                        ],
                        "type": "string",
                        "description": "Property category to search.",
                        "default": "residential"
                    },
                    "minPrice": {
                        "title": "Min price ($)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Minimum price in CAD."
                    },
                    "maxPrice": {
                        "title": "Max price ($)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum price in CAD."
                    },
                    "enrichDetails": {
                        "title": "Enrich from listing pages",
                        "type": "boolean",
                        "description": "Visit each listing page for extra data (full description, GPS coordinates, broker, extra features and all photos). Slower but richer.",
                        "default": false
                    },
                    "maxItems": {
                        "title": "Max listings",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum number of listings to return across all locations. Set 0 for no limit.",
                        "default": 100
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Apify Proxy settings. Canadian residential is recommended and set by default.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ],
                            "apifyProxyCountry": "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```