# AutoTempest Car Listings Scraper (`automation-lab/autotempest-car-listings-scraper`) Actor

Extract AutoTempest vehicle listings with price, mileage, VIN, dealer, location, source marketplace, image, and listing URL.

- **URL**: https://apify.com/automation-lab/autotempest-car-listings-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** E-commerce
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## AutoTempest Car Listings Scraper

Extract structured vehicle listings from AutoTempest searches.

### What does AutoTempest Car Listings Scraper do?

AutoTempest Car Listings Scraper turns public AutoTempest search results into a clean Apify dataset.

It collects vehicle listing data such as price, mileage, VIN, dealer, seller type, source marketplace, location, image URL, listing URL, and scrape timestamp.

Use it when you need repeatable used-car market data without manually copying listing cards from AutoTempest.

### Who is it for?

- 🚗 Used-car dealers monitoring local inventory
- 📈 Automotive analysts tracking price and mileage bands
- 🧾 Vehicle sourcing teams building lead lists
- 🔁 Resellers and flippers watching fresh listings
- 🏷️ Pricing teams comparing inventory across marketplaces
- 🧑‍💻 Developers feeding car listing data into internal tools

### Why use it?

AutoTempest aggregates listings from multiple automotive sources.

This actor gives you one normalized dataset that is easier to export, filter, schedule, and integrate than browser search pages.

You can run searches by make, model, ZIP code, radius, year, price, mileage, and AutoTempest result URLs.

### What data can it extract?

| Field | Description |
|---|---|
| `title` | Listing title from AutoTempest |
| `year` | Vehicle model year |
| `make` | Vehicle make |
| `model` | Vehicle model |
| `trim` | Trim when available |
| `price` | Numeric price |
| `priceText` | Price as displayed |
| `mileage` | Numeric mileage |
| `mileageText` | Mileage as displayed |
| `vin` | Vehicle identification number when exposed |
| `dealerName` | Dealer or seller name |
| `sellerType` | Dealer/private/other seller type |
| `location` | Listing location |
| `locationCode` | ZIP or location code |
| `distanceMiles` | Distance from the search ZIP |
| `sourceMarketplace` | AutoTempest source marketplace |
| `sourceSiteCode` | Source site code |
| `listingUrl` | Listing or detail URL |
| `imageUrl` | Vehicle image URL |
| `details` | Feature/detail summary |
| `vehicleTitle` | Clean/salvage/title status where available |
| `dateListed` | Listing date from AutoTempest |
| `priceHistory` | Optional price history array |
| `searchUrl` | Search URL that produced the row |
| `scrapedAt` | ISO timestamp for the scrape |

### How much does it cost to scrape AutoTempest car listings?

This actor uses pay-per-event pricing.

You pay a small run-start fee plus a per-listing fee for saved dataset items. The live platform pricing uses a $0.005 run-start event plus canonical tiered per-listing pricing:

| Plan tier | Per saved listing |
|---|---:|
| FREE | $0.000025813 |
| BRONZE | $0.000022446 |
| SILVER | $0.000017508 |
| GOLD | $0.000013468 |
| PLATINUM | $0.00001 |
| DIAMOND | $0.00001 |

Example cost before Apify account discounts: a 100-listing FREE-tier run is about `$0.005 + (100 × $0.000025813) = $0.0075813`; a 1,000-listing BRONZE-tier run is about `$0.005 + (1000 × $0.000022446) = $0.027446`.

The default input is intentionally small enough for a quick first run, and `maxItems` lets you cap spend.

### How to scrape AutoTempest listings

1. Open the actor on Apify.
2. Enter a make such as `toyota`.
3. Enter a model such as `camry` or leave it empty for all models.
4. Enter a ZIP code such as `10001`.
5. Choose a radius and optional filters.
6. Set `maxItems`.
7. Run the actor.
8. Export the dataset as JSON, CSV, Excel, or via API.

### Search by AutoTempest URL

Paste one or more AutoTempest `/results` URLs into `startUrls`.

The actor reads the URL query parameters and uses them for that search.

