# CarGurus Scraper (`khadinakbar/cargurus-scraper`) Actor

Scrape CarGurus car listings (US, CA, UK) with VIN, price, deal rating, mileage, and dealer contact.

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

## Pricing

from $5.00 / 1,000 listing scrapeds

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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

## CarGurus Scraper

Scrape car listings from **CarGurus** (US, Canada, and UK) by ZIP/postal-code search or by pasting a CarGurus search URL. Returns one clean, flat JSON record per car — including **VIN, price, total price, MSRP, CarGurus deal rating, deal score, mileage, dealer name + phone, days on market, drivetrain, fuel type, MPG, photos, and more**.

Built for dealers, resellers, and automotive analysts who need fresh inventory and pricing intelligence, and for AI agents that need structured car data from a single query. HTTP-only, fast, and MCP-ready.

### What you get

| Field | Description |
|---|---|
| `title`, `make`, `model`, `trim`, `year` | Vehicle identity |
| `vin`, `stockNumber` | VIN and dealer stock number |
| `price`, `totalPrice`, `msrp`, `priceCurrency` | Sticker price, price incl. fees, MSRP, currency |
| `dealRating`, `dealScore`, `priceDifferential` | CarGurus deal rating (GREAT/GOOD/FAIR price), 0–1 score, $ above/below market value |
| `mileage`, `daysOnMarket` | Odometer and time on market |
| `bodyType`, `transmission`, `driveTrain`, `fuelType`, `engine`, `combinedMpg` | Specs |
| `exteriorColor`, `interiorColor`, `options[]` | Colors and feature list |
| `imageUrl`, `pictureCount` | Primary photo + photo count |
| `dealerName`, `sellerType`, `isFranchiseDealer`, `sellerCity`, `sellerRegion`, `sellerPostalCode`, `phone` | Seller / dealer contact |
| `distance`, `listingUrl`, `country`, `scrapedAt` | Distance, permalink, marketplace, timestamp |

### When to use it

- **Dealer / reseller price intelligence** — track competitor inventory and deal ratings in your market.
- **Lead generation** — VIN + dealer name + phone per listing.
- **Market research** — price differentials vs. CarGurus Instant Market Value, days-on-market trends.
- **AI agents** — a single ZIP-based query returns structured listings as JSON.

Do **not** use this for CarGurus dealer reviews or for non-CarGurus sites (Cars.com, CARFAX, AutoTrader have their own scrapers).

### Pricing

Pay-per-event:

- **$0.00005** per actor start
- **$0.005** per listing returned

A run that returns 100 listings costs about **$0.50**. Pay-per-usage (compute + proxy) is also available — pick whichever billing model you prefer at run time.

### Input

| Field | Type | Description |
|---|---|---|
| `country` | enum | `US`, `CA`, or `UK`. Picks the CarGurus marketplace domain. Default `US`. |
| `postalCode` | string | US ZIP (`10001`), CA postal/FSA (`M5V`), or UK outcode (`SW1A`). Default `10001`. |
| `distance` | integer | Search radius (miles US / km CA-UK). 10–500. Default `50`. |
| `make` | string | Optional brand filter (e.g. `Toyota`). |
| `model` | string | Optional model filter (e.g. `Camry`). |
| `minPrice` / `maxPrice` | integer | Optional total-price band in local currency. |
| `minYear` / `maxYear` | integer | Optional model-year band. |
| `maxMileage` | integer | Optional max odometer. |
| `sortBy` | enum | `deal_score` (default), `price_asc`, `price_desc`, `mileage_asc`, `year_desc`, `distance`. |
| `searchUrls` | array | Advanced: paste CarGurus search-result URLs to reuse their exact filters. Overrides `postalCode`/`distance`. |
| `maxResults` | integer | Max listings per run. 1–10000. Default `100`. |

#### Example input

