# AutoTrader Canada Vehicle Listings Scraper (`automation-lab/autotrader-canada-vehicle-listings-scraper`) Actor

🚗 Scrape public AutoTrader.ca vehicle listings with prices, mileage, seller details, locations, and images for market research.

- **URL**: https://apify.com/automation-lab/autotrader-canada-vehicle-listings-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** E-commerce
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 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

## AutoTrader Canada Vehicle Listings Scraper

Extract public vehicle listings from AutoTrader.ca search result pages. This Apify Actor is built for Canadian car-market monitoring, dealer inventory tracking, price research, and lead-list exports.

### What does AutoTrader Canada Vehicle Listings Scraper do?

AutoTrader Canada Vehicle Listings Scraper reads public AutoTrader.ca search pages and saves structured vehicle data to an Apify dataset.

It can collect listing IDs, URLs, titles, model years, makes, models, trims, prices, mileage, seller names, seller phone numbers when public, locations, images, descriptions, and technical attributes exposed in the search result page state.

### Who is it for?

- 🚗 Car dealers monitoring competing inventory in Canadian cities.
- 📊 Pricing analysts comparing asking prices by make, model, year, and mileage.
- 🧾 Resellers and exporters building sourcing spreadsheets.
- 🏦 Lenders and insurance teams tracking market values.
- 🛠 Automotive data teams feeding dashboards and alerts.
- 🧑‍💻 Developers who need AutoTrader.ca listing data via API.

### Why use this scraper?

AutoTrader.ca pages are designed for browsing, not spreadsheet exports. This Actor converts public search results into clean rows that can be downloaded as JSON, CSV, Excel, XML, or consumed through the Apify API.

### What data can you extract?

| Field | Description |
|---|---|
| `listingId` | AutoTrader listing UUID or listing reference |
| `legacyId` | Public cross-reference ID when present |
| `url` | Canonical listing URL |
| `title` | Vehicle title assembled from public fields |
| `year` | Model year |
| `make` | Vehicle make |
| `model` | Vehicle model |
| `trim` | Trim or model version |
| `price` | Numeric asking price |
| `priceText` | Displayed price text |
| `currency` | CAD |
| `mileageKm` | Numeric mileage in kilometers |
| `sellerName` | Dealer or seller name when public |
| `sellerPhone` | Public seller phone when present |
| `city` | Listing city |
| `province` | Canadian province code |
| `imageUrls` | Public listing image URLs |
| `description` | Public description snippet when available |
| `vehicleDetails` | Labelled attributes from the search page |
| `sourceSearchUrl` | Search URL that produced the listing |
| `scrapedAt` | Extraction timestamp |

### How much does it cost to scrape AutoTrader Canada listings?

This Actor uses pay-per-event pricing: a $0.005 run-start event plus a per-listing event. The current BRONZE price is $0.0005 per listing, or about $0.50 per 1,000 listings before volume-tier discounts. Free-tier users pay $0.000575 per listing; Scale users pay $0.00039 per listing; Business users pay $0.0003 per listing. Higher enterprise tiers receive additional volume discounts.

### How to use AutoTrader Canada Vehicle Listings Scraper

1. Open AutoTrader.ca in your browser.
2. Apply the filters you need, such as location, make, price, mileage, or body type.
3. Copy the resulting search URL.
4. Paste it into the `startUrls` input field.
5. Set `maxItems` to your desired listing limit.
6. Run the Actor.
7. Download the dataset or connect it to your workflow.

### Input configuration

#### `startUrls`

AutoTrader.ca search result URLs. Use URLs from public search pages, for example:

```json
[{ "url": "https://www.autotrader.ca/cars/on/toronto/?rcp=15&rcs=0&srt=35" }]
````

#### `maxItems`

Maximum number of listings to save across all provided search URLs.

#### `maxPagesPerStartUrl`

Safety cap for pagination attempts. Some AutoTrader.ca result pages expose the same first page for offset parameters, so the Actor automatically stops when it sees duplicate listings.

#### `includeDescriptions`

Set to `true` to save public listing descriptions from the search result state.

#### `requestDelayMs`

Delay between page requests. Keep the default for polite scraping.

#### `proxyConfiguration`

Optional Apify proxy settings. Start without a proxy; enable Apify Proxy only if your run environment receives different content.

### Example input

```json
{
  "startUrls": [
    { "url": "https://www.autotrader.ca/cars/on/toronto/?rcp=15&rcs=0&srt=35" }
  ],
  "maxItems": 50,
  "maxPagesPerStartUrl": 10,
  "includeDescriptions": true,
  "requestDelayMs": 1000,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

### Example output

```json
{
  "listingId": "8f27eab3-3246-41c9-b6b5-89c41e7b20c0",
  "url": "https://www.autotrader.ca/offers/...",
  "title": "2025 RAM 1500 Rebel Crew Cab | Sunroof | RamBox | Lvl 2",
  "year": 2025,
  "make": "RAM",
  "model": "1500",
  "trim": "Rebel Crew Cab | Sunroof | RamBox | Lvl 2",
  "price": 68988,
  "currency": "CAD",
  "mileageKm": 16998,
  "sellerName": "Scarborotown Chrysler Dodge Jeep Ram Ltd",
  "city": "TORONTO",
  "province": "ON"
}
```

### Tips for better results

- 🎯 Use filtered URLs for specific makes, models, cities, or price ranges.
- 📍 Create separate URLs for different provinces if you need broad coverage.
- 🔁 For monitoring, schedule the Actor and compare datasets over time.
- 💸 Keep the first run small while validating your filters.
- 🧹 Remove duplicate URLs from the input list.

### Integrations

You can connect this Actor with:

- Google Sheets for price-monitor spreadsheets.
- Make or Zapier for alerts when matching listings appear.
- Slack or email notifications for new inventory checks.
- Databases such as BigQuery, PostgreSQL, or Snowflake.
- BI tools for market dashboards.
- Apify webhooks for scheduled monitoring.

### API usage

#### Node.js

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/autotrader-canada-vehicle-listings-scraper').call({
  startUrls: [{ url: 'https://www.autotrader.ca/cars/on/toronto/?rcp=15&rcs=0&srt=35' }],
  maxItems: 25
});
console.log(run.defaultDatasetId);
```

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient('MY-APIFY-TOKEN')
run = client.actor('automation-lab/autotrader-canada-vehicle-listings-scraper').call(run_input={
    'startUrls': [{'url': 'https://www.autotrader.ca/cars/on/toronto/?rcp=15&rcs=0&srt=35'}],
    'maxItems': 25,
})
print(run['defaultDatasetId'])
```

#### cURL

```bash
curl -X POST 'https://api.apify.com/v2/acts/automation-lab~autotrader-canada-vehicle-listings-scraper/runs?token=YOUR_APIFY_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"startUrls":[{"url":"https://www.autotrader.ca/cars/on/toronto/?rcp=15&rcs=0&srt=35"}],"maxItems":25}'
```

### MCP usage

Use the Apify MCP server to run this Actor from AI tools.

MCP URL:

```text
https://mcp.apify.com/?tools=automation-lab/autotrader-canada-vehicle-listings-scraper
```

Claude Code CLI setup:

```bash
claude mcp add apify https://mcp.apify.com/?tools=automation-lab/autotrader-canada-vehicle-listings-scraper
```

Claude Desktop JSON setup:

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

MCP example prompts:

- "Use the Apify MCP server to run `automation-lab/autotrader-canada-vehicle-listings-scraper` for 20 Toronto listings."
- "Using MCP, call the AutoTrader Canada scraper and summarize prices by make."
- "With the MCP tool, run this AutoTrader.ca URL and export URL, price, mileage, and seller."

### Claude Code example prompts

- "Using MCP, run `automation-lab/autotrader-canada-vehicle-listings-scraper` for this Toronto search URL and summarize average price by make."
- "Use the AutoTrader Canada MCP tool to get 50 Vancouver listings and create a CSV with price, mileage, seller, and URL."
- "Run this AutoTrader.ca search through MCP every day and show me new listing IDs."

### Claude Desktop workflow

Add the Apify MCP server, enable this Actor, then ask Claude Desktop to run searches, compare prices, or prepare dealer-inventory reports.

Claude Code CLI setup example:

```bash
claude mcp add apify https://mcp.apify.com/?tools=automation-lab/autotrader-canada-vehicle-listings-scraper
```

Claude Desktop JSON setup example:

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

MCP prompt examples:

- "Use the Apify AutoTrader Canada tool to scrape 20 Toronto listings and return the cheapest five."
- "Run the AutoTrader Canada scraper for Vancouver and group the dataset by sellerName."
- "Fetch Montreal listings and tell me which vehicles have mileage under 20,000 km."

### Data quality notes

The Actor extracts data from public search-result state. Some fields depend on what AutoTrader.ca exposes for each listing. For example, seller phones, descriptions, or suggested retail prices may be missing on some results.

### Pagination notes

AutoTrader.ca can return duplicate first-page data for some offset parameters. The Actor deduplicates by listing ID and stops a pagination loop when no new listings are found. For larger exports, provide multiple filtered search URLs.

### Performance notes

This is an HTTP-only scraper and does not launch a browser. It is designed to run with 256 MB memory and conservative page pacing.

### Legality

This Actor extracts publicly visible information from AutoTrader.ca pages. You are responsible for using the data lawfully, respecting applicable terms, privacy requirements, and rate limits. Do not scrape private account data or use the Actor for spam.

### FAQ

#### Can I scrape private saved searches?

No. This Actor is scoped to public AutoTrader.ca search result pages only.

