# Kijiji Scraper - Canada Listings Data (`benthepythondev/kijiji-scraper`) Actor

Scrape Kijiji.ca listings from search-result URLs, including real-estate rentals with price, address, bedrooms, bathrooms, coordinates, poster info, images and listing URLs.

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

## Pricing

from $3.00 / 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.

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

## Kijiji Scraper - Canada Listings Data

Scrape listings from **Kijiji.ca**, one of Canada's largest classifieds marketplaces, in one run. Paste any Kijiji search-results URL and get clean listing data with prices, titles, descriptions, images, locations, poster information and direct URLs. Real-estate rental categories include extra fields such as bedrooms, bathrooms, furnished status, utilities, parking, pet rules, coordinates and address data. Export to JSON/CSV/Excel, run on a schedule, call via API, or connect to Make, Zapier or n8n.

### What is the Kijiji Scraper?

The Kijiji Scraper turns public Kijiji search pages into structured data. It is designed for Canada classifieds monitoring, rental-market research, lead generation, price tracking and marketplace analysis. Instead of opening listings manually and copying fields one by one, you can paste a filtered Kijiji search URL and receive normalized rows in the Apify dataset.

The actor is especially useful for real-estate categories such as apartments, condos, rooms, parking, commercial rentals and homes for sale. Kijiji exposes rich rental metadata inside its search-page data, so the actor can return more than a simple title and URL: it can include coordinates, rent-by type, utilities, parking, accessibility fields and other attributes where Kijiji provides them.

#### What data does it extract?

**Listing identity:** Kijiji listing ID, title, description, category ID, listing URL and source search URL.

**Price data:** price, price type and currency.

**Location data:** city or area name, address, nearest intersections, latitude and longitude.

**Rental attributes:** bedrooms, bathrooms, unit type, furnished status, parking, pet rules, smoking rules and agreement type.

**Utility and amenity fields:** heat, hydro, water, internet, cable TV, balcony, yard, elevator, laundry and wheelchair accessibility.

**Seller/poster signals:** poster ID, verification flag, poster rating when available, top-ad flag and showcase flag.

**Media:** primary image, all image URLs and image count.

**Timing:** activation date and Kijiji sorting date.

### Input

| Field | Type | Description |
| --- | --- | --- |
| `searchUrls` | array | Kijiji.ca search-results URLs. Use the filters on Kijiji first, then paste the resulting URL. |
| `maxResults` | integer | Maximum number of listings to return across all supplied URLs. |
| `maxPages` | integer | Maximum number of result pages to fetch per search URL. |

#### Example input

