# Craigslist Vehicles Scraper (`fmchisti/craigslist-vehicles-scraper`) Actor

Scrape Craigslist Cars & Trucks listings by search URL or keyword. Extract vehicle titles, prices, year, mileage, condition, location, seller details, descriptions, images, and more into structured data.

- **URL**: https://apify.com/fmchisti/craigslist-vehicles-scraper.md
- **Developed by:** [Fahim Mahmud Chisti](https://apify.com/fmchisti) (community)
- **Categories:** Automation, Integrations, Developer tools
- **Stats:** 3 total users, 2 monthly users, 97.7% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.50 / 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/docs.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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

### What does Craigslist Vehicles Scraper do?

Craigslist Vehicles Scraper extracts structured Cars & Trucks listings from regional [Craigslist](https://www.craigslist.org/) search pages and individual postings. It collects titles, prices, publication dates, vehicle attributes, locations, descriptions, and images. Runs can be started manually, scheduled, monitored, and exported through the Apify platform.

### Why use Craigslist Vehicles Scraper?

- Monitor newly posted used vehicles in a local market.
- Research asking prices, makes, models, mileage, and condition.
- Build lead lists from public vehicle postings.
- Track inventory across one or more filtered Craigslist searches.
- Export consistent JSON, CSV, Excel, or API-ready dataset results.

### How to scrape Craigslist vehicle listings

1. Open the Actor's **Input** tab.
2. Add search keywords, Craigslist Cars & Trucks URLs, or direct posting URLs.
3. Choose the maximum items and pages.
4. Keep **Scrape item details** enabled for richer vehicle attributes and images.
5. Start the Actor and open the **Output** tab when the run finishes.

For example, use `https://yuma.craigslist.org/search/cta?sort=date` to scrape Yuma Cars & Trucks. URL filters are preserved.

### Input

- `searchKeywords`: keywords searched within Cars & Trucks.
- `startUrls`: regional search URLs or direct posting URLs.
- `domain`: regional Craigslist domain used for keyword searches.
- `maxItems`: maximum saved listings across all searches; `0` means unlimited.
- `maxPagesPerSearch`: pagination limit per search.
- `maxListingAgeDays`: optional maximum posting age.
- `scrapeItemDetails`: opens each posting for descriptions, attributes, and images.
- `duplicateCheck`: skip detail scraping for listing URLs already known (default `false`).
- `duplicateCheckApiUrl`: optional POST exists API; leave empty for Apify storage only.
- `duplicateCheckStoreName`: named KV store (default `vehicle-listing-urls`).
- `proxyConfiguration`: Apify proxy settings. Residential US proxies are recommended because Craigslist may reject datacenter traffic.

Example:

```json
{
    "startUrls": [{ "url": "https://yuma.craigslist.org/search/cta?sort=date" }],
    "maxItems": 50,
    "maxPagesPerSearch": 2,
    "maxListingAgeDays": 30,
    "scrapeItemDetails": true
}
````

### Skip existing listings (duplicate check)

Detail scraping makes one residential-proxy request per posting. On scheduled re-runs, most results are often listings you already stored. Duplicate check skips those URLs so you do not pay again for detail pages you already have.

Enable it with `duplicateCheck: true` (default `false`).

**Modes**

- When **`duplicateCheckApiUrl`** is set, the Actor POSTs batches of up to 500 listing URLs to your endpoint, then skips URLs returned in `existing`. It also reads and updates the named Apify Key-Value store. A URL is skipped if **either** your API or the store marks it as known.
- When **`duplicateCheckApiUrl`** is empty, the Actor uses the **Apify Key-Value store only** (no external API).

**API contract**

```json
// Request
{ "listingUrls": ["https://example.com/listing/1", "https://example.com/listing/2"] }

// Response
{
  "existing": ["https://example.com/listing/1"],
  "missing": ["https://example.com/listing/2"]
}
```

`listingUrls` may also be a single string. URLs are normalized (query string and trailing slash ignored). No auth header is required for public endpoints. If the API call fails, the Actor fail-opens and scrapes the batch.

After a listing is saved successfully, its URL is written to the named store under the `KNOWN_LISTING_URLS` record so future runs skip it even without an API.

Example:

```json
{
    "startUrls": [{ "url": "https://yuma.craigslist.org/search/cta?sort=date" }],
    "maxItems": 100,
    "duplicateCheck": true,
    "duplicateCheckApiUrl": "https://your-api.example.com/listings/exists",
    "duplicateCheckStoreName": "vehicle-listing-urls"
}
```

### Output

Each vehicle is saved as one dataset item:

```json
{
    "itemId": "1234567890",
    "title": "2018 Toyota Tacoma 4x4",
    "listedAt": "2026-07-18T14:20:00-0700",
    "price": "24900",
    "currency": "USD",
    "year": "2018",
    "make": "Toyota",
    "model": "Tacoma 4x4",
    "mileage": "82000",
    "condition": "excellent",
    "location": "Yuma",
    "imageUrl": "https://images.craigslist.org/example.jpg",
    "images": ["https://images.craigslist.org/example.jpg"],
    "url": "https://yuma.craigslist.org/cto/d/yuma-example/1234567890.html"
}
```

You can download the dataset in JSON, HTML, CSV, XML, RSS, or Excel format.

### Data fields

The output follows the same vehicle-oriented contract as the eBay Vehicles Scraper: `itemId`, `title`, `subtitle`, `description`, `listedAt`, `price`, `currency`, `condition`, `location`, `seller`, `year`, `mileage`, `make`, `model`, `trim`, `vin`, `bodyType`, `engine`, `transmission`, `driveType`, `fuelType`, colors, title status, seller type, `specifics`, images, URL, source URL, page, and scrape timestamp. Fields Craigslist does not publish remain `null`.

### Cost and performance

Search-only mode is fastest. Detail mode makes one additional request per posting and therefore takes longer and uses more proxy traffic. Set `maxItems`, `maxPagesPerSearch`, and `maxListingAgeDays` to bound cost. Enable `duplicateCheck` on scheduled re-runs to skip known postings. Set `scrapeItemDetails: false` when search-card fields are enough. Prefer skipping known listings over raising memory. The scraper processes requests conservatively to avoid overloading Craigslist.

### Tips

- Use a filtered Cars & Trucks URL for advanced options such as owner/dealer, price, mileage, and model year.
- Sort order is automatically set to newest first.
- Enable `duplicateCheck` on scheduled re-runs to skip postings you already stored.
- Set `scrapeItemDetails: false` when search-card fields are enough.
- Prefer skipping known listings over raising memory.
- If a run receives blocked pages, enable an Apify residential US proxy.
- The run Container URL exposes `/` and `/status` with live progress while the Actor is running.

### FAQ, legal notice, and support

Scrape only public data and comply with applicable laws, Craigslist's terms, and reasonable request rates. Listings can be edited or removed at any time, and some fields may be absent. Personal contact information is not intentionally extracted. If Craigslist changes its HTML, report the affected URL and run ID through the Actor's Issues tab.

# Actor input Schema

## `searchKeywords` (type: `array`):

Used only when Start URLs are empty. Vehicle keywords to search on the selected Craigslist site. Each keyword creates a separate Cars & Trucks search.

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

Craigslist Cars & Trucks search URLs or direct vehicle posting URLs. When provided, the Actor crawls only these URLs and ignores keywords. Search filters in the URL are preserved.

## `domain` (type: `string`):

Craigslist regional domain used for keyword searches, for example yuma.craigslist.org.

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

Maximum vehicle listings to save across all searches. Set to 0 for no item limit.

## `maxPagesPerSearch` (type: `integer`):

Maximum Craigslist result pages to process for each keyword or search URL.

## `maxListingAgeDays` (type: `integer`):

Optional. Save only posts published within this many days. Posts without a known date are excluded.

## `scrapeItemDetails` (type: `boolean`):

Open each posting to extract description, condition, mileage, VIN, attributes, and all images. Slower but provides richer output.

## `duplicateCheck` (type: `boolean`):

When enabled, skip detail scraping for listing URLs already known from your duplicate-check API and/or a named Apify Key-Value store. Saves proxy and compute cost on re-runs.

## `duplicateCheckApiUrl` (type: `string`):

Optional. POST endpoint that accepts { "listingUrls": string|string\[] } and returns { "existing": string\[], "missing": string\[] }. Leave empty to use Apify Key-Value store only.

## `duplicateCheckStoreName` (type: `string`):

Named Apify Key-Value store that remembers listing URLs across runs. Used whenever Skip existing listings is enabled.

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

Proxy settings. Residential US proxies are recommended when Craigslist blocks cloud or datacenter traffic.

## Actor input object example

```json
{
  "searchKeywords": [],
  "startUrls": [
    {
      "url": "https://www.craigslist.org/search/city/sneedville-tn?auto_title_status=1&bundleDuplicates=1&cat=cta&lat=36.4752&lon=-83.3203&max_auto_miles=60000&min_auto_year=1975&min_price=10000&purveyor=owner&radius=1000#search=2~gallery~0"
    },
    {
      "url": "https://www.craigslist.org/search/city/aspen-co?auto_title_status=1&bundleDuplicates=1&cat=cta&lat=39.2306&lon=-106.7871&max_auto_miles=60000&min_auto_year=1975&min_price=10000&purveyor=owner&radius=1000#search=2~gallery~0"
    }
  ],
  "domain": "yuma.craigslist.org",
  "maxItems": 100,
  "maxPagesPerSearch": 3,
  "scrapeItemDetails": true,
  "duplicateCheck": false,
  "duplicateCheckApiUrl": "https://ccscraperapi.up.railway.app/api/listings/exists",
  "duplicateCheckStoreName": "vehicle-listing-urls",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  }
}
```

# Actor output Schema

## `results` (type: `string`):

No description

## `scrapeState` (type: `string`):

No description

## `debugItems` (type: `string`):

No description

## `debugPages` (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 = {
    "searchKeywords": [],
    "startUrls": [
        {
            "url": "https://www.craigslist.org/search/city/sneedville-tn?auto_title_status=1&bundleDuplicates=1&cat=cta&lat=36.4752&lon=-83.3203&max_auto_miles=60000&min_auto_year=1975&min_price=10000&purveyor=owner&radius=1000#search=2~gallery~0"
        },
        {
            "url": "https://www.craigslist.org/search/city/aspen-co?auto_title_status=1&bundleDuplicates=1&cat=cta&lat=39.2306&lon=-106.7871&max_auto_miles=60000&min_auto_year=1975&min_price=10000&purveyor=owner&radius=1000#search=2~gallery~0"
        }
    ],
    "domain": "yuma.craigslist.org",
    "duplicateCheckApiUrl": "https://ccscraperapi.up.railway.app/api/listings/exists",
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "apifyProxyCountry": "US"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("fmchisti/craigslist-vehicles-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 = {
    "searchKeywords": [],
    "startUrls": [
        { "url": "https://www.craigslist.org/search/city/sneedville-tn?auto_title_status=1&bundleDuplicates=1&cat=cta&lat=36.4752&lon=-83.3203&max_auto_miles=60000&min_auto_year=1975&min_price=10000&purveyor=owner&radius=1000#search=2~gallery~0" },
        { "url": "https://www.craigslist.org/search/city/aspen-co?auto_title_status=1&bundleDuplicates=1&cat=cta&lat=39.2306&lon=-106.7871&max_auto_miles=60000&min_auto_year=1975&min_price=10000&purveyor=owner&radius=1000#search=2~gallery~0" },
    ],
    "domain": "yuma.craigslist.org",
    "duplicateCheckApiUrl": "https://ccscraperapi.up.railway.app/api/listings/exists",
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "US",
    },
}

# Run the Actor and wait for it to finish
run = client.actor("fmchisti/craigslist-vehicles-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 '{
  "searchKeywords": [],
  "startUrls": [
    {
      "url": "https://www.craigslist.org/search/city/sneedville-tn?auto_title_status=1&bundleDuplicates=1&cat=cta&lat=36.4752&lon=-83.3203&max_auto_miles=60000&min_auto_year=1975&min_price=10000&purveyor=owner&radius=1000#search=2~gallery~0"
    },
    {
      "url": "https://www.craigslist.org/search/city/aspen-co?auto_title_status=1&bundleDuplicates=1&cat=cta&lat=39.2306&lon=-106.7871&max_auto_miles=60000&min_auto_year=1975&min_price=10000&purveyor=owner&radius=1000#search=2~gallery~0"
    }
  ],
  "domain": "yuma.craigslist.org",
  "duplicateCheckApiUrl": "https://ccscraperapi.up.railway.app/api/listings/exists",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  }
}' |
apify call fmchisti/craigslist-vehicles-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Craigslist Vehicles Scraper",
        "description": "Scrape Craigslist Cars & Trucks listings by search URL or keyword. Extract vehicle titles, prices, year, mileage, condition, location, seller details, descriptions, images, and more into structured data.",
        "version": "0.1",
        "x-build-id": "hZ3oMPurkUmbxhbGu"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/fmchisti~craigslist-vehicles-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-fmchisti-craigslist-vehicles-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/fmchisti~craigslist-vehicles-scraper/runs": {
            "post": {
                "operationId": "runs-sync-fmchisti-craigslist-vehicles-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/fmchisti~craigslist-vehicles-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-fmchisti-craigslist-vehicles-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": {
                    "searchKeywords": {
                        "title": "Search keywords",
                        "type": "array",
                        "description": "Used only when Start URLs are empty. Vehicle keywords to search on the selected Craigslist site. Each keyword creates a separate Cars & Trucks search.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "startUrls": {
                        "title": "Start URLs",
                        "type": "array",
                        "description": "Craigslist Cars & Trucks search URLs or direct vehicle posting URLs. When provided, the Actor crawls only these URLs and ignores keywords. Search filters in the URL are preserved.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "domain": {
                        "title": "Craigslist site domain",
                        "type": "string",
                        "description": "Craigslist regional domain used for keyword searches, for example yuma.craigslist.org.",
                        "default": "yuma.craigslist.org"
                    },
                    "maxItems": {
                        "title": "Max items",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum vehicle listings to save across all searches. Set to 0 for no item limit.",
                        "default": 100
                    },
                    "maxPagesPerSearch": {
                        "title": "Max pages per search",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Maximum Craigslist result pages to process for each keyword or search URL.",
                        "default": 3
                    },
                    "maxListingAgeDays": {
                        "title": "Only listings from the last (days)",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Optional. Save only posts published within this many days. Posts without a known date are excluded."
                    },
                    "scrapeItemDetails": {
                        "title": "Scrape item details",
                        "type": "boolean",
                        "description": "Open each posting to extract description, condition, mileage, VIN, attributes, and all images. Slower but provides richer output.",
                        "default": true
                    },
                    "duplicateCheck": {
                        "title": "Skip existing listings",
                        "type": "boolean",
                        "description": "When enabled, skip detail scraping for listing URLs already known from your duplicate-check API and/or a named Apify Key-Value store. Saves proxy and compute cost on re-runs.",
                        "default": false
                    },
                    "duplicateCheckApiUrl": {
                        "title": "Duplicate check API URL",
                        "type": "string",
                        "description": "Optional. POST endpoint that accepts { \"listingUrls\": string|string[] } and returns { \"existing\": string[], \"missing\": string[] }. Leave empty to use Apify Key-Value store only."
                    },
                    "duplicateCheckStoreName": {
                        "title": "Duplicate check store name",
                        "type": "string",
                        "description": "Named Apify Key-Value store that remembers listing URLs across runs. Used whenever Skip existing listings is enabled.",
                        "default": "vehicle-listing-urls"
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Proxy settings. Residential US proxies are recommended when Craigslist blocks cloud or datacenter traffic.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ],
                            "apifyProxyCountry": "US"
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
