# Kijiji Canada Scraper (`automation-lab/kijiji-scraper`) Actor

Extract classified listings from Kijiji.ca. Scrape real estate, cars, jobs, and buy/sell listings with prices, descriptions, images, seller info, and GPS coordinates. Export to JSON, CSV, or Excel. Schedule daily runs.

- **URL**: https://apify.com/automation-lab/kijiji-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Lead generation, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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.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 Canada Scraper

### What does Kijiji Canada Scraper do?

**Kijiji Canada Scraper** extracts classified listings from [Kijiji.ca](https://www.kijiji.ca), Canada's largest online classifieds marketplace. Scrape **real estate rentals, cars and trucks, buy & sell items, jobs, services, and pets** from any city or province in Canada.

The scraper uses **pure HTTP requests** (no browser), making it fast and cost-effective. It parses Kijiji's structured data directly, extracting **titles, prices, descriptions, images, seller info, location coordinates, and category-specific attributes** (bedrooms, mileage, condition, etc.).

Try it now — click **Start** with the prefilled input to scrape Toronto apartment listings.

### Who is Kijiji Canada Scraper for?

🏠 **Real estate investors and property managers**
- Monitor rental prices across Canadian cities
- Track new apartment and condo listings in real time
- Analyze rental market trends by neighbourhood

🚗 **Car dealers and buyers**
- Track used car prices by make, model, and location
- Find underpriced vehicles before competitors
- Build a database of dealer inventory across provinces

📊 **Market researchers and data analysts**
- Analyze pricing trends for consumer goods across Canada
- Study regional demand patterns for different product categories
- Build datasets for machine learning or reporting

🛍️ **Resellers and deal hunters**
- Find deals on electronics, furniture, and collectibles
- Set up automated monitoring for specific keywords
- Compare prices across different Canadian cities

💼 **Recruiters and HR teams**
- Monitor job postings across industries in Canada
- Track salary ranges and hiring trends by location
- Analyze competitor job listings

### Why use Kijiji Canada Scraper?

- ⚡ **Fast and affordable** — pure HTTP scraper, no browser overhead. Scrape 100 listings for ~$0.30
- 🔄 **Schedule and automate** — run on a daily/weekly schedule to monitor new listings
- 📋 **Rich structured data** — prices, coordinates, seller info, and all category-specific attributes
- 🌍 **All of Canada** — any city, province, or category on Kijiji.ca
- 🔗 **API access** — integrate with Google Sheets, Slack, Zapier, Make, and 5,000+ apps
- 📦 **Multiple export formats** — JSON, CSV, Excel, XML, HTML
- 🔑 **No login or API key needed** — scrapes public listing data only
- 🖼️ **Full-size images** — automatically upgrades thumbnail URLs to high-resolution versions

### What data can you extract from Kijiji?

Each listing includes these fields:

| Field | Type | Description |
|-------|------|-------------|
| `adId` | string | Unique Kijiji listing ID |
| `title` | string | Listing title |
| `description` | string | Full listing description |
| `price` | string | Display price ("$1,200.00", "Free", "Please Contact") |
| `priceAmount` | number | Numeric price in CAD (null if not applicable) |
| `currency` | string | Always "CAD" |
| `category` | string | Listing category (e.g., "Cars & Trucks", "Apartments & Condos") |
| `location` | string | City or area name |
| `address` | string | Street address (when available) |
| `latitude` | number | GPS latitude |
| `longitude` | number | GPS longitude |
| `postedDate` | string | Date the listing was posted (ISO format) |
| `url` | string | Direct link to the listing |
| `imageUrls` | array | High-resolution image URLs |
| `sellerName` | string | Seller display name |
| `sellerType` | string | Seller type (Owner, Dealer) |
| `adType` | string | Ad type (ORGANIC, TOP_AD) |
| `attributes` | object | Category-specific attributes (bedrooms, mileage, year, etc.) |
| `scrapedAt` | string | Timestamp when the data was extracted |

#### Category-specific attributes examples

🏠 **Real estate**: bedrooms, bathrooms, unit type, parking, pet-friendly, laundry, air conditioning, move-in date

🚗 **Cars**: year, make, model, mileage, transmission, drivetrain, fuel type, body type, colour, number of seats

🛍️ **Buy & Sell**: condition, brand, model

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

This actor uses **pay-per-event** pricing — you only pay for what you scrape. No monthly subscription. All platform costs are **included**.

| | Free | Starter ($29/mo) | Scale ($199/mo) | Business ($999/mo) |
|---|---|---|---|---|
| **Per listing** | $0.00345 | $0.003 | $0.00234 | $0.0018 |
| **100 listings** | $0.35 | $0.30 | $0.23 | $0.18 |
| **1,000 listings** | $3.45 | $3.00 | $2.34 | $1.80 |

Higher-tier plans get additional volume discounts.

**Real-world cost examples:**

| Query | Listings | Duration | Cost (Free tier) |
|---|---|---|---|
| Toronto apartments (20 listings with details) | 20 | ~30s | ~$0.07 |
| Honda Civic search across Canada (50 listings) | 50 | ~15s | ~$0.18 |
| Buy & sell electronics Ottawa (100 listings) | 100 | ~25s | ~$0.35 |

On the free plan ($5 credits), you can scrape approximately **1,400 listings**.

### How to scrape Kijiji listings

1. Go to the [Kijiji Canada Scraper](https://apify.com/automation-lab/kijiji-scraper) page on Apify Store
2. Click **Start** to try with prefilled Toronto apartment listings
3. Or customize your search:
   - Paste a Kijiji URL directly into **Kijiji URLs**
   - Or use **Search keywords**, **Category**, and **Location** to build a query
4. Set **Max listings** to control how many results to scrape
5. Enable **Include full details** for complete descriptions and attributes
6. Click **Start** and wait for results
7. Download your data as JSON, CSV, Excel, or connect via API

#### Example: Scrape Toronto car listings

```json
{
    "category": "cars-vehicles",
    "location": "city-of-toronto",
    "maxListings": 50,
    "includeDetails": true
}
````

#### Example: Search for specific items

```json
{
    "searchQuery": "macbook pro",
    "category": "buy-sell",
    "location": "vancouver",
    "maxListings": 30,
    "includeDetails": false
}
```

#### Example: Scrape from a direct URL

```json
{
    "startUrls": [
        { "url": "https://www.kijiji.ca/b-jobs/city-of-toronto/c45l1700273" }
    ],
    "maxListings": 100,
    "includeDetails": true
}
```

### Input parameters

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `startUrls` | array | — | Direct Kijiji search or category page URLs |
| `searchQuery` | string | — | Keywords to search for |
| `category` | string | All | Category filter (buy-sell, cars-vehicles, real-estate, jobs, services, pets, community, vacation-rentals) |
| `location` | string | — | Location slug from Kijiji URLs (e.g., city-of-toronto, vancouver, alberta) |
| `maxListings` | integer | 100 | Maximum number of listings to extract (1-5000) |
| `includeDetails` | boolean | true | Fetch detail pages for full descriptions and attributes |

### Output example

```json
{
    "adId": "1734239942",
    "title": "1, 2 AND 3 BEDROOM APARTMENTS AVAILABLE",
    "description": "ONE MONTH FREE RENT PROMO! Welcome to Royal Palace Apartments...",
    "price": "$1,700.00",
    "priceAmount": 1700,
    "currency": "CAD",
    "category": "Apartments & Condos",
    "location": "Toronto",
    "address": "3827 Lawrence Ave E, Scarborough, ON",
    "latitude": 43.76837,
    "longitude": -79.29991,
    "postedDate": "2026-03-10T14:40:15.000Z",
    "url": "https://www.kijiji.ca/v-apartments-condos/city-of-toronto/1-2-and-3-bedroom-apartments-available/1734239942",
    "imageUrls": [
        "https://media.kijiji.ca/api/v1/ca-prod-fsbo-ads/images/39/391a8292-a3aa-4e3c-ba29-2c1fe7090ed0?rule=kijijica-960-jpg"
    ],
    "sellerName": null,
    "sellerType": null,
    "adType": "TOP_AD",
    "attributes": {
        "Unit Type": "Apartment",
        "Bedrooms": "1",
        "Bathrooms": "1",
        "Pet Friendly": "Yes",
        "Parking Included": "Yes",
        "Agreement Type": "1 Year"
    },
    "scrapedAt": "2026-03-30T05:30:00.000Z"
}
```

### Tips for best results

- 🎯 **Start small** — use the prefilled input (20 listings) to test before running large jobs
- 📍 **Use specific locations** — narrow by city for more relevant results. Find location slugs in Kijiji URLs
- 🔍 **Combine search + category** — search within a category for more targeted results
- ⏱️ **Skip details for speed** — disable "Include full details" when you only need titles and prices. This is ~3x faster
- 📅 **Schedule daily runs** — set up a recurring schedule to monitor new listings automatically
- 💰 **Optimize costs** — without detail pages, scraping is cheaper and faster. Use detail pages only when you need full descriptions
- 🔗 **Use direct URLs** — paste Kijiji search URLs with filters (price range, sort order) already applied for precise results

### Integrations

🔄 **Kijiji to Google Sheets** — export rental listings to a spreadsheet for market analysis. Set up a daily schedule to track new apartments in your target neighbourhood.

📱 **Kijiji to Slack/Discord** — get instant alerts when new listings matching your criteria appear. Perfect for deal hunting or competitive monitoring.

⚡ **Kijiji to Zapier/Make** — build automated workflows: new car listing appears → check price against your budget → send notification → add to database.

📊 **Scheduled monitoring** — run the scraper on a daily schedule and compare datasets to identify new listings, price changes, and removed ads.

🔗 **Webhooks** — trigger your own API endpoint when scraping completes for real-time data processing.

### Using the Apify API

#### Node.js

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

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

const run = await client.actor('automation-lab/kijiji-scraper').call({
    category: 'real-estate',
    location: 'city-of-toronto',
    maxListings: 100,
    includeDetails: true,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient('YOUR_API_TOKEN')

run = client.actor('automation-lab/kijiji-scraper').call(run_input={
    'category': 'real-estate',
    'location': 'city-of-toronto',
    'maxListings': 100,
    'includeDetails': True,
})

items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

#### cURL

```bash
curl -X POST "https://api.apify.com/v2/acts/automation-lab~kijiji-scraper/runs?token=YOUR_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "category": "cars-vehicles",
    "location": "vancouver",
    "maxListings": 50,
    "includeDetails": true
  }'
```

### Use with AI agents via MCP

Kijiji Canada Scraper is available as a tool for AI assistants that support the [Model Context Protocol (MCP)](https://docs.apify.com/platform/integrations/mcp).

Add the Apify MCP server to your AI client — this gives you access to all Apify actors, including this one:

#### Setup for Claude Code

```bash
claude mcp add --transport http apify "https://mcp.apify.com?tools=automation-lab/kijiji-scraper"
```

#### Setup for Claude Desktop, Cursor, or VS Code

Add this to your MCP config file:

```json
{
    "mcpServers": {
        "apify": {
            "url": "https://mcp.apify.com?tools=automation-lab/kijiji-scraper"
        }
    }
}
```

Your AI assistant will use OAuth to authenticate with your Apify account on first use.

#### Example prompts

Once connected, try asking your AI assistant:

- "Use automation-lab/kijiji-scraper to find 2-bedroom apartments under $2,000/month in downtown Toronto"
- "Search Kijiji for used Honda Civic listings in Vancouver and compare prices"
- "Monitor Kijiji Ottawa for new MacBook Pro listings under $1,500"

Learn more in the [Apify MCP documentation](https://docs.apify.com/platform/integrations/mcp).

### Is it legal to scrape Kijiji?

This actor scrapes only **publicly available data** from Kijiji.ca — the same information any visitor can see without logging in. It does not access private accounts, bypass authentication, or collect personal data beyond what sellers publicly display.

Web scraping of public data is generally legal, as confirmed by the US Ninth Circuit Court ruling in *HiQ Labs v. LinkedIn*. However, always comply with applicable laws in your jurisdiction and use the data responsibly.

For more information, see Apify's [guide to ethical web scraping](https://blog.apify.com/is-web-scraping-legal/).

### FAQ

**How fast is Kijiji Canada Scraper?**

Without detail pages, the scraper processes approximately 40 listings per second (one page fetch). With detail pages enabled, it processes about 3-5 listings per second due to individual page fetches. A typical run of 100 listings with details takes about 30-45 seconds.

**How much does it cost to monitor Kijiji daily?**

A daily run scraping 50 new listings with details costs about $0.17 on the Free plan. That's roughly $5/month — well within the free plan's $5 monthly credit.

**Does it work for all Canadian cities?**

Yes. The scraper works with any location on Kijiji.ca. Use the location slug from any Kijiji URL (e.g., "city-of-toronto", "calgary", "montreal", "vancouver", "edmonton", "winnipeg", "halifax", "alberta", "british-columbia").

**Why are some description fields short?**

If you disable "Include full details", descriptions are truncated (~200 characters) as they appear on the search page. Enable full details to get complete descriptions from each listing's detail page.

**Why do some listings show "Please Contact" instead of a price?**

Some Kijiji sellers choose not to display a price. The `price` field shows the display text, and `priceAmount` will be `null` for these listings. You can filter these out in post-processing.

**Why are results from outside my chosen location appearing?**

Kijiji shows promoted/featured ads from across Canada at the top of search results. These are marked with `adType: "TOP_AD"`. Filter by the `location` field in your results to get only local listings.

### Other classifieds and marketplace scrapers

- 🛒 [Poshmark Scraper](https://apify.com/automation-lab/poshmark-scraper) — scrape Poshmark fashion listings
- 🛍️ [Newegg Scraper](https://apify.com/automation-lab/newegg-scraper) — extract electronics and computer products
- 🏠 [Greenhouse Jobs Scraper](https://apify.com/automation-lab/greenhouse-jobs-scraper) — scrape job listings from Greenhouse

# Actor input Schema

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

Add Kijiji search or category page URLs to scrape. Paste any kijiji.ca listing page URL.

## `searchQuery` (type: `string`):

Enter keywords to search for on Kijiji (e.g., 'iphone', '2 bedroom apartment', 'honda civic').

## `category` (type: `string`):

Select a Kijiji category to search in.

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

Enter a Kijiji location slug (e.g., 'city-of-toronto', 'ottawa', 'vancouver', 'alberta'). Find slugs in Kijiji URLs.

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

Maximum number of listings to scrape. Each listing costs ~$0.003.

## `includeDetails` (type: `boolean`):

Fetch each listing's detail page for full description, all attributes, and seller info. Slower but more complete data.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.kijiji.ca/b-apartments-condos/city-of-toronto/c37l1700273"
    }
  ],
  "category": "",
  "location": "city-of-toronto",
  "maxListings": 20,
  "includeDetails": true
}
```

# Actor output Schema

## `overview` (type: `string`):

No description

# 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": [
        {
            "url": "https://www.kijiji.ca/b-apartments-condos/city-of-toronto/c37l1700273"
        }
    ],
    "searchQuery": "",
    "category": "",
    "location": "city-of-toronto",
    "maxListings": 20,
    "includeDetails": true
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/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": [{ "url": "https://www.kijiji.ca/b-apartments-condos/city-of-toronto/c37l1700273" }],
    "searchQuery": "",
    "category": "",
    "location": "city-of-toronto",
    "maxListings": 20,
    "includeDetails": True,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/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 '{
  "startUrls": [
    {
      "url": "https://www.kijiji.ca/b-apartments-condos/city-of-toronto/c37l1700273"
    }
  ],
  "searchQuery": "",
  "category": "",
  "location": "city-of-toronto",
  "maxListings": 20,
  "includeDetails": true
}' |
apify call automation-lab/kijiji-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Kijiji Canada Scraper",
        "description": "Extract classified listings from Kijiji.ca. Scrape real estate, cars, jobs, and buy/sell listings with prices, descriptions, images, seller info, and GPS coordinates. Export to JSON, CSV, or Excel. Schedule daily runs.",
        "version": "0.1",
        "x-build-id": "pHcXRpyhI4gbC5Bl8"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~kijiji-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-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/automation-lab~kijiji-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-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/automation-lab~kijiji-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-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": {
                    "startUrls": {
                        "title": "Kijiji URLs",
                        "type": "array",
                        "description": "Add Kijiji search or category page URLs to scrape. Paste any kijiji.ca listing page URL.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "searchQuery": {
                        "title": "Search keywords",
                        "type": "string",
                        "description": "Enter keywords to search for on Kijiji (e.g., 'iphone', '2 bedroom apartment', 'honda civic')."
                    },
                    "category": {
                        "title": "Category",
                        "enum": [
                            "",
                            "buy-sell",
                            "cars-vehicles",
                            "real-estate",
                            "jobs",
                            "services",
                            "pets",
                            "community",
                            "vacation-rentals"
                        ],
                        "type": "string",
                        "description": "Select a Kijiji category to search in.",
                        "default": ""
                    },
                    "location": {
                        "title": "Location",
                        "type": "string",
                        "description": "Enter a Kijiji location slug (e.g., 'city-of-toronto', 'ottawa', 'vancouver', 'alberta'). Find slugs in Kijiji URLs."
                    },
                    "maxListings": {
                        "title": "Max listings",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Maximum number of listings to scrape. Each listing costs ~$0.003.",
                        "default": 100
                    },
                    "includeDetails": {
                        "title": "Include full details",
                        "type": "boolean",
                        "description": "Fetch each listing's detail page for full description, all attributes, and seller info. Slower but more complete data.",
                        "default": true
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
