# Cargurus Com Scraper (`api-empire/cargurus-com-scraper`) Actor

- **URL**: https://apify.com/api-empire/cargurus-com-scraper.md
- **Developed by:** [API Empire](https://apify.com/api-empire) (community)
- **Categories:** Automation, Lead generation, Social media
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $4.99 / 1,000 results

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 Listings Scraper

Pick a **country**, **ZIP/postcode**, **make** (and optional **model** + **condition**) — the actor walks CarGurus' search SPA and streams clean, structured rows of vehicle data into your Apify dataset in real time.

### 🌟 Why Choose This Actor?

* 🧭 **Zero-URL workflow** — no need to copy a search URL. Pick country + ZIP + make and we build the request for you.
* 🛡️ **Smart 3-tier connection strategy** — starts with a direct request, then auto-falls-back to **datacenter proxy → residential proxy with 3 retries** if CarGurus pushes back. Once we escalate, we stay on the stronger tier.
* 🇺🇸🇨🇦🇬🇧 **Multi-country** — `cargurus.com` (USD), `cargurus.ca` (CAD), `cargurus.co.uk` (GBP) with automatic currency tagging.
* ⚡ **Real-time output** — each matching listing is pushed to the dataset as soon as it's parsed.
* 🛞🆕 **Condition filter** — choose Used (incl. CPO + priority) or New.
* 🎯 **Make + optional model filter** — applied client-side so results always match.
* 📦 **80+ structured fields per listing** — pricing, deal rating, dealer phone, fuel economy, colours, drivetrain, fuel type, images and more.
* 🧠 **Browser-fingerprinted HTTP** via `curl_cffi` (Chrome TLS + HTTP/2 impersonation) so we look like a real Chrome session.
* 🧭 **VIN-based dedup** — never pushes the same vehicle twice.

---

### 📥 Input

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `country` | enum `US` / `CA` / `UK` | ✅ | Which CarGurus marketplace to query. |
| `zipcode` | string | ✅ | ZIP / postcode to anchor the search. |
| `make` | enum (44 brands) | ✅ | Vehicle brand. Drives the CarGurus internal make-ID + client-side filter. |
| `model` | string | optional | Narrow to a specific model name (case-insensitive). Leave blank for all. |
| `condition` | enum `used` / `new` | ✅ | Used = pre-owned + CPO + priority listings. New = factory-fresh. |
| `maxItems` | integer | optional | Cap on matching listings. `0` = no cap. Default `50`. The internal SRP page budget is auto-sized from this — no extra knobs to tune. |
| `proxyConfiguration` | object | optional | Leave blank for smart 3-tier fallback. |

#### Example input

```json
{
  "country": "US",
  "zipcode": "10001",
  "make": "Toyota",
  "model": null,
  "condition": "used",
  "maxItems": 50,
  "proxyConfiguration": { "useApifyProxy": false }
}
````

***

### 📤 Output

Each row in the dataset is a single vehicle listing. Selected fields:

| Field | Type | Example |
|-------|------|---------|
| `id` | string | `5TFBY5F12AX122219` (VIN) |
| `sku` | number | `433980025` (CarGurus listing id) |
| `name` | string | `2010 Toyota Tundra Limited Double Cab 5.7L 4WD` |
| `url` | string | `https://www.cargurus.com/Cars/inventorylisting/vdp.action?listingId=…` |
| `price` | string | `"17895"` |
| `priceCurrency` | string | `USD` |
| `localizedTotalPrice` | string | `$17,895` |
| `brand`, `model`, `trimName`, `vehicleModelDate` | text/int | `Toyota` · `Tundra` · `Limited Double Cab 5.7L 4WD` · `2010` |
| `mileage`, `unitMileage` | int / object | `99050` · `{ value: 99050, unit: "MILES" }` |
| `color`, `vehicleInteriorColor` | text | `Gray` · `Gray` |
| `engine`, `vehicleTransmission`, `driveWheelConfiguration` | text | `381 hp 5.7L V8` · `Automatic` · `Four-Wheel Drive` |
| `fuelType`, `fuelEfficiency`, `cityFuelEconomy`, `highwayFuelEconomy`, `combinedFuelEconomy` | mixed | `Gasoline` · `15 MPG` · `{ value: 13, unit: "MPG" }` · … |
| `dealRating`, `dealScore` | string/number | `GREAT_PRICE` · `0.761643` |
| `daysOnMarket`, `pictureCount` | int | `164` · `12` |
| `dealerName`, `sellerCity`, `sellerRegion`, `sellerPostalCode` | text | `Williston Economy Motors` · `South Burlington, VT` · `VT` · `05403` |
| `phoneNumberString`, `phoneNumberSMS` | text | `(802) 255-8955` · `+18883346545` |
| `primaryImage`, `dealerLogoUrl` | url | image URLs |
| `googleStaticMapUrl` | url | dealer location map URL |
| `itemType` | string | `LISTING_USED_STANDARD` / `LISTING_USED_CPO` / `LISTING_USED_PRIORITY` / `LISTING_NEW` |

Plus many more: `inclusionType`, `listingSource`, `bodyType`, `bodyTypeGroupId`, `salesStatus`, `compliance`, `priceDropData`, `financeDto`, `evBatteryDto`, `stockNumber`, `ncapOverallSafetyRating`, `howToShop`, `buyingOption`, `sellerType`, `isFranchiseDealer`, `franchiseMake`, `distance`, `localizedFuelEconomy`, `description`, `expectedPrice`, `priceDifferential`, `imvPrice`, `feesCompliant`, `localizedDoors`, `normalizedExteriorColor`, `condition`, `availability`, `priceValidUntil`, `sortScore`, `debugInfo`, `offset`, `mpn`.

***

### 🚀 How to Use (Apify Console)

1. 🔐 Sign in at <https://console.apify.com> → **Actors**.
2. 🔍 Open the **CarGurus Listings Scraper** Actor.
3. 🌍 Pick **Country**, type a **ZIP / postcode**, pick a **Make** (and optional **Model**).
4. 🛞 Pick a **Condition** (Used / New).
5. 🎯 Optionally cap **Maximum listings** and **Maximum pages**.
6. ▶️ Click **Start**.
7. 👀 Watch matching listings stream into the **Output** tab live.
8. 💾 Export to JSON / CSV / XLSX when the run finishes.

### 🤖 Use via API

```bash
curl -X POST "https://api.apify.com/v2/acts/<ACTOR_ID>/run-sync-get-dataset-items?token=$APIFY_TOKEN" \
     -H "Content-Type: application/json" \
     -d '{
       "country": "US",
       "zipcode": "10001",
       "make": "Toyota",
       "condition": "used",
       "maxItems": 50
     }'
```

***

### 🎯 Best Use Cases

- 📊 Market-price benchmarking by make / model / region
- 🏬 Inventory monitoring for specific dealers
- 🚗 Lead generation for car-buying services
- 📈 Trend analysis on deal ratings and days-on-market
- 🌍 Cross-country pricing comparison (US / CA / UK)
- 🤖 AI agents that need fresh used-car data

### 💸 Pricing

This Actor uses Apify's **Pay-per-event** monetisation. You are billed per **`result-item`** event (i.e. per listing pushed to the dataset). Run start is free for the first 5 seconds and capped by your **`ACTOR_MAX_TOTAL_CHARGE_USD`** — the run stops cleanly when the limit is reached.

### ❓ Frequently Asked Questions

**Q. Do I need a proxy?**
No. The Actor starts without a proxy and only falls back to **datacenter → residential** if CarGurus pushes back. Leave **Proxy configuration** as-is.

**Q. Why is the model field optional?**
Because the make-level filter already narrows the result set heavily and many users want a quick model snapshot. Leave it blank for all models from the selected make.

**Q. Does it support new / used / CPO listings?**
Yes. Pick **Used** to include standard pre-owned + CPO + priority listings. Pick **New** for factory-fresh inventory only. The output includes an `itemType` field for finer slicing.

**Q. Why am I seeing fewer rows than `maxItems`?**
CarGurus simply ran out of unique listings for your search — we keep paginating until either your `maxItems` target is hit or CarGurus stops returning new VINs (3 consecutive empty pages). Widen the search (different zip, drop the model filter, try a more common make) and re-run. The scraper carries the make filter forward on every pagination request so server-side filtering is preserved across pages, and the SRP page budget is sized automatically from `maxItems` so you never need to tune it.

**Q. Is this legal?**
The Actor only collects data already publicly visible on CarGurus search pages. You are responsible for compliance with target-site Terms of Service, GDPR / CCPA, and any data-handling laws applicable to your use case.

### 🛟 Support and Feedback

Found a quirk or want a custom field? Open an issue on the Actor's page or drop a line to **dev.scraperengine@gmail.com**.

***

### ⚖️ Legal / Cautions

- Data is collected only from publicly available CarGurus search-result pages.
- Do not scrape private accounts or content behind authentication.
- The end user is responsible for legal compliance (GDPR, CCPA, anti-spam laws, CarGurus ToS, etc.).
- Honour `robots.txt` and reasonable rate limits — being a good citizen reduces blocks too.

# Actor input Schema

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

🗺️ Paste one or more CarGurus search-result URLs.

🔎 Example: `https://www.cargurus.com/Cars/inventorylisting/viewDetailsFilterViewInventoryListing.action?...` or `https://www.cargurus.com/search?...`

💡 Tip: build the perfect search on the CarGurus website (filter by zip, make, model, year, mileage…) then copy the URL straight from the address bar.

✅ Bulk friendly — add as many URLs as you like, the actor will paginate through each.

📭 Leave empty to instead use the **Country + ZIP + Make** picker in Step 2.

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

🗺️ Which CarGurus marketplace to query.

🇺🇸 `US` → cargurus.com (USD)
🇨🇦 `CA` → cargurus.ca (CAD)
🇬🇧 `UK` → cargurus.co.uk (GBP)

## `zipcode` (type: `string`):

🏷️ ZIP / postcode the search should be anchored to.

🇺🇸 5-digit US ZIP (e.g. `10001`)
🇨🇦 Canadian FSA (e.g. `M5V`)
🇬🇧 UK outward code (e.g. `SW1A`)

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

🏭 Vehicle brand to search for. Pick from the dropdown — the actor uses the CarGurus internal make-ID for accuracy and also filters client-side.

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

🎯 Optional — narrow results to a specific model name (e.g. `Camry`, `RAV4`, `Civic`). Leave blank to fetch every model from the selected make.

🧠 The model name must match what CarGurus shows in the listing (case-insensitive).

## `condition` (type: `string`):

✨ Filter by vehicle condition:

🛞 `Used` → pre-owned standard + CPO + priority listings
🆕 `New` → factory-fresh listings

💡 Also applied when scraping the URLs in Step 1, if you want to enforce a condition.

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

📦 Cap how many *matching* listings to collect in total.

0️⃣ Use 0 for no limit (we'll keep paginating until CarGurus stops returning new VINs).

⚡ Lower = faster & lighter; higher = broader coverage.

🧠 The page budget is sized automatically from this value — no extra knobs to tune.

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

🛰️ Optional Apify Proxy settings.

🟢 Leave blank to use the smart 3-stage fallback: **no proxy → datacenter → residential (×3)**.

🔵 Provide your own choice (e.g. RESIDENTIAL with country=US) to force a starting strategy — the actor will still fall back if that fails.

## Actor input object example

```json
{
  "urls": [],
  "country": "US",
  "zipcode": "10001",
  "make": "Toyota",
  "condition": "used",
  "maxItems": 10,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# 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": [],
    "zipcode": "10001",
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("api-empire/cargurus-com-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": [],
    "zipcode": "10001",
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("api-empire/cargurus-com-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": [],
  "zipcode": "10001",
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call api-empire/cargurus-com-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Cargurus Com Scraper",
        "description": null,
        "version": "1.0",
        "x-build-id": "YAu2NdZnUbq7BS3Kx"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/api-empire~cargurus-com-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-api-empire-cargurus-com-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/api-empire~cargurus-com-scraper/runs": {
            "post": {
                "operationId": "runs-sync-api-empire-cargurus-com-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/api-empire~cargurus-com-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-api-empire-cargurus-com-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "urls": {
                        "title": "🔗 CarGurus search URLs (optional, bulk-friendly)",
                        "type": "array",
                        "description": "🗺️ Paste one or more CarGurus search-result URLs.\n\n🔎 Example: `https://www.cargurus.com/Cars/inventorylisting/viewDetailsFilterViewInventoryListing.action?...` or `https://www.cargurus.com/search?...`\n\n💡 Tip: build the perfect search on the CarGurus website (filter by zip, make, model, year, mileage…) then copy the URL straight from the address bar.\n\n✅ Bulk friendly — add as many URLs as you like, the actor will paginate through each.\n\n📭 Leave empty to instead use the **Country + ZIP + Make** picker in Step 2.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "country": {
                        "title": "🌐 Country",
                        "enum": [
                            "US",
                            "CA",
                            "UK"
                        ],
                        "type": "string",
                        "description": "🗺️ Which CarGurus marketplace to query.\n\n🇺🇸 `US` → cargurus.com (USD)\n🇨🇦 `CA` → cargurus.ca (CAD)\n🇬🇧 `UK` → cargurus.co.uk (GBP)",
                        "default": "US"
                    },
                    "zipcode": {
                        "title": "📮 ZIP / Postal code",
                        "type": "string",
                        "description": "🏷️ ZIP / postcode the search should be anchored to.\n\n🇺🇸 5-digit US ZIP (e.g. `10001`)\n🇨🇦 Canadian FSA (e.g. `M5V`)\n🇬🇧 UK outward code (e.g. `SW1A`)"
                    },
                    "make": {
                        "title": "🚘 Make",
                        "enum": [
                            "Acura",
                            "Alfa Romeo",
                            "Aston Martin",
                            "Audi",
                            "Bentley",
                            "BMW",
                            "Buick",
                            "Cadillac",
                            "Chevrolet",
                            "Chrysler",
                            "Dodge",
                            "Ferrari",
                            "Fiat",
                            "Ford",
                            "Genesis",
                            "GMC",
                            "Honda",
                            "Hyundai",
                            "Infiniti",
                            "Jaguar",
                            "Jeep",
                            "Kia",
                            "Lamborghini",
                            "Land Rover",
                            "Lexus",
                            "Lincoln",
                            "Lotus",
                            "Maserati",
                            "Mazda",
                            "McLaren",
                            "Mercedes-Benz",
                            "MINI",
                            "Mitsubishi",
                            "Nissan",
                            "Polestar",
                            "Porsche",
                            "RAM",
                            "Rivian",
                            "Rolls-Royce",
                            "Subaru",
                            "Tesla",
                            "Toyota",
                            "Volkswagen",
                            "Volvo"
                        ],
                        "type": "string",
                        "description": "🏭 Vehicle brand to search for. Pick from the dropdown — the actor uses the CarGurus internal make-ID for accuracy and also filters client-side.",
                        "default": "Toyota"
                    },
                    "model": {
                        "title": "🚗 Model (optional)",
                        "type": "string",
                        "description": "🎯 Optional — narrow results to a specific model name (e.g. `Camry`, `RAV4`, `Civic`). Leave blank to fetch every model from the selected make.\n\n🧠 The model name must match what CarGurus shows in the listing (case-insensitive)."
                    },
                    "condition": {
                        "title": "🆕🛞 Condition",
                        "enum": [
                            "used",
                            "new"
                        ],
                        "type": "string",
                        "description": "✨ Filter by vehicle condition:\n\n🛞 `Used` → pre-owned standard + CPO + priority listings\n🆕 `New` → factory-fresh listings\n\n💡 Also applied when scraping the URLs in Step 1, if you want to enforce a condition.",
                        "default": "used"
                    },
                    "maxItems": {
                        "title": "📊 Maximum listings",
                        "minimum": 0,
                        "maximum": 100000,
                        "type": "integer",
                        "description": "📦 Cap how many *matching* listings to collect in total.\n\n0️⃣ Use 0 for no limit (we'll keep paginating until CarGurus stops returning new VINs).\n\n⚡ Lower = faster & lighter; higher = broader coverage.\n\n🧠 The page budget is sized automatically from this value — no extra knobs to tune.",
                        "default": 10
                    },
                    "proxyConfiguration": {
                        "title": "🛡️ Proxy configuration (optional)",
                        "type": "object",
                        "description": "🛰️ Optional Apify Proxy settings.\n\n🟢 Leave blank to use the smart 3-stage fallback: **no proxy → datacenter → residential (×3)**.\n\n🔵 Provide your own choice (e.g. RESIDENTIAL with country=US) to force a starting strategy — the actor will still fall back if that fails."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```