# Kijiji.ca $1💰 Classifieds, Vehicles, Jobs & Property (`abotapi/kijiji-scraper`) Actor

Extract listings from Kijiji.ca across property, vehicles, jobs, electronics, furniture, services, and more. Search by keyword and location or use any Kijiji URL. Returns title, description, price, photos, GPS coordinates, seller details, and category-specific attributes.

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

## Pricing

from $1.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.
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

## Kijiji.ca Scraper

Extract classified listings from Kijiji.ca across every category: property, vehicles, jobs, furniture, electronics, services, and more. Search by keyword and location, or paste any Kijiji URL. Each record carries the title, full description, price, every photo, GPS coordinates, seller details, and the category-specific attributes Kijiji shows on the listing. Fast and inexpensive at scale.

### Why this scraper

- Covers all of Kijiji.ca, not just one vertical. The extractor adapts to property, vehicles, and general classifieds automatically.
- Rich records out of the box: 30+ fields from the search page alone, including full description, all image URLs, and GPS coordinates.
- Optional detail enrichment adds view counts, seller phone and website, listing status, virtual tour or video, and dealer profile.
- Two ways in: keyword + location search (any Canadian city, region, or province), or paste Kijiji URLs directly.
- Price and sort filters, covering the whole result set with no artificial page ceiling.
- Resilient connection handling: rotates to a fresh exit IP on rejection and fails over to a backup gateway.
- Resumable: a run interrupted by a platform migration or Resurrect continues from where it left off (same dataset, no duplicate rows). `resumeFromRunId` also lets you pull just the NEW listings since a previous run.
- Incremental mode for recurring monitoring: schedule this actor daily or weekly and get only what changed, with no run/dataset id to paste.

### Data you get

> Sample shape, values are illustrative placeholders, not from a live listing.

| Field | Example |
| --- | --- |
| id | "0000000000" |
| listingType | "AutosListing" |
| title | "Sample listing title" |
| description | "Full listing description appears here." |
| url | "https://www.kijiji.ca/v-cars-trucks/city-of-toronto/sample/0000000000" |
| price | 12500.0 |
| priceRaw | 1250000 |
| priceType | "FIXED" |
| currency | "CAD" |
| categoryId | 174 |
| locationName | "Toronto" |
| address | "100 Sample Street, Toronto, ON, M0M 0M0" |
| latitude | 43.6500 |
| longitude | -79.4000 |
| nearestIntersection | \["Sample Road", "Example Avenue"] |
| imageUrls | \["https://media.kijiji.ca/api/v1/.../image?rule=kijijica-200-jpg"] |
| imageCount | 10 |
| posterId | "0000000000" |
| sellerType | "KMB" |
| posterRating | 4.5 |
| posterVerified | false |
| activationDate | "2026-01-01T00:00:00.000Z" |
| sortingDate | "2026-01-01T00:00:00.000Z" |
| isTopAd | false |
| attr\_carmake | "ford" |
| attr\_noofseats | "4" |
| views | 1140 |
| phoneNumber | "+15550000000" |
| sellerWebsiteUrl | "https://example.com/" |

Category-specific facts arrive as `attr_*` keys (for example `attr_carmake`, `attr_numberbedrooms`, `attr_dateavailable`) plus the full raw list in `attributesRaw`, so no field is ever dropped.

### How to use

Search a single keyword in one city:

```json
{
  "mode": "search",
  "keywords": ["iphone"],
  "location": "city-of-toronto",
  "maxListings": 50
}
```

Search with price filter and newest-first sort:

```json
{
  "mode": "search",
  "keywords": ["sofa"],
  "location": "vancouver",
  "minPrice": 100,
  "maxPrice": 500,
  "sortBy": "dateDesc",
  "maxListings": 100
}
```

Browse every listing in a location (no keyword), unlimited:

```json
{
  "mode": "search",
  "keywords": [],
  "location": "calgary",
  "fetchDetails": true,
  "maxPages": 0,
  "maxListings": 0
}
```

Paste Kijiji URLs directly (multiple supported):

```json
{
  "mode": "url",
  "urls": [
    "https://www.kijiji.ca/b-cars-trucks/city-of-toronto/c174l1700273",
    "https://www.kijiji.ca/b-apartments-condos/vancouver/c37l1700287"
  ],
  "maxListings": 200
}
```

Resume a previous run, collecting only listings added since then:

```json
{
  "mode": "search",
  "keywords": ["iphone"],
  "location": "city-of-toronto",
  "resumeFromRunId": "<a previous run or dataset ID>"
}
```

### Input parameters

