# Kijiji Listings Scraper · Full descriptions · $0.76/1K (`mlg14/kijiji-scraper`) Actor

Scrape Kijiji classifieds from search or listing URLs for rental market research, price monitoring and lead generation. Returns full descriptions, prices, images, category attributes, location and status. No login. $0.76/1K listings.

- **URL**: https://apify.com/mlg14/kijiji-scraper.md
- **Developed by:** [MLG Data](https://apify.com/mlg14) (community)
- **Categories:** Real estate, Automation
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

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

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## 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.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Kijiji Scraper

Scrape Kijiji classified listings from a search page or a direct ad URL, then export the results as JSON, CSV, or a spreadsheet. This Kijiji data extractor provides a practical API alternative for collecting listing descriptions, prices, images, locations, and category details across Canadian markets.

Start with a category, location, keyword, or filtered search URL already available on the site. The scraper follows result pages, opens each public listing through the same data service used by the site, and produces one consistent row per listing. The output works for rental research, vehicle comparisons, local inventory monitoring, and other analysis of public classified ads.

### What data can you extract from Kijiji?

Each dataset row represents one listing. Search results supply the listing IDs; the detail lookup adds the full description and other fields that are absent or abbreviated on search cards. All row keys use camelCase. Fields that do not apply to a category are returned as `null` or an empty list, so a vehicle listing and a rental listing can be processed with the same columns.

| Field | Description | Example |
| --- | --- | --- |
| `id` | Stable listing identifier for deduplication | `1743448639` |
| `title` | Advertised headline | `Affordable Commercial space Crown Point for rent $995` |
| `url` | Direct public listing link | `https://www.kijiji.ca/v-commercial-office-space/.../1743448639` |
| `description` | Full public description, including HTML where present | `Great affordable opportunity...` |
| `activationDate` | Original posting time in ISO format | `2026-09-14T14:35:03.000Z` |
| `sortingDate` | Time used to order search results | `2026-09-14T14:35:03.000Z` |
| `status` | Current public listing state | `ACTIVE` |
| `endDate` | Scheduled end date when supplied | `2026-11-13T14:35:03.000Z` |
| `type` | Ad type | `OFFER` |
| `categoryId` | Numeric category identifier | `40` |
| `adSource` | Source or promotion classification | `ORGANIC` |
| `imageUrls` | Full size public image links | list of image URLs |
| `imageCount` | Number of returned image URLs | `6` |
| `priceAmount` | Raw listed amount in cents | `99500` |
| `priceCad` | Convenient dollar amount when a numeric price exists | `995` |
| `priceType` | Fixed, negotiable, contact, or another site price type | `FIXED` |
| `priceCurrency` | Currency reported by the listing | `CAD` |
| `originalPriceAmount` | Previous amount in cents if a reduction is reported | `null` |
| `attributes` | Category details with names, canonical values, and display values | `Size (sqft): 525` |
| `bedrooms` | Display bedroom count when applicable | `2` |
| `bathrooms` | Display bathroom count when applicable | `1` |
| `sizeSqft` | Advertised floor area when applicable | `525` |
| `topAd` | Top placement indicator | `true` |
| `highlight` | Highlighted ad indicator | `false` |
| `priceDrop` | Price reduction indicator | `false` |
| `showcase` | Showcase placement indicator | `false` |
| `isFromDealer` | Dealer status when reported | `false` |
| `locationId` | Site location identifier | `80014` |
| `locationName` | City or region | `Hamilton` |
| `locationAddress` | Public address displayed for the ad | `Hamilton, ON L8H` |
| `latitude`, `longitude` | Public map coordinates when available | `43.25`, `-79.79` |
| `posterId` | Public seller identifier | `78777163` |
| `sellerType` | Seller classification | `FSBO` |
| `sellerWebsiteUrl` | Public seller website when present | `null` |
| `sellerVerified` | Public seller verification flag | `false` |
| `views` | Public listing view count when supplied | `208` |
| `externalSourceProviderId` | External feed identifier when present | `null` |
| `virtualTourUrl` | Property tour link when present | `null` |
| `youtubeVideoId` | Video identifier when present | `null` |
| `productUrl` | Linked product page when present | `null` |
| `searchUrl` | Input URL that produced the row | `https://www.kijiji.ca/b-for-rent/ontario/c30349001l9004` |

`attributes` is an array of objects. Each object carries `canonicalName`, a human readable `label`, `canonicalValues`, and displayed `values`. Use the canonical name to compare the same attribute across listings, and use the displayed value for reports. For example, a bathroom may have a canonical code of `10` but a displayed value of `1`. The convenient `bedrooms`, `bathrooms`, and `sizeSqft` columns use those displayed values. Treat them as strings because some categories use nonnumeric options such as “Bachelor” or ranges.

The price distinction matters. `priceAmount` and `originalPriceAmount` are cents, while `priceCad` is the amount divided by 100. A listing marked “Please Contact” can have a `priceType` without a numeric amount. Keep `priceType` alongside any price comparison so that those listings are not mistaken for free items.

### How to scrape Kijiji

1. Open a public search results page that already represents the category, location, keyword, and filters you need. Copy its full URL. You can also copy a direct listing URL beginning with `/v-`.
2. Paste one or more URLs into `startUrls`. A search URL collects listings from that result set; a direct listing URL collects that single ad when it is publicly available.
3. Set `maxItems` to control the total number of unique rows across every input URL. Start with 30 to 100 items while checking a new market, then raise the limit for a larger collection.
4. Run the scraper and inspect the dataset. Download JSON for structured processing, CSV for a table, or a spreadsheet file for manual review.

Search URLs can target rentals, homes for sale, vehicles, furniture, jobs, services, and other public categories. The scraper respects filters already encoded in the URL, including location and price filters. A direct listing URL can be mixed with search URLs; the listing ID prevents duplicate rows within the run.

### Input

| Parameter | Type | Default | Description |
| --- | --- | --- | --- |
| `startUrls` | List of strings | Required | Public search and/or direct listing URLs on `kijiji.ca`. Search URLs are paginated. |
| `maxItems` | Integer | `100` | Maximum unique listings across all input URLs. `0` allows the crawl to continue until each search ends or reaches the page limit. |
| `proxyConfiguration` | Object | Platform proxy | Optional proxy override. The default configuration is sufficient for the tested data endpoint. |

A small Ontario rental run:

```json
{
  "startUrls": [
    "https://www.kijiji.ca/b-for-rent/ontario/c30349001l9004"
  ],
  "maxItems": 35
}
```

To investigate a narrower market, paste a search URL after setting filters on the site. This keeps the query terms and filter choices visible and reproducible. For example, select a city and a rental price range, copy the resulting URL, and rerun it on a schedule. You can pass several filtered URLs in one input, provided the combined limit is large enough to cover them. Put the most important URL first because `maxItems` applies to the combined output, in input order.

### Output example

The following selected fields are from a successful 35 item run against the Ontario rental results page. The description and image list are shortened for readability; the dataset row contains the full values and all fields listed above.

```json
{
  "id": "1743448639",
  "title": "Affordable Commercial space Crown Point for rent $995",
  "url": "https://www.kijiji.ca/v-commercial-office-space/hamilton/affordable-commercial-space-crown-point-for-rent-995/1743448639",
  "description": "Great affordable opportunity for your business. Recently renovated commercial unit fit for retail, office (not for food service). Rent is $995 a month including utilities...",
  "activationDate": "2026-09-14T14:35:03.000Z",
  "status": "ACTIVE",
  "categoryId": 40,
  "imageCount": 6,
  "priceAmount": 99500,
  "priceCad": 995,
  "priceType": "FIXED",
  "priceCurrency": "CAD",
  "sizeSqft": "525",
  "topAd": true,
  "locationName": "Hamilton",
  "locationAddress": "Hamilton, ON L8H",
  "latitude": 43.25,
  "longitude": -79.79,
  "sellerType": "FSBO",
  "views": 208,
  "searchUrl": "https://www.kijiji.ca/b-for-rent/ontario/c30349001l9004"
}
```

The example is a commercial space even though its starting URL is the broader “For Rent” category. That category includes long term rentals, rooms, commercial space, parking, and other subcategories. To get only apartments, start with an apartment category URL. Use `categoryId` and `attributes` to separate subcategories when you intentionally collect a broad search.

### Use cases

- **Rental market tracking:** Gather apartment and room ads for a chosen city each day, compare asking prices, identify new listings by `id`, and monitor whether a listing remains public. Use separate searches for different rental types when the broad category mixes them.
- **Vehicle research:** Export vehicle ads from a category and location, compare listed prices, and retain vehicle specific entries from `attributes`. A search URL with the make, model, or price filter already selected can narrow the result set.
- **Local inventory monitoring:** Collect public ads for furniture, electronics, or equipment in several cities. Deduplicate by `id` and keep `activationDate` and `sortingDate` to distinguish newly posted ads from promoted ads that appear near the top.
- **Property comparisons:** Build a table of homes for sale with price, location, images, floor area, and public tour links. Category attributes can vary between an owner ad and an imported listing, so preserve the original attribute list.
- **Service discovery:** Review public service ads within a region and group them by title, category, seller classification, and location. Use the listing URL to verify any item before acting on it.
- **Scheduled change reports:** Repeat a saved search URL, compare current IDs and prices with an earlier dataset, and produce counts of new, removed, or repriced listings. A fresh run reports current public data; it does not generate historical changes by itself.

### How much does it cost to scrape Kijiji?

The configured result price is **$0.76 per 1,000 dataset items**, or $0.00076 per returned listing. Billing follows delivered items, not the number of input URLs. A direct URL that produces one row costs the same per row as a row discovered through search. The platform usage for a pay per result run is included in that event price; the amount shown at checkout is the definitive price if this actor's pricing changes.

| Returned listings | Result charge at $0.76 per 1,000 |
| ---: | ---: |
| 35 | $0.0266 |
| 1,000 | $0.76 |
| 5,000 | $3.80 |

These are examples of result charges, not a promise that every search can return the requested number. A narrow query might contain fewer ads. Some ads can disappear between search discovery and detail retrieval. The scraper only adds a row after its public detail record is available, so the final count can be lower than `maxItems`. The successful 35 item verification run completed in about 37 seconds; longer runs take more time because each listing needs its detail lookup. Site response time, retry attempts, and proxy availability can change the duration.

### Tips for best results

- Start with a current search URL copied from the site. A URL with a category and location is easier to audit than a broad national search, and its filters remain visible in the saved input.
- Use more specific locations, subcategories, and site filters for large result sets. A search can report tens of thousands of matching ads, while a single run traverses at most 250 pages per input URL. Separate filters can cover different parts of a large market.
- Set a realistic `maxItems`. The default 100 is enough to inspect field quality and category mix. Raise it after confirming that the search really represents the listings you want.
- Expect promoted top listings to recur on result pages. The scraper deduplicates within a run by listing ID, so they do not consume multiple output rows. A promoted ad may be older than nearby organic results; use dates and promotion flags when interpreting order.
- Preserve both price fields. `priceCad` is convenient for tables, while `priceAmount` reproduces the site's integer amount. Check `priceType` before calculating averages so contact price ads do not enter a numeric comparison as zero.
- Save the exact input URL with each dataset. `searchUrl` records which start URL led to a listing, which helps when several categories or cities are collected in one run.

### Limits

The scraper uses only public listing data. It does not sign in, send seller messages, expose private contact channels, or fetch listings that the public detail service no longer provides. Some descriptions may contain HTML because that is how the listing is published. Seller supplied text can contain claims or errors; verify important facts on the listing itself.

A search result page currently yields up to 40 ordinary listings plus promoted positions. Pagination is represented by `/page-N/` in the search URL. The scraper follows that sequence until it reaches `maxItems`, the reported end of results, an empty page, or 250 pages for that input URL. Therefore a very large broad category may require separate category, location, keyword, or price slices to cover more than the first 10,000 ordinary positions. Page counts and filters can change as ads are posted or removed during a run.

Some fields are inherently category specific. A room rental may have a bedroom count; an electronics ad may not. A public map can provide approximate coordinates instead of an exact street address. A private seller may have no website. View counts, original prices, videos, tours, and external source identifiers appear only where the public record supplies them. Empty fields should be treated as unknown or inapplicable, not as negative answers.

### Use in automated workflows

An automated workflow can call this actor with a saved search URL and a result limit, then consume the dataset rows. Two useful instructions for a workflow are:

1. “Collect the latest 100 public rental listings for this city search URL, then group the rows by `categoryId` and summarize the median numeric `priceCad` for each category.”
2. “Run these three saved vehicle search URLs each morning, compare `id` with yesterday's rows, and report new ads with a numeric price and a direct `url`.”

For stable comparisons, retain the full input URL, run time, and listing ID with each snapshot. Listing IDs identify ads; titles and prices can change. Sorting dates are useful context, but they are not a substitute for storing your own observation time.

### FAQ

#### Is it legal to collect these listings?

The actor reads public classified data. Your use still needs to respect site terms, applicable privacy law, and the rights of people who placed ads. Collect only what you need, limit retention where appropriate, and avoid using seller supplied information for unwanted contact or personal profiling.

#### Do I need to provide proxies?

No. The default platform proxy is configured automatically. The actor starts with the lower cost proxy route and can change route after repeated blocks. Keep the proxy input empty unless you have a specific approved setup to use.

#### Can I provide a single listing instead of a search?

Yes. Add a direct `/v-` listing URL to `startUrls`. If its public detail record is available, it produces one row. You can mix direct and search URLs, with `maxItems` applying to their combined output.

#### Why is a price or location field empty?

Some ads invite buyers to contact the seller for a price, and some do not publish a precise map position. Category details also vary. The actor keeps those fields empty instead of inventing a value; inspect `priceType`, `attributes`, and the listing URL for context.

#### How quickly can a run finish?

The 35 item verification run took about 37 seconds. Each result requires a detail lookup, so a 1,000 item run takes longer. Time varies with the data service and any retries. Use a smaller limit when testing a new query.

#### Can I schedule the same search or compare runs?

Yes. Save the input URL and run it on a schedule. Compare the resulting `id` values and numeric prices with a prior export. The actor returns a current snapshot; change detection belongs in the workflow that stores and compares those snapshots.

#### Can I export to a spreadsheet?

Yes. Download a table format from the dataset. Nested `attributes` and image lists remain structured in JSON; for spreadsheet analysis, the dedicated columns such as `priceCad`, `locationName`, `bedrooms`, and `sizeSqft` are easiest to use.

### Integrations

The dataset can be read through an API, downloaded for a spreadsheet, sent by a webhook, or passed to a scheduled reporting workflow. Use `id` as the join key when merging runs and `searchUrl` to retain query provenance. For category specific analysis, unpack `attributes` only after deciding which category or attribute names matter to the report.

### Support

Open an issue on the Issues tab with the input URL, the run time, and a brief description of the missing field or unexpected result. Include a public listing URL when a specific ad illustrates the problem. We reply within 24 hours and consider requests for additional public fields.

### Use with AI agents (MCP)

Add this actor to any MCP client (Claude, Cursor, VS Code, n8n and others) with one URL:

`https://mcp.apify.com?tools=mlg14/kijiji-scraper`

The actor returns one dataset item per Kijiji listing: title, full description, price, images, category attributes, location, seller type and status. Set `maxItems` to keep results bounded, and check for an empty dataset when a search URL has no matching listings.

**Prompt 1:** "Get 20 rental listings in Ontario from Kijiji."

```json
{
  "startUrls": ["https://www.kijiji.ca/b-for-rent/ontario/c30349001l9004"],
  "maxItems": 20
}
```

**Prompt 2:** "Collect 10 listings from two Kijiji searches to compare prices."

```json
{
  "startUrls": [
    "https://www.kijiji.ca/b-for-rent/ontario/c30349001l9004",
    "https://www.kijiji.ca/b-for-rent/ontario/c30349001l9004/page-2/"
  ],
  "maxItems": 10
}
```

**Prompt 3:** "Fetch the full details of this single Kijiji listing."

```json
{
  "startUrls": ["https://www.kijiji.ca/v-commercial-office-space/hamilton/affordable-commercial-space-crown-point-for-rent-995/1743448639"],
  "maxItems": 1
}
```

# Actor input Schema

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

Kijiji search result URLs or single listing URLs (kijiji.ca/b-... or /v-...). Search URLs can include category, location, keyword and filters; pagination is automatic. e.g. https://www.kijiji.ca/b-for-rent/ontario/c30349001l9004. Use one URL per search you want to scrape.

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

Maximum unique listings across all start URLs, whole number. e.g. 50 for a quick sample. Set 0 to crawl until each search ends or reaches its first 250 pages. Use a small value for tests to keep cost low.

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

Apify Proxy is used by default. Change this only if you need your own proxy configuration.

## Actor input object example

```json
{
  "startUrls": [
    "https://www.kijiji.ca/b-for-rent/ontario/c30349001l9004"
  ],
  "maxItems": 100,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

Collected public listings in the default dataset.

# 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 = {
    "startUrls": [
        "https://www.kijiji.ca/b-for-rent/ontario/c30349001l9004"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("mlg14/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 = { "startUrls": ["https://www.kijiji.ca/b-for-rent/ontario/c30349001l9004"] }

# Run the Actor and wait for it to finish
run = client.actor("mlg14/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 '{
  "startUrls": [
    "https://www.kijiji.ca/b-for-rent/ontario/c30349001l9004"
  ]
}' |
apify call mlg14/kijiji-scraper --silent --output-dataset

```

## MCP server setup

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