This is useful when a teammate already has a search URL from the AutoTempest website.

### Search by make, model, and ZIP

Use the form fields when you want a repeatable scheduled search.

Example:

```json
{
  "make": "toyota",
  "model": "camry",
  "zip": "10001",
  "radius": 100,
  "maxItems": 100
}
````

### Input options

- `make` — vehicle make accepted by AutoTempest
- `model` — optional model
- `keywords` — optional search text
- `zip` — search center ZIP/postal code
- `radius` — search distance in miles
- `startUrls` — existing AutoTempest result URLs
- `maxItems` — maximum listings to save
- `minYear` / `maxYear` — model-year filters
- `minPrice` / `maxPrice` — price filters
- `minMileage` / `maxMileage` — mileage filters
- `sort` — AutoTempest sort order
- `includePriceHistory` — include listing price history when available
- `proxyConfiguration` — optional Apify Proxy settings

### Output example

```json
{
  "title": "2023 Toyota Camry SE",
  "year": 2023,
  "make": "Toyota",
  "model": "Camry",
  "trim": "SE",
  "price": 22998,
  "mileage": 39561,
  "vin": "4T1G11BK9PU074158",
  "dealerName": "Global Auto Mall",
  "sellerType": "Dealer",
  "location": "North Plainfield, NJ",
  "distanceMiles": 22,
  "sourceMarketplace": "AutoByTel",
  "listingUrl": "https://www.autotempest.com/details/abt-536922606",
  "imageUrl": "https://thumb.autotempest.com/example.webp",
  "scrapedAt": "2026-07-09T05:35:00.649Z"
}
```

### Tips for better results

- Use broad searches when you need market comps.
- Use year, price, and mileage filters when you need lead lists.
- Use multiple start URLs for different markets.
- Schedule daily runs to monitor inventory changes.
- Keep `maxItems` low while testing a new workflow.

### Integrations

Use this scraper with:

- Google Sheets for dealer inventory tracking
- Airtable for lead-review workflows
- BI tools for price trend dashboards
- CRMs for sourcing teams
- Webhooks for fresh-listing alerts
- Data warehouses for historical automotive analysis

### API usage with Node.js

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/autotempest-car-listings-scraper').call({
  make: 'toyota',
  model: 'camry',
  zip: '10001',
  radius: 100,
  maxItems: 100,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

### API usage with Python

```python
from apify_client import ApifyClient

client = ApifyClient('YOUR_APIFY_TOKEN')
run = client.actor('automation-lab/autotempest-car-listings-scraper').call(run_input={
    'make': 'toyota',
    'model': 'camry',
    'zip': '10001',
    'radius': 100,
    'maxItems': 100,
})

items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

### API usage with cURL

```bash
curl -X POST "https://api.apify.com/v2/acts/automation-lab~autotempest-car-listings-scraper/runs?token=$APIFY_TOKEN" \
  -H 'Content-Type: application/json' \
  -d '{"make":"toyota","model":"camry","zip":"10001","radius":100,"maxItems":100}'
```

### MCP integration

Connect the actor to AI tools through Apify MCP.

MCP URL:

```text
https://mcp.apify.com/?tools=automation-lab/autotempest-car-listings-scraper
```

Claude Code setup:

```bash
claude mcp add --transport http apify-autotempest "https://mcp.apify.com/?tools=automation-lab/autotempest-car-listings-scraper"
```

JSON MCP server config:

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

Example prompt ideas using MCP:

- "Use the AutoTempest MCP scraper to run Toyota Camry near 10001 and summarize the cheapest cars."
- "Use MCP to find Honda Accord listings under $25,000 near 90210 and group them by mileage band."
- "Use the AutoTempest actor through MCP to monitor used Tesla listings around Austin and flag listings below the market median."

### Scheduling and monitoring

Schedule the actor daily or weekly to monitor changing inventory.

Use the `vin`, `listingUrl`, and `price` fields to detect new listings, removed listings, or price drops.

### Data quality notes

AutoTempest data depends on what source marketplaces expose.