| Parameter | Type | Default | Description |
| --- | --- | --- | --- |
| mode | string | "search" | "search" for keyword + location, "url" to paste links. |
| keywords | array | \["iphone"] | Search terms (search mode). Each runs as its own all-category search. Empty browses everything in the location. |
| location | string | "canada" | City, region, or province name, a Kijiji slug, or a numeric id. Resolved against the live Kijiji location list. |
| sortBy | string | "relevance" | "relevance", "dateDesc", "priceAsc", or "priceDesc". Search mode only. |
| urls | array | (example) | Kijiji search or listing URLs (URL mode). Keywords, Location, and Sort by are search-only and have no effect here. |
| minPrice | integer | (none) | Minimum price in Canadian dollars. Applies to both Search mode and URL mode. A listing with no numeric price (e.g. "Please Contact", "Free", "Swap") is dropped once either bound is set. |
| maxPrice | integer | (none) | Maximum price in Canadian dollars. Applies to both Search mode and URL mode; see minPrice for the no-price-listing behavior. |
| fetchDetails | boolean | true | Open each listing page for view count, seller phone and website, status, and more. |
| maxPages | integer | 0 | Optional bound on result pages per search or URL (40 listings per page). 0 = no page bound; the run stops on its own at the reported total, an empty page, or a page with no new listings. Does not cap listings saved: use maxListings for that. |
| maxListings | integer | 20 | Maximum listings to save for the whole run. 0 = unlimited (paid plans only). This is the one setting that bounds run size. |
| resumeFromRunId | string | (none) | ID of a previous run (or dataset) of this actor. Listings already in that dataset are skipped, so this run returns only new listings. |
| incrementalMode | boolean | false | Recurring monitoring: return only NEW/UPDATED/REAPPEARED listings vs. the actor's own memory of the last run for this search. See "Incremental / recurring updates" below. |
| stateKey | string | (empty) | Optional label for the tracked search in Incremental mode. Auto-derived from filters when empty. |
| emitUnchanged | boolean | false | Incremental mode only: also return UNCHANGED listings (the full snapshot every run). |
| emitExpired | boolean | false | Incremental mode only: also return EXPIRED listings, when this run reached the natural end of the search. |
| proxy | object | Residential CA | Proxy configuration. Residential with country CA is strongly recommended. |

The actor also survives a platform migration or a manual Resurrect of a failed/aborted run: it checkpoints its progress (current search, page, and collected IDs) and, when resumed with the same input, continues from there instead of restarting, with no duplicate rows and no duplicate charges.

### Incremental / recurring updates

For a search or URL list you run on a schedule (daily, weekly), turn on **`incrementalMode`** instead of pasting a run id every time. The actor remembers the listings it saw last time (in a dedicated key-value store, keyed by a hash of your search/URL filters, or your own `stateKey`) and classifies every listing it scrapes against that memory:

| `changeType` | Meaning |
| --- | --- |
| `NEW` | Not seen in any previous run for this search. |
| `UPDATED` | Seen before, and at least one field genuinely changed (`changedFields` lists which). |
| `UNCHANGED` | Seen before, nothing changed. **Not returned by default** (turn on `emitUnchanged` to get it anyway). |
| `REAPPEARED` | Seen before, then missing for a run, now back. |
| `EXPIRED` | Seen before, not found in this run, and this run reached the natural end of the search (no cap, no Resume); see `emitExpired` below. |

By default a recurring run therefore returns only what changed. A quiet run (nothing changed) can legitimately push **zero** listings, which is not an error.

