# Realtor.ca Scraper - Canada Real Estate, Agents & Leads (`scrapesage/realtor-ca-scraper`) Actor

Scrape Realtor.ca for-sale & for-rent homes across Canada: price, beds/baths, size, address & geo, photos, remarks, MLS#, plus listing agent & brokerage leads. Search by city, map URL or MLS number. New-listing & price-drop monitoring. No login, key or browser.

- **URL**: https://apify.com/scrapesage/realtor-ca-scraper.md
- **Developed by:** [Scrape Sage](https://apify.com/scrapesage) (community)
- **Categories:** Real estate, Lead generation, Agents
- **Stats:** 3 total users, 3 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.20 / 1,000 property scrapeds

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/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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 Scraper — Canada Real Estate Listings, Agents & Leads

Extract **complete Realtor.ca real-estate data** for any Canadian city, neighbourhood or map area — the listings *and* the people behind them. Pull live **for-sale** and **for-rent** homes with price, beds/baths, size, lot, address & geo, photos, full remarks, property type and MLS® number, **plus the listing agent and brokerage as ready-to-use leads** (name, phone, office). Search a whole metro, a custom map box, a point + radius, or look up exact MLS® numbers — and monitor a market for **new listings and price drops**.

No login, no API key, no browser — fast JSON extraction straight from Realtor.ca's own public listing data path.

### Why this Realtor.ca scraper?

Realtor.ca (operated by CREA) is **the** national real-estate portal of Canada. Most scrapers return a thin listing grid and stop. This actor ships the **richest record in the category** and turns every listing into a lead:

| Data | Typical scrapers | This actor |
|---|---|---|
| Price, beds, baths, size, property type, MLS# | ✅ | ✅ |
| Full address, postal code, community, neighbourhood, lat/long | partial | ✅ |
| For sale **and** for rent | partial | ✅ |
| Ownership type, building type, stories, age, lot size & frontage | ❌ | ✅ |
| Parking, nearby amenities, landscape features | ❌ | ✅ |
| Full public remarks / description | partial | ✅ |
| All listing photos (high-res) | partial | ✅ |
| **Listing agent: name, phone, cell, profile** | ❌ | ✅ |
| **Brokerage: name, phone, fax, office address, website** | ❌ | ✅ |
| **Deduplicated agent-lead list** with active-listing count & lead score | ❌ | ✅ |
| Listed date, time-on-market, price-change date | ❌ | ✅ |
| New-listing & price-drop monitoring | ❌ | ✅ |
| Whole-metro coverage past the 500-result cap (auto map tiling) | ❌ | ✅ |

### Use cases

- **Real-estate lead generation** — every listing carries the **listing agent and brokerage** with phone numbers and office details. Run `Agents` mode to get a clean, deduplicated agent/brokerage prospect list per market, ranked by a 0-100 lead score and active-listing volume.
- **Investing & market analysis** — pull active inventory or rentals for a city, filter by price, beds and property type, and compare $/listing, rent levels and days-on-market across neighbourhoods.
- **Pricing & inventory intelligence** — track active counts, new listings, price cuts and rent trends for any Canadian metro over time.
- **New-listing & price-drop alerts** — run in monitoring mode on a schedule to capture only listings that are new or whose price/status changed since the last run.
- **Proptech, CRM & valuation models** — feed clean, structured Canadian listings, geo and agent data straight into your own models, dashboards or CRM.

### How to use

1. [Sign up for Apify](https://console.apify.com/sign-up) — the free plan is enough to try this actor.
2. Open the **Realtor.ca Scraper**, type one or more **cities** (e.g. `Toronto`, `Vancouver`, `Calgary`), pick **For sale** or **For rent**, and click **Start**.
3. Watch results stream into the dataset table.
4. **Export** as JSON, CSV, Excel, XML, or RSS — or pull results programmatically via the [Apify API](https://docs.apify.com/api/v2).

### Input

```json
{
    "mode": "properties",
    "transactionType": "sale",
    "searchCities": ["Toronto", "Calgary"],
    "propertyType": "residential",
    "priceMin": 500000,
    "priceMax": 1200000,
    "bedsMin": 3,
    "sort": "newest",
    "subdivideLargeAreas": true,
    "maxResults": 500
}
```

- **mode** — `properties` (one record per listing, agent embedded) or `agents` (deduplicated agent/brokerage leads).
- **transactionType** — `sale`, `rent`, or `all`.
- **searchCities** — Canadian cities; 55+ major metros are built in (Toronto, Vancouver, Calgary, Edmonton, Ottawa, Montreal, Halifax, Winnipeg, Quebec City and many more).
- **startUrls** — any [realtor.ca map URL](https://www.realtor.ca/map): search your area on Realtor.ca, copy the `…/map#…` URL, and the actor reads the bounding box from it (works for any town or neighbourhood).
- **boundingBoxes** — explicit `latMin,lngMin,latMax,lngMax` rectangles.
- **centerPoints** — a `lat,lng,radiusKm` catchment around a point.
- **mlsNumbers** — look up exact listings by MLS® number (e.g. `A2321763`).
- **propertyType / priceMin / priceMax / bedsMin / bathsMin / sort** — listing filters.
- **enrichDetails** *(default false)* — fetch each listing's full detail record (complete remarks + extra fields).
- **subdivideLargeAreas / maxSubdivisionDepth** — Realtor.ca caps any query at 500 results; the actor auto-splits busy areas into map tiles for full coverage.
- **maxResults / maxResultsPerArea** — global and per-area caps.
- **monitorMode** *(default false)* — emit ONLY new or changed (price/status) listings vs. the previous run; pairs with [Schedules](https://docs.apify.com/platform/schedules).

### Output

One record per property (agent & brokerage embedded):

```json
{
    "id": "29913854",
    "mlsNumber": "A2321763",
    "url": "https://www.realtor.ca/real-estate/29913854/487-arlington-drive-se-calgary-acadia",
    "transactionType": "For sale",
    "price": 739900,
    "priceFormatted": "$739,900",
    "propertyType": "Single Family",
    "ownershipType": "Freehold",
    "address": "487 Arlington Drive SE, Calgary, Alberta T2H1S4",
    "city": "Calgary",
    "province": "Alberta",
    "postalCode": "T2H1S4",
    "latitude": 50.975628,
    "longitude": -114.057285,
    "bedrooms": 4,
    "bedroomsRaw": "2 + 2",
    "bathroomsTotal": 3,
    "sizeInterior": "1525 sqft",
    "lotSize": "7480 sqft",
    "parkingTotal": 4,
    "amenitiesNearby": "Playground, Schools, Shopping",
    "status": "Active",
    "timeOnRealtor": "25 min ago",
    "listedDate": "2026-06-17T02:02:23.640Z",
    "photoCount": 32,
    "primaryPhoto": "https://cdn.realtor.ca/listings/.../highres/...jpg",
    "listingAgentName": "Brandon Cabrera",
    "listingAgentPhone": "(587) 577-3627",
    "brokerageName": "CIR Realty",
    "brokeragePhone": "(403) 271-0600",
    "agents": [
        {
            "agentId": 2256996,
            "name": "Brandon Cabrera",
            "position": "Associate",
            "phone": "(587) 577-3627",
            "profileUrl": "https://www.realtor.ca/agent/2256996/brandon-cabrera-...",
            "brokerage": {
                "name": "CIR Realty",
                "phone": "(403) 271-0600",
                "fax": "(403) 271-5909",
                "address": "130, 703 - 64 AVENUE SE, CALGARY, Alberta T2H2C3",
                "profileUrl": "https://www.realtor.ca/office/firm/54464/cir-realty-..."
            }
        }
    ],
    "scrapedAt": "2026-06-17T12:00:00.000Z"
}
```

In `agents` mode each record is a deduplicated agent/brokerage lead with `activeListings`, `cities`, `sampleMls` and a 0-100 `leadScore`. In monitoring mode each listing also carries `changeType` (`new` / `price_drop` / `price_increase` / `status_change`) and `previousPrice`.

### Pricing — pay per result, no start or subscription fee

You pay only for what you pull:

| Event | Charged | Price |
|---|---|---|
| **Property scraped** | Every listing written to the dataset (full record + agent/brokerage). | **$0.004** |
| **Property detail enriched** | Once per listing whose full detail record is fetched (`enrichDetails` on). | **$0.005** |
| **Agent lead scraped** | Each unique agent/brokerage lead emitted in `agents` mode. | **$0.008** |

- **Listings** run → **$0.004 / property** (grid record already includes the agent & brokerage).
- **Full-detail** run → **$0.009 / property** (listing + enrichment).
- **Agent-lead** run → **$0.008 / unique agent**.

Example: 1,000 listings = **$4.00**; 500 deduplicated agent leads = **$4.00**. Apify platform compute & proxy usage is billed separately by Apify.

### Automate & schedule

Run this actor on autopilot and pull results into your own stack:

- **[Apify API](https://docs.apify.com/api/v2)** — start runs, fetch datasets, and manage schedules over REST.
- **[apify-client for JavaScript](https://docs.apify.com/api/client/js/)** and **[apify-client for Python](https://docs.apify.com/api/client/python/)** — official SDKs.
- **[Schedules](https://docs.apify.com/platform/schedules)** — run it hourly/daily to monitor a market for new listings and price drops.
- **[Webhooks](https://docs.apify.com/platform/integrations/webhooks)** — trigger downstream actions (CRM import, Slack alert, email sequence) the moment a run finishes.

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

const client = new ApifyClient({ token: 'MY_APIFY_TOKEN' });

const run = await client.actor('scrapesage/realtor-ca-scraper').call({
    mode: 'properties',
    transactionType: 'sale',
    searchCities: ['Toronto'],
    bedsMin: 3,
    monitorMode: true,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(`Got ${items.length} Realtor.ca listings`);
```

### Integrate with any app

Connect the dataset to 5,000+ apps — no code required:

- **[Make](https://docs.apify.com/platform/integrations/make)** — multi-step automation scenarios.
- **[Zapier](https://docs.apify.com/platform/integrations/zapier)** — push new listings or agent leads straight into your CRM.
- **[Slack](https://docs.apify.com/platform/integrations/slack)** — get notified when a monitored market gets new listings or price cuts.
- **[Google Drive / Sheets](https://docs.apify.com/platform/integrations/drive)** — auto-export every run to a spreadsheet.
- **[Airbyte](https://docs.apify.com/platform/integrations/airbyte)** — pipe results into your data warehouse.
- **[GitHub](https://docs.apify.com/platform/integrations/github)** — trigger runs from commits or releases.

### Use with AI assistants (MCP)

The output is clean, LLM-ready JSON. You can call this actor from Claude, ChatGPT, or any agent framework through the **[Apify MCP server](https://docs.apify.com/platform/integrations/mcp)** — ask your assistant to "find 3-bed houses under $900k in Calgary and list the agents" and let it run this scraper for you.

### Agent-ready: autonomous payments (x402 & Skyfire)

This actor is **agent-ready** — AI agents can discover it, run it, and **pay for it autonomously**, with no Apify account and no human in the loop. It uses [pay-per-event](https://docs.apify.com/platform/actors/publishing/monetize/pay-per-event) pricing and [limited permissions](https://docs.apify.com/platform/actors/development/permissions), so it qualifies for Apify's agentic-payment standards:

- **[x402](https://docs.apify.com/platform/integrations/x402)** — an open, HTTP-native payment protocol. Agents pay per run in USDC on the Base network directly through the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp) — no account, no API key.
- **[Skyfire](https://docs.apify.com/platform/integrations/skyfire)** — agent-to-service payments for fully autonomous AI-agent workflows.

Building an AI agent, MCP tool, or autonomous data pipeline? This scraper is ready to plug in and pay as it goes.

### More scrapers from scrapesage

Build a complete **property & local-market intelligence stack**:

- **[Redfin Scraper](https://apify.com/scrapesage/redfin-scraper)** — US listings, sold comps, Redfin Estimate & agent leads.
- **[Rightmove Scraper](https://apify.com/scrapesage/rightmove-scraper)** — UK for-sale & to-rent properties with agent leads.
- **[Rent.com Scraper](https://apify.com/scrapesage/rent-com-scraper)** — US apartment & rental listings with property-management leads.
- **[Property Finder Scraper](https://apify.com/scrapesage/property-finder-scraper)** — UAE/GCC real estate, off-plan projects & agent leads.
- **[FastExpert Scraper](https://apify.com/scrapesage/fastexpert-agent-scraper)** — US real-estate agent leads, stats & reviews.
- **[Craigslist Scraper](https://apify.com/scrapesage/craigslist-scraper)** — FSBO housing, real estate & classifieds with phone/email leads.
- **[Houzz Scraper](https://apify.com/scrapesage/houzz-scraper)** — home-improvement pros, contacts and reviews.

### Tips

- **Whole-metro coverage**: Realtor.ca returns at most **500 results per query**. Keep `subdivideLargeAreas` on (default) so the actor auto-tiles busy cities — raise `maxSubdivisionDepth` for exhaustive coverage of a large market.
- **Any area, any town**: not in the built-in city list? Open [realtor.ca/map](https://www.realtor.ca/map), search your area, and paste the `…/map#…` URL into `startUrls` — the bounding box is read straight from the URL.
- **Agent prospecting**: switch `mode` to `agents` for a deduplicated agent/brokerage lead list with phone, office and a lead score, instead of one row per listing.
- **Recurring monitoring**: combine [Schedules](https://docs.apify.com/platform/schedules) with `monitorMode` to track only new listings and price drops — the actor's own "seen" memory is separate from the Apify scheduler, so they work together cleanly.
- **Proxies**: keep the default **Canadian residential** proxy — Realtor.ca's edge (Imperva Incapsula) rate-blocks datacenter and single IPs, so residential is required (and is the default). A fully blocked run **fails loudly** instead of returning an empty dataset.

### FAQ

**How do I scrape Realtor.ca for a specific city?** Type the city name into `searchCities` (Toronto, Vancouver, Calgary, …). For a town or neighbourhood that isn't built in, paste a realtor.ca map URL into `startUrls`, or give a bounding box / center point.

**Can I get rentals?** Yes — set `transactionType` to `rent` (or `all` for both). Price filters apply to monthly rent for rentals.

**Does it include the listing agent's contact?** Yes — every listing carries the listing agent (name, phone, cell, profile link) and the brokerage (name, phone, fax, office address). Run `agents` mode for a deduplicated agent-lead list.

**Why is there a 500-result cap per area?** That's Realtor.ca's own per-query limit. The actor works around it by automatically splitting busy areas into smaller map tiles — keep `subdivideLargeAreas` on.

**Can I export to Google Sheets, CSV, or Excel?** Yes — one click in the dataset view, or automatically on every run via the [Google Drive integration](https://docs.apify.com/platform/integrations/drive).

**How do I monitor new listings automatically?** Turn on `monitorMode` and create a [Schedule](https://docs.apify.com/platform/schedules). Each run emits only listings that are new or changed since the last run, tagged with `changeType`.

**Is scraping Realtor.ca legal?** This actor collects publicly available data only. You are responsible for using the data in compliance with applicable laws and Realtor.ca's terms.

**A field is null — why?** Some listings genuinely don't publish a lot size, agent cell or amenity list. Fields are `null` only when the data doesn't exist, not because the scraper skipped them.

### Need help?

Open an issue on the actor's **Issues** tab, or visit the [Apify help center](https://help.apify.com/). Feature requests are welcome — this actor is actively maintained.

# Actor input Schema

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

`Properties` = one rich record per listing (with the listing agent & brokerage embedded). `Agents` = the same search, but output deduplicated **agent / brokerage leads** (name, phone, brokerage, cities covered, active-listing count, lead score) instead of listings.

## `transactionType` (type: `string`):

Scrape homes `For sale`, `For rent`, or both.

## `searchCities` (type: `array`):

Canadian cities to scrape (e.g. `Toronto`, `Vancouver`, `Calgary`, `Ottawa`, `Montreal`, `Halifax`). 55+ major metros are built in. For any other area, use **Bounding boxes**, **Center points**, or a **Realtor.ca map URL** below.

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

Optional. Open [realtor.ca](https://www.realtor.ca/map), search your area, apply any filters, then copy the `https://www.realtor.ca/map#...` URL from your address bar. The map's bounding box is read straight from the URL — works for any neighbourhood, town or region.

## `boundingBoxes` (type: `array`):

Optional. Explicit map rectangles as `latMin,lngMin,latMax,lngMax` (e.g. `43.58,-79.64,43.86,-79.12` for Toronto). Each box is searched directly.

## `centerPoints` (type: `array`):

Optional. A point + radius as `lat,lng,radiusKm` (e.g. `43.6532,-79.3832,8`). A bounding box is built around the point. Handy for a custom catchment around an address.

## `mlsNumbers` (type: `array`):

Optional. Look up specific listings directly by their Realtor.ca MLS® number (e.g. `A2321763`, `C12363977`).

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

Limit to a Realtor.ca property bucket.

## `priceMin` (type: `integer`):

Only keep listings priced at least this much (CAD). For rentals this is the minimum monthly rent. Leave empty for no filter.

## `priceMax` (type: `integer`):

Only keep listings priced at most this much (CAD). Leave empty for no filter.

## `bedsMin` (type: `integer`):

Minimum number of bedrooms. Leave empty for no filter.

## `bathsMin` (type: `integer`):

Minimum number of bathrooms. Leave empty for no filter.

## `sort` (type: `string`):

Order listings are pulled in (also controls which appear first when capped). 'Newest' is best for monitoring.

## `customSearchParams` (type: `object`):

Optional. Extra Realtor.ca `PropertySearch_Post` parameters merged verbatim into the request (e.g. `{ "BuildingTypeId": 1 }`). For power users who know the API.

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

Fetch each listing's full Realtor.ca detail record (complete public remarks, room/building details, land, history). The grid already carries most fields, so enrichment mainly fills in the full description. Adds one API call per listing (and the per-detail charge). Leave off for a fast, cheap grid run.

## `subdivideLargeAreas` (type: `boolean`):

Realtor.ca returns at most 500 listings per query. When an area has more, automatically split it into smaller map tiles to capture them all. Turn off to take only the first ~500 of each area.

## `maxSubdivisionDepth` (type: `integer`):

How many times a busy area may be split (each level = 4× more tiles). 2 covers very large metros; raise for exhaustive coverage of a whole city.

## `maxResults` (type: `integer`):

Global cap on the total number of records emitted in this run.

## `maxResultsPerArea` (type: `integer`):

Cap per city / box / point. Combine with subdivision for deep coverage of large markets.

## `monitorMode` (type: `boolean`):

Remember listings already returned and emit ONLY listings that are **new** or whose **price/status changed** since the last run (tagged `changeType`: new / price\_drop / price\_increase / status\_change). Perfect for new-listing alerts and price-drop tracking. Pairs with Apify Schedules.

## `monitorStoreName` (type: `string`):

Named key-value store that holds the 'already seen' listings for monitoring mode. Use a different name per tracked market to keep histories separate (lowercase letters, digits and hyphens).

## `maxConcurrency` (type: `integer`):

Maximum parallel detail requests. Keep moderate — Realtor.ca's edge rate-challenges bursts, and the actor already rotates a fresh proxy session per request.

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

Proxy settings. Realtor.ca sits behind Imperva Incapsula, which rate-blocks datacenter and single IPs, so **Canadian residential proxies are the default and recommended** setting. Datacenter proxies will fail with blocks.

## `urlsFromFile` (type: `string`):

Paste a list of URLs (one per line), OR one link to a .txt/.csv file, Google Sheet or Google Drive file containing them. Lets you import many Start URLs at once instead of typing each. Google Sheet/Drive share links are handled automatically.

## Actor input object example

```json
{
  "mode": "properties",
  "transactionType": "sale",
  "searchCities": [
    "Toronto"
  ],
  "propertyType": "any",
  "sort": "newest",
  "enrichDetails": false,
  "subdivideLargeAreas": true,
  "maxSubdivisionDepth": 2,
  "maxResults": 200,
  "maxResultsPerArea": 500,
  "monitorMode": false,
  "monitorStoreName": "realtor-ca-monitor",
  "maxConcurrency": 4,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "CA"
  }
}
```

# Actor output Schema

## `results` (type: `string`):

All scraped Realtor.ca records in the default dataset. Use the Listings / Detail / Agent leads views to filter columns.

# 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 = {
    "searchCities": [
        "Toronto"
    ],
    "urlsFromFile": ""
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapesage/realtor-ca-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 = {
    "searchCities": ["Toronto"],
    "urlsFromFile": "",
}

# Run the Actor and wait for it to finish
run = client.actor("scrapesage/realtor-ca-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "searchCities": [
    "Toronto"
  ],
  "urlsFromFile": ""
}' |
apify call scrapesage/realtor-ca-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,scrapesage/realtor-ca-scraper"
        }
    }
}

```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/7uH58xb0L3czEXsxl/builds/lBuHpHM60AS0CJf6h/openapi.json