```json
{
  "searchUrls": [
    "https://www.kijiji.ca/b-apartments-condos/city-of-toronto/c37l1700273"
  ],
  "maxResults": 25,
  "maxPages": 2
}
````

### Output

Each result is pushed as one dataset item.

```json
{
  "id": "1737964689",
  "title": "1 Bedroom Apartment for Rent! Dufferin St./Lawrence Ave.!",
  "description": "Live well at Glen Park Apartments...",
  "url": "https://www.kijiji.ca/v-apartments-condos/city-of-toronto/...",
  "category_id": 37,
  "price": 1695,
  "price_type": "FIXED",
  "currency": "CAD",
  "location_name": "City of Toronto",
  "address": "437 Glen Park Ave, Toronto, ON, M6B 2E8",
  "nearest_intersections": ["Glencairn Avenue", "Ennerdale Street"],
  "latitude": 43.70749,
  "longitude": -79.45535,
  "bedrooms": "1",
  "bathrooms": 1,
  "unit_type": "apartment",
  "for_rent_by": "reprofessional",
  "furnished": false,
  "parking_spots": "0",
  "pets_allowed": "1",
  "poster_id": "90184145",
  "poster_verified": false,
  "is_top_ad": true,
  "image_count": 11,
  "image": "https://media.kijiji.ca/api/v1/...",
  "activation_date": "2026-05-21T23:03:08.000Z",
  "search_url": "https://www.kijiji.ca/b-apartments-condos/city-of-toronto/c37l1700273"
}
```

### Use cases

**Rental-market monitoring:** Track asking rents, bedrooms, bathrooms and location patterns across Toronto, Vancouver, Montreal, Calgary and other Canadian markets.

**Real-estate lead generation:** Collect fresh rental listings, owner/professional signals and poster IDs for sales, property-management or tenant-acquisition workflows.

**Classifieds price tracking:** Monitor prices for cars, furniture, electronics, tools, equipment or local services by pasting a Kijiji category URL.

**Market research:** Build datasets for location analysis, inventory changes, competitive supply, listing velocity and neighborhood-level trends.

**Automation:** Schedule searches daily and send new rows to a CRM, spreadsheet, BI dashboard, Slack alert, Airtable base or internal database.

### FAQ

**Does it work with any Kijiji URL?** It is built for public Kijiji search-results URLs. Real-estate search URLs provide the richest structured fields, but many category searches expose usable listing data too.

**Do I need a Kijiji account?** No. The actor reads public search-page data and does not require a Kijiji login.

**Can I filter by city, price or category?** Yes. Apply filters on Kijiji, copy the resulting URL, and paste it into `searchUrls`.

**Does it scrape detail pages?** This version focuses on search-result data because it is faster, cheaper and more reliable for scheduled runs. Detail-page crawling can be added later if there is strong demand.

**Can it return coordinates?** For real-estate listings, Kijiji often embeds latitude and longitude in the search page. The actor returns those when available.

**Why do some fields return null?** Kijiji categories differ. A furniture listing will not have bedrooms or bathrooms; a rental listing may not expose every utility or amenity.

**Is this actor free to run?** It uses direct HTTP requests and does not require a paid unblocker in the tested path. You only pay the actor's configured result pricing and standard Apify platform usage.

**Is it legal to scrape Kijiji?** Use the data responsibly, respect applicable laws, follow Kijiji's terms, and avoid using personal data for spam or unlawful outreach. For compliance-sensitive use cases, consult your legal team.

**Can I schedule it?** Yes. Apify schedules can run the same Kijiji searches hourly, daily or weekly and send results to your preferred destination.

### You might also like

- [Craigslist Real Estate Scraper](https://apify.com/benthepythondev/craigslist-real-estate-scraper) for US real-estate classifieds.
- [Zumper Rental Scraper](https://apify.com/benthepythondev/zumper-rental-scraper) for US rental listings.
- [PadMapper Rental Scraper](https://apify.com/benthepythondev/padmapper-rental-scraper) for apartment listings.
- [Website Contact Extractor](https://apify.com/benthepythondev/website-contact-extractor) for finding contact emails and phone numbers from company websites.

**Keywords:** Kijiji scraper, Kijiji API, Kijiji Canada scraper, Kijiji real estate scraper, Kijiji rentals scraper, Kijiji apartments scraper, Canada classifieds scraper, Toronto rentals data, Vancouver rentals data, Kijiji price tracker, classifieds monitoring, rental market data, real estate lead generation, Kijiji listings export, Apify Kijiji scraper

# Actor input Schema

## `searchUrls` (type: `array`):

Paste Kijiji.ca search-results URLs. Real-estate category URLs return the richest structured fields.

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

Maximum listings to return across all search URLs.

## `maxPages` (type: `integer`):

How many Kijiji result pages to fetch per search URL.

## Actor input object example

```json
{
  "searchUrls": [
    "https://www.kijiji.ca/b-apartments-condos/city-of-toronto/c37l1700273"
  ],
  "maxResults": 10,
  "maxPages": 1
}
```

# 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 = {
    "searchUrls": [
        "https://www.kijiji.ca/b-apartments-condos/city-of-toronto/c37l1700273"
    ],
    "maxResults": 10,
    "maxPages": 1
};

// Run the Actor and wait for it to finish
const run = await client.actor("benthepythondev/kijiji-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 = {
    "searchUrls": ["https://www.kijiji.ca/b-apartments-condos/city-of-toronto/c37l1700273"],
    "maxResults": 10,
    "maxPages": 1,
}

# Run the Actor and wait for it to finish
run = client.actor("benthepythondev/kijiji-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 '{
  "searchUrls": [
    "https://www.kijiji.ca/b-apartments-condos/city-of-toronto/c37l1700273"
  ],
  "maxResults": 10,
  "maxPages": 1
}' |
apify call benthepythondev/kijiji-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Kijiji Scraper - Canada Listings Data",
        "description": "Scrape Kijiji.ca listings from search-result URLs, including real-estate rentals with price, address, bedrooms, bathrooms, coordinates, poster info, images and listing URLs.",
        "version": "1.0",
        "x-build-id": "3V2vzDBbzIwb4HsSz"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/benthepythondev~kijiji-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-benthepythondev-kijiji-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/benthepythondev~kijiji-scraper/runs": {
            "post": {
                "operationId": "runs-sync-benthepythondev-kijiji-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/benthepythondev~kijiji-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-benthepythondev-kijiji-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": {
                    "searchUrls": {
                        "title": "Kijiji search URLs",
                        "type": "array",
                        "description": "Paste Kijiji.ca search-results URLs. Real-estate category URLs return the richest structured fields.",
                        "default": [
                            "https://www.kijiji.ca/b-apartments-condos/city-of-toronto/c37l1700273"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxResults": {
                        "title": "Max results",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Maximum listings to return across all search URLs.",
                        "default": 50
                    },
                    "maxPages": {
                        "title": "Max pages per URL",
                        "minimum": 1,
                        "maximum": 20,
                        "type": "integer",
                        "description": "How many Kijiji result pages to fetch per search URL.",
                        "default": 3
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