Some listings may not include VIN, image, dealer name, or full price history.

The actor keeps missing values as `null` rather than inventing data.

### Proxy and anti-blocking notes

The default mode uses direct HTTP because AutoTempest public search currently allows normal requests.

If your environment is blocked, enable Apify Proxy in `proxyConfiguration` and keep concurrency conservative.

### Limitations

- It extracts public listing search data, not private account data.
- It does not contact sellers or enrich VINs from third-party databases.
- It does not bypass paywalls, login-only pages, or captchas.
- Source marketplace availability may vary by ZIP, make, and model.

### Legality

Only scrape publicly available data.

Respect AutoTempest terms, source marketplace rights, and applicable laws.

Use reasonable limits and avoid excessive traffic.

Do not use the output for spam, harassment, or unlawful discrimination.

### FAQ

#### Why did I get zero listings?

Try a broader radius, remove strict filters, check the ZIP code, or test the same search on AutoTempest.

#### Why are some VINs missing?

Not every source marketplace exposes a VIN in the search payload.

#### Why are some listing URLs on AutoTempest?

AutoTempest sometimes routes details through its own detail page before the source marketplace.

### Related scrapers

Other automation-lab actors that pair well with this workflow:

- https://apify.com/automation-lab/google-search-results-scraper
- https://apify.com/automation-lab/website-contact-finder
- https://apify.com/automation-lab/yelp-business-scraper

### Support

If a search behaves differently from the AutoTempest website, share the input JSON and a run URL so we can reproduce it.

### Changelog

- Initial version: AutoTempest listing search extraction with structured vehicle fields.

# Actor input Schema

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

Vehicle make accepted by AutoTempest, for example toyota, ford, honda, bmw, or tesla.

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

Vehicle model accepted by AutoTempest. Leave empty for all models from the selected make.

## `keywords` (type: `string`):

Optional free-text keywords to narrow the listings, such as hybrid, awd, manual, or clean title.

## `zip` (type: `string`):

ZIP or postal code used as the center of the AutoTempest search.

## `radius` (type: `integer`):

Distance around the ZIP code. Use common AutoTempest values such as 50, 100, 250, 500, or 1000.

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

Optional AutoTempest /results URLs. When provided, URL filters override the make/model/ZIP fields for those searches.

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

Maximum number of car listing records to save across all searches.

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

Only return vehicles from this model year or newer. Leave empty for no minimum.

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

Only return vehicles from this model year or older. Leave empty for no maximum.

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

Only return listings priced at or above this amount in USD.

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

Only return listings priced at or below this amount in USD.

## `minMileage` (type: `integer`):

Only return vehicles with at least this many miles.

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

Only return vehicles with no more than this many miles.

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

AutoTempest sort order for the source search.

## `includePriceHistory` (type: `boolean`):

Add AutoTempest price history arrays when available. Disable for slimmer output.

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

Optional Apify Proxy configuration. The default is direct HTTP because AutoTempest currently allows public requests.

## Actor input object example

```json
{
  "make": "toyota",
  "model": "camry",
  "zip": "10001",
  "radius": 100,
  "startUrls": [
    {
      "url": "https://www.autotempest.com/results?make=toyota&model=camry&zip=10001&radius=100"
    }
  ],
  "maxItems": 20,
  "sort": "best_match",
  "includePriceHistory": false,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `overview` (type: `string`):

No description

# API

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

## JavaScript example

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

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

// Prepare Actor input
const input = {
    "make": "toyota",
    "model": "camry",
    "zip": "10001",
    "radius": 100,
    "startUrls": [
        {
            "url": "https://www.autotempest.com/results?make=toyota&model=camry&zip=10001&radius=100"
        }
    ],
    "maxItems": 20,
    "sort": "best_match",
    "includePriceHistory": false,
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/autotempest-car-listings-scraper").call(input);

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

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

```

## Python example

