# Kijiji Scraper (Cheap) (`data_api/kijiji-scraper-cheap`) Actor

Kijiji Listing Extractor collects real estate, vehicle, and classified ads from Kijiji.ca. It gathers listing prices, images, location coordinates, and technical specifications for market research, price comparisons, and lead generation.

- **URL**: https://apify.com/data\_api/kijiji-scraper-cheap.md
- **Developed by:** [Data API](https://apify.com/data_api) (community)
- **Categories:** Lead generation, Real estate, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.99 / 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/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/docs.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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

![Kijiji Scraper](cover.jpg)

Kijiji is full of fresh classifieds, but there's no clean way to get them into a spreadsheet. Copying ads one at a time is slow, and the price, location, and photos are scattered across the page. This scraper handles the collecting: paste a Kijiji browse URL or a single ad link, and it walks the pages and hands back one tidy row per ad — title, asking price, city, coordinates, photo links, and whatever category specs the seller filled in. Works on cars, real estate, jobs, or anything else posted to the board.

### What you get

Each ad comes back as a single row with a steady set of columns, so results load straight into a sheet or database without reshaping. The fields split into a few groups:

- **Ad basics** — `adId`, `adTitle`, `adDescription`, `adUrl`, `categoryCode`
- **Price** — `askingPrice`, `priceKind`, `currencyCode`
- **Location** — `cityName`, `fullAddress`, `geoLat`, `geoLng`
- **Photos** — `photoCount`, `photoLinks`
- **Specs and timing** — `itemSpecs`, `postedDate`, `rankingDate`, `placementType`, `collectedAt`

### Quick start

1. Click **Try for free** and open the input form.
2. Paste one or more Kijiji URLs into **Kijiji URLs** — a category or search page to sweep many ads, or a single ad page for one record.
3. Set a **Results limit** to cap how many ads you collect.
4. Hit **Start**, then download the dataset as JSON, CSV, Excel, or XML when the run finishes.

![How it works](how-it-works.jpg)

### Use cases

- **Car market research** — track asking prices, mileage, and model years across a region to spot fair deals
- **Real estate monitoring** — follow rental and sale listings in a neighborhood and watch how prices move
- **Competitor pricing** — see what local sellers and dealers charge so you can position your own listings
- **Lead generation** — catch new ads that match your keywords as soon as they post
- **Market sizing** — count supply and gauge demand by category and city before you enter a market
- **Price history** — run the scraper on a schedule and build your own record of how listings change over time

### Input

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `sourceUrls` | array of objects | Yes | Kijiji category, search, or single-ad URLs to pull from. A browse URL walks every page; an ad URL returns one record. |
| `resultsLimit` | integer | No | Stop after saving this many ads across all URLs. Default `25`; max `1000`. |
| `timeoutSeconds` | integer | No | Seconds to wait on each page request before giving up. Default `45`. |

#### Example input

```json
{
    "sourceUrls": [
        { "url": "https://www.kijiji.ca/b-cars-trucks/canada/c174l0" }
    ],
    "resultsLimit": 25,
    "timeoutSeconds": 45
}
````

### Output

Every ad becomes one row. Fields that an ad doesn't carry come back empty rather than dropping out, so your columns stay consistent across the whole dataset.

#### Example output

```json
{
    "adId": "1738543866",
    "adTitle": "1974 Chevy C50 Tow Truck",
    "adDescription": "Chevy C50 Custom 1974. 350 engine, manual transmission, hydraulic winch. Seats 3, radio, recently serviced.",
    "adUrl": "https://www.kijiji.ca/v-classic-cars/sherbrooke-qc/chevy-c50-towing/1738543866",
    "categoryCode": 122,
    "photoCount": 10,
    "photoLinks": [
        "https://media.kijiji.ca/api/v1/ca-prod-fsbo-ads/images/eb/eb34ebec-c03a-4973-a34c-3f15558e2889?rule=kijijica-200-jpg"
    ],
    "postedDate": "2026-06-02T00:27:35.000Z",
    "rankingDate": "2026-06-05T00:30:46.000Z",
    "placementType": "TOP_AD",
    "cityName": "Sherbrooke",
    "fullAddress": "Lac-Mégantic, QC, G6B 1R1",
    "geoLat": 45.58221,
    "geoLng": -70.89756,
    "askingPrice": 11500.0,
    "priceKind": "FIXED",
    "currencyCode": "CAD",
    "itemSpecs": {
        "carmake": "chevrolet",
        "carmodel": "othrmdl",
        "caryear": "1974",
        "carmileageinkms": "78000",
        "cartransmission": "1",
        "carbodytype": "pickuptruck",
        "carfueltype": "gas",
        "carcolor": "gray",
        "drivetrain": "rwd",
        "noofdoors": "2",
        "noofseats": "3"
    },
    "collectedAt": "2026-06-07T04:20:00.000Z",
    "errorMessage": null
}
```

#### Output fields

| Field | Type | Description |
|-------|------|-------------|
| `adId` | string | Kijiji's own identifier for the ad |
| `adTitle` | string | Headline the seller gave the ad |
| `adDescription` | string | Body text or summary from the ad |
| `adUrl` | string | Link to the ad page on Kijiji |
| `categoryCode` | integer | Numeric code for the Kijiji category |
| `photoCount` | integer | How many photos the seller attached |
| `photoLinks` | array of strings | Image URLs pulled from the ad |
| `postedDate` | string | When the ad went live (ISO 8601) |
| `rankingDate` | string | Timestamp Kijiji uses to order the ad (ISO 8601) |
| `placementType` | string | Ad placement, such as TOP\_AD or ORGANIC |
| `cityName` | string | City or town tied to the ad |
| `fullAddress` | string | Street-level address when the ad has one |
| `geoLat` | number | Latitude of the ad location |
| `geoLng` | number | Longitude of the ad location |
| `askingPrice` | number | Listed price as a number, in CAD |
| `priceKind` | string | Pricing style: FIXED, CONTACT, FREE, or SWAP |
| `currencyCode` | string | Currency for the price, usually CAD |
| `itemSpecs` | object | Flat map of category-specific details like make, model, year, mileage |
| `collectedAt` | string | Timestamp marking when the row was captured |
| `errorMessage` | string | Reason a page failed; `null` on success |

### Tips for best results

- **Test with a small limit first.** Set `resultsLimit` to 10–20 to confirm the output fits your pipeline before you run a full sweep.
- **Use browse URLs to go wide.** A category or search page (the ones with `/b-` in the URL) walks through page after page on its own, up to your limit.
- **Use ad URLs to go deep.** Paste a single ad link (the `/v-` URLs) when you only want one specific record.
- **Raise `timeoutSeconds` on slow runs.** If you see timeout errors, push it toward 60–90 seconds to give each page more room.
- **Specs vary by category.** `itemSpecs` reflects whatever the seller entered, so a car ad carries make and mileage while a rental ad carries different keys.

### How can I use Kijiji listing data?

**How can I use the Kijiji Scraper to track car prices across Canada?**
Paste a vehicle category URL, set `resultsLimit` to the batch you want, and the scraper returns each ad's asking price, model year, mileage, and city. Group the rows by make or region to benchmark prices and flag deals that sit below the going rate.

**How can I export Kijiji real estate listings to a spreadsheet?**
Point it at a rental or for-sale browse URL and run it. Every ad comes back as one row with the title, price, address, coordinates, and photo links, ready to download as CSV or Excel and drop into your own housing analysis.

**How can I collect Kijiji ads that match specific keywords for lead generation?**
Build a Kijiji search URL with your keywords and paste it in. The scraper pulls the matching ads with their descriptions, prices, and locations, so you can pick out fresh offers and follow up while they're still live.

**How can I monitor Kijiji listings over time?**
Schedule the scraper to run on a recurring basis with the same source URLs. Each run captures a `collectedAt` timestamp, so stacking the datasets gives you a price-and-supply history you can chart however you like.

### Is it legal to scrape data?

Our actors are ethical and do not extract any private user data, such as email addresses or private contact information. They only extract what the user has chosen to share publicly. We therefore believe that our actors, when used for ethical purposes by Apify users, are safe.

However, you should be aware that your results could contain personal data. Personal data is protected by the GDPR in the European Union and by other regulations around the world. You should not scrape personal data unless you have a legitimate reason to do so. If you're unsure whether your reason is legitimate, consult your lawyers.

You can also read Apify's blog post on the [legality of web scraping](https://blog.apify.com/is-web-scraping-legal/).

### Support

Questions, feature requests, or a field you'd like added? Reach out at <data.apify@proton.me> and we'll get back to you.

# Actor input Schema

## `sourceUrls` (type: `array`):

Kijiji category, search-result, or single-ad pages you want to pull listings from. Paste a browse URL to walk every page, or a single ad URL for one record.

## `resultsLimit` (type: `integer`):

Stop once this many listings have been saved across all source URLs. Keep it low for quick test runs, raise it for a full sweep.

## `timeoutSeconds` (type: `integer`):

How long to wait on each page request before giving up. Bump it up if you see frequent timeouts on slower connections.

## Actor input object example

```json
{
  "sourceUrls": [
    {
      "url": "https://www.kijiji.ca/b-cars-trucks/canada/c174l0"
    }
  ],
  "resultsLimit": 25,
  "timeoutSeconds": 45
}
```

# 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 = {
    "sourceUrls": [
        {
            "url": "https://www.kijiji.ca/b-cars-trucks/canada/c174l0"
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("data_api/kijiji-scraper-cheap").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 = { "sourceUrls": [{ "url": "https://www.kijiji.ca/b-cars-trucks/canada/c174l0" }] }

# Run the Actor and wait for it to finish
run = client.actor("data_api/kijiji-scraper-cheap").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 '{
  "sourceUrls": [
    {
      "url": "https://www.kijiji.ca/b-cars-trucks/canada/c174l0"
    }
  ]
}' |
apify call data_api/kijiji-scraper-cheap --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Kijiji Scraper (Cheap)",
        "description": "Kijiji Listing Extractor collects real estate, vehicle, and classified ads from Kijiji.ca. It gathers listing prices, images, location coordinates, and technical specifications for market research, price comparisons, and lead generation.",
        "version": "0.0",
        "x-build-id": "iSz0GnrVgsKOuRgMK"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/data_api~kijiji-scraper-cheap/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-data_api-kijiji-scraper-cheap",
                "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/data_api~kijiji-scraper-cheap/runs": {
            "post": {
                "operationId": "runs-sync-data_api-kijiji-scraper-cheap",
                "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/data_api~kijiji-scraper-cheap/run-sync": {
            "post": {
                "operationId": "run-sync-data_api-kijiji-scraper-cheap",
                "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",
                "required": [
                    "sourceUrls"
                ],
                "properties": {
                    "sourceUrls": {
                        "title": "Kijiji URLs",
                        "type": "array",
                        "description": "Kijiji category, search-result, or single-ad pages you want to pull listings from. Paste a browse URL to walk every page, or a single ad URL for one record.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "resultsLimit": {
                        "title": "Results limit",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Stop once this many listings have been saved across all source URLs. Keep it low for quick test runs, raise it for a full sweep.",
                        "default": 25
                    },
                    "timeoutSeconds": {
                        "title": "Timeout (seconds)",
                        "minimum": 5,
                        "maximum": 120,
                        "type": "integer",
                        "description": "How long to wait on each page request before giving up. Bump it up if you see frequent timeouts on slower connections.",
                        "default": 45
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
