# 🏠 Centris Scraper — Quebec Real Estate (MLS) by Region (`trepanat0r/centris-quebec`) Actor

Scrape centris.ca for Quebec property listings. Filter by region, category, sale/rent, price range. Optional detail pages with characteristics, municipal assessment, photos.

- **URL**: https://apify.com/trepanat0r/centris-quebec.md
- **Developed by:** [Trepanator Labs](https://apify.com/trepanat0r) (community)
- **Categories:** Real estate, Lead generation
- **Stats:** 3 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $5.00 / 1,000 property listing extracteds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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 Scraper — Quebec Real Estate (MLS)

**The only Apify Actor that extracts full Quebec MLS property listings from [centris.ca](https://www.centris.ca).** Filter by region, category, sale/rent, and price range. Pull MLS numbers, prices, addresses, coordinates, photos, and (optionally) full detail pages with characteristics, municipal assessment, and high-resolution photo URLs.

### What does Centris Scraper do?

Centris is the official MLS-equivalent for Quebec real estate. There's no public API. Other Apify Centris Actors only scrape brokers or URLs — none deliver the **full property dataset**. This Actor does.

For each run, you get:

- Every listing in the regions and price range you specify
- MLS number, price, category, address, city, latitude/longitude
- Bedrooms, bathrooms, photo count, thumbnail
- Direct link to the Centris detail page
- **Optional**: full enriched detail — description, all property characteristics (year built, lot size, parking, etc.), municipal assessment table, all high-res photos

Run from the Apify Console, schedule weekly to monitor market changes, hit the API from your CRM/dashboard.

### Why use this Actor?

- **Realtors and investors** — build deal-flow pipelines, monitor competitors' listings
- **Market analysts and journalists** — pull aggregate data on Quebec housing prices, inventory, regional trends
- **PropTech builders** — feed Quebec listings into AVMs, recommendation engines, search tools
- **Researchers** — academic / public-policy work on housing affordability in Quebec

### How to use it

1. Click **Try for free**
2. Pick one or more **Quebec regions** (default: Montréal Island)
3. Optionally narrow by **category** (Residential / Commercial / Plex), **sale/rent**, and **price range**
4. Toggle **Include detail page enrichment** if you want full property descriptions, characteristics, and high-res photos
5. Set **Max listings per region** (default 500, max 5000 — Centris's hard cap per query)
6. Click **Start**

### Input

| Field | Required | Default | Description |
|---|---|---|---|
| `regions` | No | `["GSGS4621"]` (Montréal Island) | One or more Quebec region codes |
| `category` | No | `Residential` | `Residential`, `Commercial`, or `Plex` |
| `sellingType` | No | `Sale` | `Sale` or `Rent` |
| `minPrice` / `maxPrice` | No | 0 / unlimited | CAD price filter |
| `includeDetail` | No | false | Fetch detail page enrichment per listing |
| `maxListings` | No | 500 | Cap per region (max 5000) |

#### Quebec regions

| Code | Region |
|---|---|
| `GSGS4621` | Montréal (Île) |
| `GSGS4622` | Laval |
| `RARA16` | Montérégie |
| `RARA15` | Laurentides |
| `RARA14` | Lanaudière |
| `RARA03` | Capitale-Nationale (Québec City) |
| `RARA05` | Estrie |
| `RARA07` | Outaouais |
| `RARA12` | Chaudière-Appalaches |
| `RARA04` | Mauricie |
| `RARA17` | Centre-du-Québec |
| `RARA01` | Bas-Saint-Laurent |
| `RARA02` | Saguenay/Lac-Saint-Jean |
| `RARA08` | Abitibi-Témiscamingue |
| `RARA09` | Côte-Nord |
| `RARA11` | Gaspésie/Îles-de-la-Madeleine |
| `RARA10` | Nord-du-Québec |

### Output

```json
{
  "mlsNumber": "12345678",
  "price": 749000,
  "category": "Maison à étages",
  "address": "1234 Rue Saint-Denis",
  "city": "Montréal (Plateau-Mont-Royal)",
  "bedrooms": 4,
  "bathrooms": 2,
  "latitude": 45.5234,
  "longitude": -73.5713,
  "photoUrl": "https://mspublic.centris.ca/media.ashx?id=...",
  "photoCount": 32,
  "detailUrl": "https://www.centris.ca/fr/maison~a-vendre~montreal-plateau-mont-royal/12345678",
  "regionId": "GSGS4621",
  "regionName": "Montréal (Île)",
  "description": "Magnifique maison à étages...",
  "characteristics": [
    { "label": "Année de construction", "value": "1920" },
    { "label": "Superficie du terrain", "value": "2,500 pi²" },
    { "label": "Stationnement", "value": "Garage (1)" }
  ],
  "municipalAssessment": [
    { "label": "Évaluation municipale", "value": "$680,000" },
    { "label": "Évaluation du terrain", "value": "$240,000" },
    { "label": "Évaluation du bâtiment", "value": "$440,000" }
  ],
  "photoUrls": [
    "https://mspublic.centris.ca/media.ashx?id=...&t=pi&w=1260&h=1024&sm=c"
  ],
  "scrapedAt": "2026-05-26T20:30:00.000Z"
}
````

Download dataset as JSON, CSV, Excel, HTML, or hit the API.

### Pricing

Pay-per-event. You're charged once per listing record returned to your dataset (with or without detail enrichment).

| Event | Description | Price |
|---|---|---|
| `centris_listing` | One property listing returned | $0.005 |

#### Cost estimates

- 100 listings (no detail): **~$0.50**
- 500 listings, all of Montréal Island: **~$2.50**
- 5000 listings (max), single region with detail: **~$25.00**
- All 17 regions × 500 listings: **~$42.50**

Apify free tier ($5/month credit) covers ~1000 listings.

### Tips

- Start with `maxListings: 50` in a single region to validate data quality for your use case
- Quebec's Centris hard-caps queries at 5000 listings per region — to get more than that for Montréal Island, segment by price bands (e.g., 0-500k, 500k-1M, 1M+) across multiple runs
- Schedule weekly to monitor new listings and price changes
- `includeDetail: true` doubles your data richness — recommended for serious analysis. Adds ~1.5s per listing.

### FAQ

**Is this legal?** Centris listings are public data published explicitly for buyer discovery. This Actor uses only what any browser sees. You're responsible for compliance in your downstream use (e.g., GDPR / Loi 25 if you contact owners).

**Why isn't there an official API?** Centris doesn't expose one to the public. Brokers have data feeds via internal MLS systems, but the public-facing site is the only source for outside use.

**Does it support neighbourhoods or specific cities?** v1 supports the 17 administrative regions. City and neighbourhood drilling will come in v2 — `Cartography` queries via the autocomplete API.

**Does it block? Need proxies?** Centris is generally permissive — default Apify proxy works fine. Run with rate limits to avoid throttling.

**Issues / feature requests?** Open them on the Issues tab. Roadmap: neighbourhood-level filtering, DuProprio multi-source mode, change detection (price drops, new listings), Realtor.ca cross-listings.

# Actor input Schema

## `regions` (type: `array`):

One or more Quebec administrative regions to scrape. Leave empty to scrape all 17 regions.

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

Type of property to scrape.

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

Filter listings for sale or for rent.

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

Minimum listing price filter.

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

Maximum listing price filter. Leave default for no cap.

## `includeDetail` (type: `boolean`):

If enabled, the scraper visits each property's detail page to extract full description, characteristics (year built, lot size, etc.), municipal assessment, and high-res photo URLs. Each detail page adds ~1.5 seconds and increases cost (each enriched record is one paid event).

## `maxListings` (type: `integer`):

Cap on listings collected per region. Centris itself caps queries at 5,000 listings.

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

Centris.ca is generally scrapeable from any IP. Default Apify proxy is fine.

## Actor input object example

```json
{
  "regions": [
    "GSGS4621"
  ],
  "category": "Residential",
  "sellingType": "Sale",
  "minPrice": 0,
  "maxPrice": 999999999999,
  "includeDetail": false,
  "maxListings": 500,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `results` (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 = {
    "regions": [
        "GSGS4621"
    ],
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("trepanat0r/centris-quebec").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 = {
    "regions": ["GSGS4621"],
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("trepanat0r/centris-quebec").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 '{
  "regions": [
    "GSGS4621"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call trepanat0r/centris-quebec --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "🏠 Centris Scraper — Quebec Real Estate (MLS) by Region",
        "description": "Scrape centris.ca for Quebec property listings. Filter by region, category, sale/rent, price range. Optional detail pages with characteristics, municipal assessment, photos.",
        "version": "0.1",
        "x-build-id": "aJQrbu16mCkAzdcg8"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/trepanat0r~centris-quebec/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-trepanat0r-centris-quebec",
                "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/trepanat0r~centris-quebec/runs": {
            "post": {
                "operationId": "runs-sync-trepanat0r-centris-quebec",
                "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/trepanat0r~centris-quebec/run-sync": {
            "post": {
                "operationId": "run-sync-trepanat0r-centris-quebec",
                "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": {
                    "regions": {
                        "title": "Quebec regions",
                        "type": "array",
                        "description": "One or more Quebec administrative regions to scrape. Leave empty to scrape all 17 regions.",
                        "default": [
                            "GSGS4621"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "category": {
                        "title": "Property category",
                        "enum": [
                            "Residential",
                            "Commercial",
                            "Plex"
                        ],
                        "type": "string",
                        "description": "Type of property to scrape.",
                        "default": "Residential"
                    },
                    "sellingType": {
                        "title": "Sale or rent",
                        "enum": [
                            "Sale",
                            "Rent"
                        ],
                        "type": "string",
                        "description": "Filter listings for sale or for rent.",
                        "default": "Sale"
                    },
                    "minPrice": {
                        "title": "Min price (CAD)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Minimum listing price filter.",
                        "default": 0
                    },
                    "maxPrice": {
                        "title": "Max price (CAD)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum listing price filter. Leave default for no cap.",
                        "default": 999999999999
                    },
                    "includeDetail": {
                        "title": "Include detail page enrichment",
                        "type": "boolean",
                        "description": "If enabled, the scraper visits each property's detail page to extract full description, characteristics (year built, lot size, etc.), municipal assessment, and high-res photo URLs. Each detail page adds ~1.5 seconds and increases cost (each enriched record is one paid event).",
                        "default": false
                    },
                    "maxListings": {
                        "title": "Max listings per region",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Cap on listings collected per region. Centris itself caps queries at 5,000 listings.",
                        "default": 500
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Centris.ca is generally scrapeable from any IP. Default Apify proxy is fine.",
                        "default": {
                            "useApifyProxy": true
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