```json
{
  "country": "US",
  "postalCode": "90210",
  "distance": 50,
  "make": "Toyota",
  "model": "Camry",
  "minYear": 2019,
  "maxMileage": 60000,
  "sortBy": "deal_score",
  "maxResults": 100
}
````

#### Advanced: paste a search URL

Filter on CarGurus in your browser (trim, body type, specific make/model), copy the results-page URL, and paste it into `searchUrls`. The actor reuses every filter in that URL and paginates through all matching results.

```json
{
  "country": "US",
  "searchUrls": [
    "https://www.cargurus.com/Cars/inventorylisting/viewDetailsFilterViewInventoryListing.action?zip=10001&distance=50"
  ],
  "maxResults": 200
}
```

### Output

Each dataset item is one car listing. Example:

```json
{
  "listingId": "440604442",
  "listingUrl": "https://www.cargurus.com/Cars/link/440604442",
  "title": "2018 Audi A3 2.0T quattro Premium Plus",
  "make": "Audi",
  "model": "A3",
  "trim": "2.0T quattro Premium Plus",
  "year": 2018,
  "vin": "WAUJEGFF0J1000000",
  "price": 18995,
  "totalPrice": 19990,
  "msrp": null,
  "priceCurrency": "USD",
  "dealRating": "GOOD_PRICE",
  "dealScore": 0.97,
  "priceDifferential": -1200,
  "mileage": 52310,
  "daysOnMarket": 41,
  "driveTrain": "ALL_WHEEL_DRIVE",
  "fuelType": "Gasoline",
  "options": ["Leather Seats", "Sunroof/Moonroof", "Navigation System"],
  "imageUrl": "https://static.cargurus.com/images/forsale/.../pic-1024x768.jpeg",
  "dealerName": "Route 7 Nissan",
  "isFranchiseDealer": true,
  "sellerCity": "Danbury, CT",
  "phone": "(505) 472-7262",
  "distance": 21.4,
  "country": "US",
  "scrapedAt": "2026-06-24T16:00:00.000Z"
}
```

### How it works

The actor calls CarGurus' inventory search JSON endpoint directly over HTTP through Apify's datacenter proxy with browser-grade TLS, paginating until your `maxResults` is reached. Price, year, mileage, make, and model filters are enforced on the returned data so results always match your input. No browser is launched, so runs are fast and cheap.

### Notes & limits

- **US is the most reliable** marketplace; CA and UK are supported and tested but served through US-region proxies.
- CarGurus may cap a single search at a few thousand results — narrow your radius or filters for deep inventory.
- Deal ratings, scores, and price differentials are CarGurus' own computed values.

### Legal

This actor collects only publicly available data shown on CarGurus search-result pages. It does not log in, bypass paywalls, or access private data. You are responsible for using scraped data in compliance with CarGurus' Terms of Service, applicable laws (including data-protection regulations), and the rights of third parties. Use for lawful purposes such as market research and internal analysis.

### Related actors

- For other automotive marketplaces, see the corresponding Cars.com, CARFAX, and AutoScout24 scrapers.
- Pair with lead-enrichment and contact-finder actors to turn dealer data into outreach lists.

# Actor input Schema

## `country` (type: `string`):

Which CarGurus marketplace to search. Use 'US' for cargurus.com, 'CA' for cargurus.ca, 'UK' for cargurus.co.uk. Defaults to US. This is NOT a proxy region — it picks the website domain and the postal-code format expected below.

## `postalCode` (type: `string`):

Center of the location search. Use a US ZIP (e.g. '10001'), a Canadian forward sortation area or postal code (e.g. 'M5V'), or a UK outcode/postcode (e.g. 'SW1A'). Ignored when 'searchUrls' is provided. Defaults to '10001'.

## `distance` (type: `integer`):

Radius around the postal code, in miles (US) or kilometres (CA/UK). Accepts 10 to 500. Larger radius returns more dealers but slower runs. Defaults to 50. Ignored when 'searchUrls' is provided.

## `make` (type: `string`):

Optional brand name to keep, matched case-insensitively against each listing's makeName (e.g. 'Toyota'). Leave empty for all makes. This is a result filter, NOT a free-text site search — spelling must match CarGurus brand names. Pair with 'model' to narrow further.

## `model` (type: `string`):

Optional model name to keep, matched case-insensitively as a substring of each listing's modelName (e.g. 'Camry' or 'F-150'). Leave empty for all models. Works on its own or combined with 'make' for precise results. This is a result filter, not a site search.

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

Lowest total price to keep, in the marketplace's local currency (USD/CAD/GBP). Listings below this are dropped. Leave empty for no floor. Enforced on the listing's totalPrice (price + dealer fees), not the sticker price alone.

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

Highest total price to keep, in local currency. Listings above this are dropped. Leave empty for no ceiling. Enforced on totalPrice. Set with 'minPrice' to define a band (e.g. 15000 to 30000).

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

Oldest model year to keep (e.g. 2018). Listings older than this are dropped. Leave empty for no limit. Matched against the listing's carYear. NOT the registration date.

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

Newest model year to keep (e.g. 2024). Listings newer than this are dropped. Leave empty for no limit. Matched against carYear. Set with 'minYear' for a year band.

## `maxMileage` (type: `integer`):

Highest odometer reading to keep, in miles (US) or kilometres (CA/UK). Listings above this are dropped. Leave empty for no limit. Matched against the listing's mileage. Use for filtering low-mileage inventory.

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

Order CarGurus returns listings in before filtering. 'deal\_score' (best deals first) is the CarGurus default and most useful. Other options sort by price, mileage, year, or distance. Defaults to 'deal\_score'.

## `searchUrls` (type: `array`):

Optional. Paste one or more CarGurus search/inventory result URLs copied from your browser (e.g. a filtered cargurus.com results page). When set, the actor reuses each URL's exact filters and ignores postalCode/distance above. Use this for filters the structured fields don't cover (trim, body type, specific make/model entity). Each item is a full https URL.

## `maxResults` (type: `integer`):

Maximum number of listings to return per run (after filtering), summed across all search inputs. Controls cost: you are charged per listing returned. Accepts 1 to 10000. Defaults to 100.

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

Proxy used to reach CarGurus. Defaults to Apify datacenter (US), which is required — CarGurus blocks unproxied requests. Leave as default unless you have a specific residential setup.

## Actor input object example

```json
{
  "country": "US",
  "postalCode": "90210",
  "distance": 50,
  "make": "Toyota",
  "model": "Camry",
  "minPrice": 15000,
  "maxPrice": 35000,
  "minYear": 2018,
  "maxYear": 2024,
  "maxMileage": 60000,
  "sortBy": "deal_score",
  "searchUrls": [
    "https://www.cargurus.com/Cars/inventorylisting/viewDetailsFilterViewInventoryListing.action?zip=10001&distance=50"
  ],
  "maxResults": 100,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

Scraped CarGurus car listings as JSON.

## `summary` (type: `string`):

Counts of listings scraped, requests, and blocks for this run.

# 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 = {
    "country": "US",
    "postalCode": "10001",
    "distance": 50,
    "sortBy": "deal_score",
    "maxResults": 100,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("khadinakbar/cargurus-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 = {
    "country": "US",
    "postalCode": "10001",
    "distance": 50,
    "sortBy": "deal_score",
    "maxResults": 100,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("khadinakbar/cargurus-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 '{
  "country": "US",
  "postalCode": "10001",
  "distance": 50,
  "sortBy": "deal_score",
  "maxResults": 100,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call khadinakbar/cargurus-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "CarGurus Scraper",
        "description": "Scrape CarGurus car listings (US, CA, UK) with VIN, price, deal rating, mileage, and dealer contact.",
        "version": "1.0",
        "x-build-id": "QXeKDftBBBWQpkZM0"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/khadinakbar~cargurus-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-khadinakbar-cargurus-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/khadinakbar~cargurus-scraper/runs": {
            "post": {
                "operationId": "runs-sync-khadinakbar-cargurus-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/khadinakbar~cargurus-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-khadinakbar-cargurus-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": [
                    "country"
                ],
                "properties": {
                    "country": {
                        "title": "Country / marketplace",
                        "enum": [
                            "US",
                            "CA",
                            "UK"
                        ],
                        "type": "string",
                        "description": "Which CarGurus marketplace to search. Use 'US' for cargurus.com, 'CA' for cargurus.ca, 'UK' for cargurus.co.uk. Defaults to US. This is NOT a proxy region — it picks the website domain and the postal-code format expected below.",
                        "default": "US"
                    },
                    "postalCode": {
                        "title": "Postal / ZIP code",
                        "type": "string",
                        "description": "Center of the location search. Use a US ZIP (e.g. '10001'), a Canadian forward sortation area or postal code (e.g. 'M5V'), or a UK outcode/postcode (e.g. 'SW1A'). Ignored when 'searchUrls' is provided. Defaults to '10001'.",
                        "default": "10001"
                    },
                    "distance": {
                        "title": "Search radius",
                        "minimum": 10,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Radius around the postal code, in miles (US) or kilometres (CA/UK). Accepts 10 to 500. Larger radius returns more dealers but slower runs. Defaults to 50. Ignored when 'searchUrls' is provided.",
                        "default": 50
                    },
                    "make": {
                        "title": "Make (brand) filter",
                        "type": "string",
                        "description": "Optional brand name to keep, matched case-insensitively against each listing's makeName (e.g. 'Toyota'). Leave empty for all makes. This is a result filter, NOT a free-text site search — spelling must match CarGurus brand names. Pair with 'model' to narrow further."
                    },
                    "model": {
                        "title": "Model filter",
                        "type": "string",
                        "description": "Optional model name to keep, matched case-insensitively as a substring of each listing's modelName (e.g. 'Camry' or 'F-150'). Leave empty for all models. Works on its own or combined with 'make' for precise results. This is a result filter, not a site search."
                    },
                    "minPrice": {
                        "title": "Minimum price",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Lowest total price to keep, in the marketplace's local currency (USD/CAD/GBP). Listings below this are dropped. Leave empty for no floor. Enforced on the listing's totalPrice (price + dealer fees), not the sticker price alone."
                    },
                    "maxPrice": {
                        "title": "Maximum price",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Highest total price to keep, in local currency. Listings above this are dropped. Leave empty for no ceiling. Enforced on totalPrice. Set with 'minPrice' to define a band (e.g. 15000 to 30000)."
                    },
                    "minYear": {
                        "title": "Minimum model year",
                        "minimum": 1950,
                        "maximum": 2027,
                        "type": "integer",
                        "description": "Oldest model year to keep (e.g. 2018). Listings older than this are dropped. Leave empty for no limit. Matched against the listing's carYear. NOT the registration date."
                    },
                    "maxYear": {
                        "title": "Maximum model year",
                        "minimum": 1950,
                        "maximum": 2027,
                        "type": "integer",
                        "description": "Newest model year to keep (e.g. 2024). Listings newer than this are dropped. Leave empty for no limit. Matched against carYear. Set with 'minYear' for a year band."
                    },
                    "maxMileage": {
                        "title": "Maximum mileage",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Highest odometer reading to keep, in miles (US) or kilometres (CA/UK). Listings above this are dropped. Leave empty for no limit. Matched against the listing's mileage. Use for filtering low-mileage inventory."
                    },
                    "sortBy": {
                        "title": "Sort order",
                        "enum": [
                            "deal_score",
                            "price_asc",
                            "price_desc",
                            "mileage_asc",
                            "year_desc",
                            "distance"
                        ],
                        "type": "string",
                        "description": "Order CarGurus returns listings in before filtering. 'deal_score' (best deals first) is the CarGurus default and most useful. Other options sort by price, mileage, year, or distance. Defaults to 'deal_score'.",
                        "default": "deal_score"
                    },
                    "searchUrls": {
                        "title": "CarGurus search URLs (advanced)",
                        "type": "array",
                        "description": "Optional. Paste one or more CarGurus search/inventory result URLs copied from your browser (e.g. a filtered cargurus.com results page). When set, the actor reuses each URL's exact filters and ignores postalCode/distance above. Use this for filters the structured fields don't cover (trim, body type, specific make/model entity). Each item is a full https URL.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxResults": {
                        "title": "Max listings",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of listings to return per run (after filtering), summed across all search inputs. Controls cost: you are charged per listing returned. Accepts 1 to 10000. Defaults to 100.",
                        "default": 100
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Proxy used to reach CarGurus. Defaults to Apify datacenter (US), which is required — CarGurus blocks unproxied requests. Leave as default unless you have a specific residential setup.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