```python
from apify_client import ApifyClient

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

# Prepare the Actor input
run_input = {
    "make": "toyota",
    "model": "camry",
    "zip": "10001",
    "radius": 100,
    "startUrls": [{ "url": "https://www.autotempest.com/results?make=toyota&model=camry&zip=10001&radius=100" }],
    "maxItems": 20,
    "sort": "best_match",
    "includePriceHistory": False,
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/autotempest-car-listings-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "make": "toyota",
  "model": "camry",
  "zip": "10001",
  "radius": 100,
  "startUrls": [
    {
      "url": "https://www.autotempest.com/results?make=toyota&model=camry&zip=10001&radius=100"
    }
  ],
  "maxItems": 20,
  "sort": "best_match",
  "includePriceHistory": false,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call automation-lab/autotempest-car-listings-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "AutoTempest Car Listings Scraper",
        "description": "Extract AutoTempest vehicle listings with price, mileage, VIN, dealer, location, source marketplace, image, and listing URL.",
        "version": "0.1",
        "x-build-id": "s9VuaimBQXivKTa8t"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~autotempest-car-listings-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-autotempest-car-listings-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/automation-lab~autotempest-car-listings-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-autotempest-car-listings-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/automation-lab~autotempest-car-listings-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-autotempest-car-listings-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "maxItems"
                ],
                "properties": {
                    "make": {
                        "title": "Make",
                        "type": "string",
                        "description": "Vehicle make accepted by AutoTempest, for example toyota, ford, honda, bmw, or tesla."
                    },
                    "model": {
                        "title": "Model",
                        "type": "string",
                        "description": "Vehicle model accepted by AutoTempest. Leave empty for all models from the selected make."
                    },
                    "keywords": {
                        "title": "Keywords",
                        "type": "string",
                        "description": "Optional free-text keywords to narrow the listings, such as hybrid, awd, manual, or clean title."
                    },
                    "zip": {
                        "title": "ZIP code",
                        "type": "string",
                        "description": "ZIP or postal code used as the center of the AutoTempest search."
                    },
                    "radius": {
                        "title": "Search radius (miles)",
                        "minimum": 10,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Distance around the ZIP code. Use common AutoTempest values such as 50, 100, 250, 500, or 1000.",
                        "default": 100
                    },
                    "startUrls": {
                        "title": "AutoTempest results URLs",
                        "type": "array",
                        "description": "Optional AutoTempest /results URLs. When provided, URL filters override the make/model/ZIP fields for those searches.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxItems": {
                        "title": "Maximum listings",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of car listing records to save across all searches.",
                        "default": 20
                    },
                    "minYear": {
                        "title": "Minimum year",
                        "minimum": 1900,
                        "maximum": 2100,
                        "type": "integer",
                        "description": "Only return vehicles from this model year or newer. Leave empty for no minimum."
                    },
                    "maxYear": {
                        "title": "Maximum year",
                        "minimum": 1900,
                        "maximum": 2100,
                        "type": "integer",
                        "description": "Only return vehicles from this model year or older. Leave empty for no maximum."
                    },
                    "minPrice": {
                        "title": "Minimum price",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only return listings priced at or above this amount in USD."
                    },
                    "maxPrice": {
                        "title": "Maximum price",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only return listings priced at or below this amount in USD."
                    },
                    "minMileage": {
                        "title": "Minimum mileage",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only return vehicles with at least this many miles."
                    },
                    "maxMileage": {
                        "title": "Maximum mileage",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only return vehicles with no more than this many miles."
                    },
                    "sort": {
                        "title": "Sort order",
                        "enum": [
                            "best_match",
                            "date_desc",
                            "date_asc",
                            "dist_asc",
                            "year_asc",
                            "year_desc",
                            "price_asc",
                            "price_desc",
                            "mileage_asc",
                            "mileage_desc"
                        ],
                        "type": "string",
                        "description": "AutoTempest sort order for the source search.",
                        "default": "best_match"
                    },
                    "includePriceHistory": {
                        "title": "Include price history",
                        "type": "boolean",
                        "description": "Add AutoTempest price history arrays when available. Disable for slimmer output.",
                        "default": false
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Optional Apify Proxy configuration. The default is direct HTTP because AutoTempest currently allows public requests."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
