# EasyAuto123 Scraper – Vehicle Listings, VINs & Dealer Data (`abotapi/easyauto123-cars-scraper`) Actor

Scrape EasyAuto123 vehicle listings into clean structured data. Extract prices, VINs, odometer readings, make, model, year, trim, specs, images, dealer names, locations, contact details, listing URLs, and optional extra fields for market research, lead generation, and inventory tracking.

- **URL**: https://apify.com/abotapi/easyauto123-cars-scraper.md
- **Developed by:** [AbotAPI](https://apify.com/abotapi) (community)
- **Categories:** Lead generation, Travel, E-commerce
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.00 / 1,000 dataset items

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

## EasyAuto123 Cars Scraper

Extract EasyAuto123 used vehicle listings into a clean dataset for pricing analysis, stock tracking, lead routing, and vehicle comparison workflows.

### What You Get

Each saved vehicle can include:

- Listing ID, EasyAuto123 URL, title, make, model, variant, release year, VIN
- Displayed price, price type, odometer, fuel, transmission, drive type, engine capacity, colour, body/type labels
- Store location, region, state, store name, public phone, public email, address, and rating when available
- Primary image, full image list, car category, banner, stock status, update timestamp
- Price component rows, full store object, and full source vehicle object for advanced exports

### Input Modes

#### Search Filters

Use `mode: search` to build a vehicle search from filters. Supported filters include:

- Keywords, makes, models, variants
- Dealer locations
- Vehicle types, fuel types, transmissions, colours
- Lifestyle labels, vehicle sizes, EasyAuto123 car types
- Year, price, and odometer ranges
- Sort order

#### URLs

Use `mode: url` for one or more EasyAuto123 URLs. Supported examples:

- `https://easyauto123.com.au/buy/used-cars?page=1&limit=20`
- `https://easyauto123.com.au/buy/used-cars?page=2&limit=20&fuel-type=Hybrid`
- `https://easyauto123.com.au/buy/used-cars/details/2014/TOYOTA/CAMRY/Hybrid-HL/SA/Adelaide/Mile-End-South/Automatic/White/Sedan-Hybrid/6T1BD3FK40X141250`

### Limits

`maxItems` is the main cap. The actor stops once that many vehicles have been saved or no more matching vehicles are available.

`maxPages` is optional. Leave it as `0` to avoid a page cap. Set it only when you want to limit how far a search can go.

### Detail Fields

Keep `fetchDetails` enabled when you want the richest vehicle records. Turn it off for faster list-level runs when you only need listing data.

### Send results into your apps (MCP connectors)

Optionally pipe the scraped results into the apps you already use, via Model Context Protocol (MCP) connectors. This is an extra delivery step **after** the scrape, and the Apify dataset is never changed.

**What gets written to the connector:** a condensed, human-readable **summary** of each record (not the full JSON). Each item becomes one entry with a **title** (the vehicle name) and its key fields flattened to plain text. Nested objects are collapsed to their main value and long lists are trimmed. The **complete record always stays in the Apify dataset**.

1. Authorize a connector once under **Apify → Settings → Integrations** (Notion, Linear, Airtable, or Apify).
2. Select it in the **"Pipe results into your apps"** input field. (If the picker is empty, you haven't authorized a connector yet.)
3. For **Notion**, also set `notionParentPageUrl` to the page where items should be created.

The connection is mediated by Apify's MCP proxy, so this actor never sees your third-party credentials. Leave the field empty to skip.

### Proxy

The actor uses Apify Proxy by default. Keep the prefilled proxy configuration for normal runs, or provide your own proxy settings if your workflow requires it.

### Example Input

```json
{
  "mode": "search",
  "makes": ["Toyota"],
  "models": ["CAMRY"],
  "fuelTypes": ["Hybrid"],
  "maxItems": 20,
  "maxPages": 0,
  "fetchDetails": true,
  "proxyConfiguration": {
    "useApifyProxy": true
  },
  "mcpConnectors": []
}
````

### Output Example

```json
{
  "listingId": "f5504a4d-5263-4cc0-fc0a-08debf9c24ec",
  "url": "https://easyauto123.com.au/buy/used-cars/details/2011/SUBARU/IMPREZA/2.0i-L/QLD/Brisbane/Hendra/Automatic/White/Sedan/JF1GJ7KC5CG003176",
  "title": "2011 Subaru Impreza 2.0i-L",
  "make": "SUBARU",
  "model": "IMPREZA",
  "variant": "2.0i-L",
  "year": 2011,
  "price": 10990,
  "odometer": 168196,
  "vin": "JF1GJ7KC5CG003176",
  "fuelType": "Petrol",
  "transmission": "Automatic",
  "location": "Hendra",
  "state": "QLD",
  "storeName": "easyauto123 Hendra"
}
```

### Notes

The dataset can include additional fields beyond the table view. Export JSON if you need nested store details, price components, image metadata, or the full vehicle object.

# Actor input Schema

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

Choose whether to build a listing search from filters or start from one or more EasyAuto123 URLs.

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

Use this in URLs mode. Add listing search URLs or individual vehicle URLs.

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

Optional make and model text, such as Toyota CAMRY or Ford RANGER.

## `makes` (type: `array`):

Vehicle makes, for example Toyota, Mazda, Ford, BYD, Kia, Hyundai, Mitsubishi, Subaru, Volkswagen, Nissan, Audi.

## `models` (type: `array`):

Vehicle models to include. Use values as shown on EasyAuto123, for example CAMRY, RANGER, HILUX, I30, CX-5.

## `variants` (type: `array`):

Optional vehicle variant names.

## `locations` (type: `array`):

Dealer locations, such as Hendra QLD, Brooklyn VIC, Joondalup WA, Mile End South SA, Liverpool NSW, Newcastle NSW.

## `vehicleTypes` (type: `array`):

Body and type labels, for example SUV, Wagon, Hatchback, Sedan, UTE, 7+ Seater, Hybrid, Electric.

## `fuelTypes` (type: `array`):

Fuel labels to include.

## `transmissions` (type: `array`):

Transmission labels to include.

## `colours` (type: `array`):

Vehicle colours, such as White, Grey, Blue, Black, Silver, Red.

## `lifestyles` (type: `array`):

Lifestyle labels, such as Family, City, Tradie, Outdoor Adventure, Eco Friendly.

## `vehicleSizes` (type: `array`):

Size labels to include.

## `carTypes` (type: `array`):

EasyAuto123 vehicle categories.

## `minYear` (type: `integer`):

Only include vehicles from this release year or newer.

## `maxYear` (type: `integer`):

Only include vehicles from this release year or older.

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

Only include vehicles at or above this displayed price.

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

Only include vehicles at or below this displayed price.

## `minOdometer` (type: `integer`):

Only include vehicles at or above this odometer reading.

## `maxOdometer` (type: `integer`):

Only include vehicles at or below this odometer reading.

## `sort` (type: `string`):

Result ordering.

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

Adds fields that are only available on individual vehicle pages.

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

Maximum number of dataset items to save. The run stops when this cap is reached or no more matching vehicles are available.

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

Optional page cap. Leave as 0 for no page cap; max items remains the main limit.

## `mcpConnectors` (type: `array`):

Optionally send the scraped results into the apps you already use, via Model Context Protocol (MCP) connectors. Authorize a connector once under Apify → Settings → Integrations, then select it here. The connector receives a condensed, human-readable summary per item (title + key fields), not the full JSON. The complete record stays in the dataset. Leave empty to skip. Supported: Notion (https://mcp.notion.com/mcp), Linear (https://mcp.linear.app/sse), Airtable (https://mcp.airtable.com/mcp), Apify (https://mcp.apify.com).

## `notionParentPageUrl` (type: `string`):

URL (or id) of the Notion page under which item pages are created. Required to enable the Notion export; ignored by other connectors.

## `maxNotifyListings` (type: `integer`):

Cap on items written to each connector per run. Does not affect the dataset.

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

Apify Proxy is used by default. Keep the prefilled setting unless you need a custom proxy.

## Actor input object example

```json
{
  "mode": "search",
  "urls": [
    "https://easyauto123.com.au/buy/used-cars?page=1&limit=20"
  ],
  "sort": "price-reduced",
  "fetchDetails": true,
  "maxItems": 20,
  "maxPages": 0,
  "maxNotifyListings": 50,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# 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 = {
    "urls": [
        "https://easyauto123.com.au/buy/used-cars?page=1&limit=20"
    ],
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("abotapi/easyauto123-cars-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 = {
    "urls": ["https://easyauto123.com.au/buy/used-cars?page=1&limit=20"],
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("abotapi/easyauto123-cars-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 '{
  "urls": [
    "https://easyauto123.com.au/buy/used-cars?page=1&limit=20"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call abotapi/easyauto123-cars-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "EasyAuto123 Scraper – Vehicle Listings, VINs & Dealer Data",
        "description": "Scrape EasyAuto123 vehicle listings into clean structured data. Extract prices, VINs, odometer readings, make, model, year, trim, specs, images, dealer names, locations, contact details, listing URLs, and optional extra fields for market research, lead generation, and inventory tracking.",
        "version": "1.0",
        "x-build-id": "bbVVzfJj5vaLbqXTb"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/abotapi~easyauto123-cars-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-abotapi-easyauto123-cars-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~easyauto123-cars-scraper/runs": {
            "post": {
                "operationId": "runs-sync-abotapi-easyauto123-cars-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~easyauto123-cars-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-abotapi-easyauto123-cars-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": "Choose whether to build a listing search from filters or start from one or more EasyAuto123 URLs.",
                        "default": "search"
                    },
                    "urls": {
                        "title": "EasyAuto123 URLs",
                        "type": "array",
                        "description": "Use this in URLs mode. Add listing search URLs or individual vehicle URLs.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "keywords": {
                        "title": "Keywords",
                        "type": "array",
                        "description": "Optional make and model text, such as Toyota CAMRY or Ford RANGER.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "makes": {
                        "title": "Makes",
                        "type": "array",
                        "description": "Vehicle makes, for example Toyota, Mazda, Ford, BYD, Kia, Hyundai, Mitsubishi, Subaru, Volkswagen, Nissan, Audi.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "models": {
                        "title": "Models",
                        "type": "array",
                        "description": "Vehicle models to include. Use values as shown on EasyAuto123, for example CAMRY, RANGER, HILUX, I30, CX-5.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "variants": {
                        "title": "Variants",
                        "type": "array",
                        "description": "Optional vehicle variant names.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "locations": {
                        "title": "Locations",
                        "type": "array",
                        "description": "Dealer locations, such as Hendra QLD, Brooklyn VIC, Joondalup WA, Mile End South SA, Liverpool NSW, Newcastle NSW.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "vehicleTypes": {
                        "title": "Vehicle types",
                        "type": "array",
                        "description": "Body and type labels, for example SUV, Wagon, Hatchback, Sedan, UTE, 7+ Seater, Hybrid, Electric.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "fuelTypes": {
                        "title": "Fuel types",
                        "type": "array",
                        "description": "Fuel labels to include.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "Petrol",
                                "Diesel",
                                "Hybrid",
                                "Electric"
                            ]
                        }
                    },
                    "transmissions": {
                        "title": "Transmissions",
                        "type": "array",
                        "description": "Transmission labels to include.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "Automatic",
                                "Manual"
                            ]
                        }
                    },
                    "colours": {
                        "title": "Colours",
                        "type": "array",
                        "description": "Vehicle colours, such as White, Grey, Blue, Black, Silver, Red.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "lifestyles": {
                        "title": "Lifestyles",
                        "type": "array",
                        "description": "Lifestyle labels, such as Family, City, Tradie, Outdoor Adventure, Eco Friendly.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "vehicleSizes": {
                        "title": "Vehicle sizes",
                        "type": "array",
                        "description": "Size labels to include.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "Small",
                                "Medium",
                                "Large"
                            ]
                        }
                    },
                    "carTypes": {
                        "title": "Car types",
                        "type": "array",
                        "description": "EasyAuto123 vehicle categories.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "Quality Verified",
                                "Budget"
                            ]
                        }
                    },
                    "minYear": {
                        "title": "Minimum year",
                        "minimum": 1990,
                        "type": "integer",
                        "description": "Only include vehicles from this release year or newer."
                    },
                    "maxYear": {
                        "title": "Maximum year",
                        "minimum": 1990,
                        "type": "integer",
                        "description": "Only include vehicles from this release year or older."
                    },
                    "minPrice": {
                        "title": "Minimum price",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only include vehicles at or above this displayed price."
                    },
                    "maxPrice": {
                        "title": "Maximum price",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only include vehicles at or below this displayed price."
                    },
                    "minOdometer": {
                        "title": "Minimum odometer",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only include vehicles at or above this odometer reading."
                    },
                    "maxOdometer": {
                        "title": "Maximum odometer",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only include vehicles at or below this odometer reading."
                    },
                    "sort": {
                        "title": "Sort",
                        "enum": [
                            "price-reduced",
                            "price-asc",
                            "price-desc",
                            "kilometres-asc",
                            "kilometres-desc",
                            "year-desc",
                            "year-asc"
                        ],
                        "type": "string",
                        "description": "Result ordering.",
                        "default": "price-reduced"
                    },
                    "fetchDetails": {
                        "title": "Fetch detail fields",
                        "type": "boolean",
                        "description": "Adds fields that are only available on individual vehicle pages.",
                        "default": true
                    },
                    "maxItems": {
                        "title": "Max items",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Maximum number of dataset items to save. The run stops when this cap is reached or no more matching vehicles are available.",
                        "default": 20
                    },
                    "maxPages": {
                        "title": "Max pages",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Optional page cap. Leave as 0 for no page cap; max items remains the main limit.",
                        "default": 0
                    },
                    "mcpConnectors": {
                        "title": "Pipe results into your apps (optional)",
                        "type": "array",
                        "description": "Optionally send the scraped results into the apps you already use, via Model Context Protocol (MCP) connectors. Authorize a connector once under Apify → Settings → Integrations, then select it here. The connector receives a condensed, human-readable summary per item (title + key fields), not the full JSON. The complete record stays in the dataset. Leave empty to skip. Supported: Notion (https://mcp.notion.com/mcp), Linear (https://mcp.linear.app/sse), Airtable (https://mcp.airtable.com/mcp), Apify (https://mcp.apify.com)."
                    },
                    "notionParentPageUrl": {
                        "title": "Notion parent page (Notion connector only)",
                        "type": "string",
                        "description": "URL (or id) of the Notion page under which item pages are created. Required to enable the Notion export; ignored by other connectors."
                    },
                    "maxNotifyListings": {
                        "title": "Max items to export per connector",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Cap on items written to each connector per run. Does not affect the dataset.",
                        "default": 50
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Apify Proxy is used by default. Keep the prefilled setting unless you need a custom proxy.",
                        "default": {
                            "useApifyProxy": 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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