- **`stateKey`**: optional human-readable label for the tracked search; leave empty for an automatic key derived from your filters.
- **`emitUnchanged`** (default off): also return `UNCHANGED` rows, i.e. the full current snapshot every run.
- **`emitExpired`** (default off): also return one tombstone row per listing no longer found, but **only** when this run scanned the search to its natural end (no `maxListings`/`maxPages` cap hit, no `resumeFromRunId`, no page that failed to load). A capped, page-bounded, or resumed run can't tell "gone from Kijiji" apart from "not reached yet this run", so it skips EXPIRED detection and logs why instead of guessing.
- `resumeFromRunId` and `incrementalMode` are two different features. Combine them only to bootstrap a monitoring baseline from a prior one-off crawl (the run fails fast if incremental mode already has saved state for that search).
- **Fields excluded from change detection**, so they never trigger a false `UPDATED`: `views` (a view counter that climbs on its own regardless of any real edit; measured live, the only recurring listing found across this actor's own past runs showed `views` drift with nothing else about the listing changing) and `sortingDate` (Kijiji's "newest first" ranking timestamp; the same measured listing was a promoted ad, and Kijiji advances a promoted ad's `sortingDate` to keep it near the top of the default sort independent of the seller editing anything). Every other field, including `price` and `description`, participates, since a real change there is exactly what a monitoring user wants surfaced. When `fetchDetails` is off, or an individual listing's detail page fails to load, the detail-only fields (`status`, `listingTypeOffer`, `endDate`, `externalSource`, `virtualTourUrl`, `youtubeVideoId`, `requestViewingUrl`, `mlsAd`, `phoneNumber`, `sellerWebsiteUrl`, `commercialProfile`, `posterInfo`) are also excluded for that comparison rather than reading their absence as Kijiji having removed them. One tradeoff from that last exclusion: a SERP-only seller-info change (e.g. a poster becoming verified) is only reliably detected when both compared runs have matching detail-page coverage.
- A failed detail-page fetch is not distinguishable, from this actor's code, between "the page never loaded" and "it loaded but had nothing to parse". Both are treated as "no detail this run"; the listing is still returned with its search-page fields, just without the detail-only ones.

### Send results into your apps (MCP connectors)

Optionally pipe the scraped results into the apps you already use, via Model Context Protocol (MCP) connectors. This is an extra delivery step **after** the scrape — the Apify dataset is never changed.

**What gets written to the connector:** a condensed, human-readable **summary** of each record — not the full JSON. Each item becomes one entry with a **title** and its key fields flattened to plain text. The **complete record always stays in the Apify dataset**.

1. Authorize a connector once under **Apify → Settings → Integrations** (Notion, Linear, Airtable, or Apify).
2. Select it in the **"Pipe results into your apps"** input field. (If the picker is empty, you haven't authorized a connector yet.)
3. For **Notion**, also set `notionParentPageUrl` to the page where items should be created.

The connection is mediated by Apify's MCP proxy, so this actor never sees your third-party credentials. Leave the field empty to skip.

### Output example

> Sample shape, values are illustrative placeholders, not from a live listing.

```json
{
  "id": "0000000000",
  "listingType": "AutosListing",
  "title": "Sample listing title",
  "description": "Full listing description appears here.",
  "url": "https://www.kijiji.ca/v-cars-trucks/city-of-toronto/sample/0000000000",
  "price": 12500.0,
  "priceRaw": 1250000,
  "priceType": "FIXED",
  "currency": "CAD",
  "categoryId": 174,
  "locationName": "Toronto",
  "address": "100 Sample Street, Toronto, ON, M0M 0M0",
  "latitude": 43.6500,
  "longitude": -79.4000,
  "imageUrls": ["https://media.kijiji.ca/api/v1/sample/image?rule=kijijica-200-jpg"],
  "imageCount": 10,
  "posterId": "0000000000",
  "sellerType": "KMB",
  "posterRating": 4.5,
  "posterVerified": false,
  "activationDate": "2026-01-01T00:00:00.000Z",
  "attr_carmake": "ford",
  "attr_noofseats": "4",
  "views": 1140,
  "phoneNumber": "+15550000000",
  "sellerWebsiteUrl": "https://example.com/"
}
```

### Plan requirement

Kijiji.ca accepts Canadian residential connections most reliably. The default proxy is Apify Residential with country CA, which requires an Apify Starter plan or higher. On the free plan, set the `BACKUP_PROXY_URL` environment variable to a Canadian residential gateway, or expect reduced results. Datacenter exits are frequently rejected by the site and are not recommended.

# Actor input Schema

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

Search by keyword + location, or paste Kijiji URLs directly.

## `keywords` (type: `array`):

Search terms (Search mode). Each term runs as a separate all-category search. Leave empty to browse every listing in the location.

## `location` (type: `string`):

City, region, or province name (e.g. 'Toronto', 'Vancouver', 'Ontario'), a Kijiji location slug ('city-of-toronto'), or a numeric location id. Defaults to all of Canada.

## `sortBy` (type: `string`):

Result ordering. Note: Kijiji inserts a few promoted ads at the top regardless of sort.

## `urls` (type: `array`):

Kijiji search or listing URLs (URL mode). Multiple supported. Pagination walks forward from the page in each URL. Keywords, Location, and Sort by are search-only and have no effect here; Min/Max price still filters these results.

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

Minimum price filter in Canadian dollars. Leave empty for no minimum.

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

Maximum price filter in Canadian dollars. Leave empty for no maximum.

## `fetchDetails` (type: `boolean`):

Open each listing's detail page for view count, seller phone + website, listing status, virtual tour / video, and dealer profile. Slower but much richer.

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

Optional bound on result pages walked per search/URL (40 listings per page). Use 0 to walk the whole catalogue: the run stops on its own once Kijiji's reported total is reached, a page comes back empty, or a page returns no new listings. This does NOT cap the number of listings saved; use Max listings for that.

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

Maximum listings to save across the whole run. 0 = unlimited (paid plans only): collect every available listing, bounded only by Max pages and the natural end of results.

## `resumeFromRunId` (type: `string`):

ID of a previous run of this actor (or a dataset ID). Listings already in that dataset are skipped, so this run returns only NEW listings (a delta). Combine both runs' datasets for the full set. Max listings then counts only the new listings. For a recurring/scheduled search, use Incremental mode below instead: it remembers the previous run itself, without pasting an id every time.

## `incrementalMode` (type: `boolean`):

For a search/URL list you run on a schedule (daily, weekly): the actor remembers the listings it saw last time (in a dedicated key-value store, keyed by this search) and, by default, only returns listings that are NEW, UPDATED (price, description, ... changed) or REAPPEARED. Unlike Resume above, you never need to paste a run or dataset id; it tracks itself. Off by default: a normal run always returns every matching listing.

## `stateKey` (type: `string`):

Optional label for the tracked search when Incremental mode is on, e.g. 'toronto-iphones'. Leave empty to let the actor derive one automatically from your search/URL filters (two different searches never share a baseline either way). Set this if you want a stable, human-readable name, or want to run the exact same search twice as two separate monitoring campaigns.

## `emitUnchanged` (type: `boolean`):

When Incremental mode is on, also return listings with no changes since last time (changeType 'UNCHANGED'), not just NEW/UPDATED/REAPPEARED. Off by default. Returning unchanged rows bills like any other listing — turn this on only if you need the full current snapshot every run, not just what changed.

## `emitExpired` (type: `boolean`):

When Incremental mode is on AND this run scans the search to its natural end (no Max listings/Max pages cap reached, no Resume from a previous run), also return one row per previously-seen listing no longer found (changeType 'EXPIRED'), using its last-known data. Off by default. Returning expired rows bills like any other listing.

## `proxy` (type: `object`):

Kijiji.ca works most reliably on Apify Residential proxy with country = CA. Datacenter exits are frequently rejected. On failure the actor rotates to a fresh exit IP and can fail over to a backup gateway.

## `mcpConnectors` (type: `array`):

Optionally send the scraped results into the apps you already use, via Model Context Protocol (MCP) connectors. Authorize a connector once under Apify → Settings → Integrations, then select it here. The connector receives a condensed, human-readable summary per item (title + key fields), not the full JSON — the complete record stays in the dataset. Leave empty to skip. Supported: Notion (https://mcp.notion.com/mcp), Linear (https://mcp.linear.app/sse), Airtable (https://mcp.airtable.com/mcp), Apify (https://mcp.apify.com).

## `notionParentPageUrl` (type: `string`):

URL (or id) of the Notion page under which item pages are created. Required to enable the Notion export; ignored by other connectors.

## `maxNotifyListings` (type: `integer`):

Cap on items written to each connector per run. Does not affect the dataset.

## Actor input object example

```json
{
  "mode": "search",
  "keywords": [
    "iphone"
  ],
  "location": "city-of-toronto",
  "sortBy": "relevance",
  "urls": [
    "https://www.kijiji.ca/b-apartments-condos/city-of-toronto/c37l1700273"
  ],
  "fetchDetails": true,
  "maxPages": 0,
  "maxListings": 20,
  "incrementalMode": false,
  "emitUnchanged": false,
  "emitExpired": false,
  "proxy": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "CA"
  },
  "maxNotifyListings": 50
}
```

# Actor output Schema

## `listings` (type: `string`):

Individual listing records with price, location hierarchy, GPS coordinates, all image URLs, seller info, and category-specific attributes.

## `output` (type: `string`):

Run summary with totals, pages fetched, details fetched, and duration.

# 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 = {
    "mode": "search",
    "keywords": [
        "iphone"
    ],
    "location": "city-of-toronto",
    "urls": [
        "https://www.kijiji.ca/b-apartments-condos/city-of-toronto/c37l1700273"
    ],
    "maxPages": 0,
    "maxListings": 20,
    "proxy": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "apifyProxyCountry": "CA"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("abotapi/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 = {
    "mode": "search",
    "keywords": ["iphone"],
    "location": "city-of-toronto",
    "urls": ["https://www.kijiji.ca/b-apartments-condos/city-of-toronto/c37l1700273"],
    "maxPages": 0,
    "maxListings": 20,
    "proxy": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "CA",
    },
}

# Run the Actor and wait for it to finish
run = client.actor("abotapi/kijiji-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 '{
  "mode": "search",
  "keywords": [
    "iphone"
  ],
  "location": "city-of-toronto",
  "urls": [
    "https://www.kijiji.ca/b-apartments-condos/city-of-toronto/c37l1700273"
  ],
  "maxPages": 0,
  "maxListings": 20,
  "proxy": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "CA"
  }
}' |
apify call abotapi/kijiji-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,abotapi/kijiji-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/Q197vGm0YmVfdU8Ib/builds/lYvaT6bGoxA9l0m7G/openapi.json