#### Does it open each vehicle detail page?

No. The first version extracts rich listing data from public search result state to reduce cost and avoid unnecessary requests.

### Troubleshooting

#### Why did I get fewer listings than `maxItems`?

The search page may contain fewer unique public listings than requested, or AutoTrader.ca may return duplicate first-page state for pagination offsets. Add more filtered search URLs to collect a larger sample.

#### Why are some fields empty?

Some sellers do not expose every field in search results. Empty values mean the field was not present in the public page state for that listing.

#### Should I enable proxy?

Start with proxy disabled. If your cloud run receives blocked or region-specific content, enable Apify Proxy and keep the result limit small for testing.

### Related scrapers

- https://apify.com/automation-lab/zillow-scraper
- https://apify.com/automation-lab/booking-scraper
- https://apify.com/automation-lab/olx-scraper
- https://apify.com/automation-lab/facebook-marketplace-scraper

### Changelog

#### 0.1

- Initial HTTP-first AutoTrader.ca search result extractor.
- Added structured vehicle, price, seller, image, and location fields.

### Support

If your search URL does not return expected listings, include the exact input and run ID when requesting help.

### Responsible usage checklist

- Use public search result URLs only.
- Keep limits small when validating filters.
- Avoid unnecessary retries.
- Schedule monitoring at reasonable intervals.
- Store and process personal data responsibly.

### Output formats

Apify datasets can be exported as JSON, JSONL, CSV, Excel, XML, RSS, or HTML. Use CSV or Excel for spreadsheet workflows and JSON/JSONL for data pipelines.

### Summary

AutoTrader Canada Vehicle Listings Scraper turns public Canadian vehicle marketplace pages into structured data for market intelligence, inventory monitoring, and pricing analysis.

# Actor input Schema

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

One or more public AutoTrader.ca search URLs, for example a cars-in-Toronto search with filters already applied.

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

Maximum number of vehicle listings to save across all search URLs.

## `maxPagesPerStartUrl` (type: `integer`):

Safety cap for pagination. AutoTrader.ca usually returns 15-20 listings per page depending on the URL.

## `includeDescriptions` (type: `boolean`):

Save public listing description text when it is present in the search result state.

## `requestDelayMs` (type: `integer`):

Polite delay between paginated search requests.

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

Optional Apify proxy settings. Leave disabled first; enable Apify Proxy if AutoTrader changes responses by region.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.autotrader.ca/cars/on/toronto/?rcp=15&rcs=0&srt=35"
    }
  ],
  "maxItems": 20,
  "maxPagesPerStartUrl": 10,
  "includeDescriptions": true,
  "requestDelayMs": 1000,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# 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.autotrader.ca/cars/on/toronto/?rcp=15&rcs=0&srt=35"
        }
    ],
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/autotrader-canada-vehicle-listings-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.autotrader.ca/cars/on/toronto/?rcp=15&rcs=0&srt=35" }],
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/autotrader-canada-vehicle-listings-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.autotrader.ca/cars/on/toronto/?rcp=15&rcs=0&srt=35"
    }
  ],
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call automation-lab/autotrader-canada-vehicle-listings-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "AutoTrader Canada Vehicle Listings Scraper",
        "description": "🚗 Scrape public AutoTrader.ca vehicle listings with prices, mileage, seller details, locations, and images for market research.",
        "version": "0.1",
        "x-build-id": "UZagl7x7rwO0LCeH7"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~autotrader-canada-vehicle-listings-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-autotrader-canada-vehicle-listings-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~autotrader-canada-vehicle-listings-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-autotrader-canada-vehicle-listings-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~autotrader-canada-vehicle-listings-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-autotrader-canada-vehicle-listings-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": [
                    "startUrls"
                ],
                "properties": {
                    "startUrls": {
                        "title": "AutoTrader.ca search result URLs",
                        "type": "array",
                        "description": "One or more public AutoTrader.ca search URLs, for example a cars-in-Toronto search with filters already applied.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxItems": {
                        "title": "Maximum listings",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of vehicle listings to save across all search URLs.",
                        "default": 20
                    },
                    "maxPagesPerStartUrl": {
                        "title": "Maximum pages per search URL",
                        "minimum": 1,
                        "maximum": 200,
                        "type": "integer",
                        "description": "Safety cap for pagination. AutoTrader.ca usually returns 15-20 listings per page depending on the URL.",
                        "default": 10
                    },
                    "includeDescriptions": {
                        "title": "Include descriptions",
                        "type": "boolean",
                        "description": "Save public listing description text when it is present in the search result state.",
                        "default": true
                    },
                    "requestDelayMs": {
                        "title": "Delay between pages (milliseconds)",
                        "minimum": 0,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Polite delay between paginated search requests.",
                        "default": 1000
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Optional Apify proxy settings. Leave disabled first; enable Apify Proxy if AutoTrader changes responses by region."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
