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

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

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

## Pricing

from $1.00 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/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.ca Scraper

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

### Why this scraper

- Covers all of Kijiji.ca, not just one vertical. The extractor adapts to property, vehicles, and general classifieds automatically.
- Rich records out of the box: 30+ fields from the search page alone, including full description, all image URLs, and GPS coordinates.
- Optional detail enrichment adds view counts, seller phone and website, listing status, virtual tour or video, and dealer profile.
- Two ways in: keyword + location search (any Canadian city, region, or province), or paste Kijiji URLs directly.
- Price and sort filters, with forward pagination across as many pages as you want.
- Resilient connection handling: rotates to a fresh exit IP on rejection and fails over to a backup gateway.

### Data you get

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

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

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

### How to use

Search a single keyword in one city:

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

Search with price filter and newest-first sort:

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

Browse every listing in a location (no keyword):

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

Paste Kijiji URLs directly (multiple supported):

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

### Input parameters

| Parameter | Type | Default | Description |
| --- | --- | --- | --- |
| mode | string | "search" | "search" for keyword + location, "url" to paste links. |
| keywords | array | \["iphone"] | Search terms (search mode). Each runs as its own all-category search. Empty browses everything in the location. |
| location | string | "canada" | City, region, or province name, a Kijiji slug, or a numeric id. Resolved against the live Kijiji location list. |
| sortBy | string | "relevance" | "relevance", "dateDesc", "priceAsc", or "priceDesc". |
| minPrice | integer | (none) | Minimum price in Canadian dollars. |
| maxPrice | integer | (none) | Maximum price in Canadian dollars. |
| urls | array | (example) | Kijiji search or listing URLs (URL mode). |
| fetchDetails | boolean | true | Open each listing page for view count, seller phone and website, status, and more. |
| maxPages | integer | 5 | Maximum result pages per search or URL (40 listings per page). |
| maxListings | integer | 50 | Maximum listings for the whole run. 0 means unlimited. |
| proxy | object | Residential CA | Proxy configuration. Residential with country CA is strongly recommended. |

### Output example

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

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

### Plan requirement

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

# Actor input Schema

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

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

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

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

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

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

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

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

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

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

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

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

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

Kijiji search or listing URLs (URL mode). Multiple supported. Pagination walks forward from the page in each URL. Search-mode filter fields are ignored here.

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

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

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

Maximum result pages to walk per search/URL (40 listings per page).

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

Maximum listings to collect across the whole run. Default 0 means unlimited (collect every available listing, bounded by Max pages).

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

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

## Actor input object example

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

# Actor output Schema

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

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

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

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

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

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

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "keywords": [
        "iphone"
    ],
    "location": "city-of-toronto",
    "urls": [
        "https://www.kijiji.ca/b-apartments-condos/city-of-toronto/c37l1700273"
    ],
    "proxy": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "apifyProxyCountry": "CA"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("abotapi/kijiji-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "keywords": ["iphone"],
    "location": "city-of-toronto",
    "urls": ["https://www.kijiji.ca/b-apartments-condos/city-of-toronto/c37l1700273"],
    "proxy": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "CA",
    },
}

# Run the Actor and wait for it to finish
run = client.actor("abotapi/kijiji-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 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 '{
  "keywords": [
    "iphone"
  ],
  "location": "city-of-toronto",
  "urls": [
    "https://www.kijiji.ca/b-apartments-condos/city-of-toronto/c37l1700273"
  ],
  "proxy": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "CA"
  }
}' |
apify call abotapi/kijiji-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Kijiji.ca $1💰 Classifieds, Vehicles, Jobs & Property",
        "description": "Extract listings from Kijiji.ca across property, vehicles, jobs, electronics, furniture, services, and more. Search by keyword and location or use any Kijiji URL. Returns title, description, price, photos, GPS coordinates, seller details, and category-specific attributes.",
        "version": "1.0",
        "x-build-id": "JakeQSmgPtPF23ghD"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/abotapi~kijiji-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-abotapi-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/abotapi~kijiji-scraper/runs": {
            "post": {
                "operationId": "runs-sync-abotapi-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/abotapi~kijiji-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-abotapi-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",
                "required": [
                    "mode"
                ],
                "properties": {
                    "mode": {
                        "title": "Mode",
                        "enum": [
                            "search",
                            "url"
                        ],
                        "type": "string",
                        "description": "Search by keyword + location, or paste Kijiji URLs directly.",
                        "default": "search"
                    },
                    "keywords": {
                        "title": "Keywords",
                        "type": "array",
                        "description": "Search terms (Search mode). Each term runs as a separate all-category search. Leave empty to browse every listing in the location.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "location": {
                        "title": "Location",
                        "type": "string",
                        "description": "City, region, or province name (e.g. 'Toronto', 'Vancouver', 'Ontario'), a Kijiji location slug ('city-of-toronto'), or a numeric location id. Defaults to all of Canada.",
                        "default": "canada"
                    },
                    "sortBy": {
                        "title": "Sort by",
                        "enum": [
                            "relevance",
                            "dateDesc",
                            "priceAsc",
                            "priceDesc"
                        ],
                        "type": "string",
                        "description": "Result ordering. Note: Kijiji inserts a few promoted ads at the top regardless of sort.",
                        "default": "relevance"
                    },
                    "minPrice": {
                        "title": "Min price (CAD)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Minimum price filter in Canadian dollars. Leave empty for no minimum."
                    },
                    "maxPrice": {
                        "title": "Max price (CAD)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum price filter in Canadian dollars. Leave empty for no maximum."
                    },
                    "urls": {
                        "title": "Kijiji URLs",
                        "type": "array",
                        "description": "Kijiji search or listing URLs (URL mode). Multiple supported. Pagination walks forward from the page in each URL. Search-mode filter fields are ignored here.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "fetchDetails": {
                        "title": "Fetch listing details",
                        "type": "boolean",
                        "description": "Open each listing's detail page for view count, seller phone + website, listing status, virtual tour / video, and dealer profile. Slower but much richer.",
                        "default": true
                    },
                    "maxPages": {
                        "title": "Max pages per search",
                        "minimum": 1,
                        "maximum": 200,
                        "type": "integer",
                        "description": "Maximum result pages to walk per search/URL (40 listings per page).",
                        "default": 1
                    },
                    "maxListings": {
                        "title": "Max listings",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum listings to collect across the whole run. Default 0 means unlimited (collect every available listing, bounded by Max pages).",
                        "default": 0
                    },
                    "proxy": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Kijiji.ca works most reliably on Apify Residential proxy with country = CA. Datacenter exits are frequently rejected. On failure the actor rotates to a fresh exit IP and can fail over to a backup gateway.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ],
                            "apifyProxyCountry": "CA"
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
