# Craigslist Vehicle Scraper + Instant Private Listing Results (`raidr-api/craigslist-vehicle-scraper`) Actor

Scrape Craigslist vehicles by make, model, year, price, and mileage. Features exact listing dates, smart age filtering, and deduplication. Optimized for lowest cost per run using advanced extraction techniques. Get instant vehicle results with filtering for private listings only.

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

## Pricing

from $1.25 / 1,000 dataset results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## 🚗 Craigslist Cars & Trucks Scraper

Scrape used cars and trucks from [Craigslist](https://www.craigslist.org/) in any city, with filtering by make/model, price, year, and seller type. Get full listing details — description, vehicle specs, photos, and location — and optional real-time Discord alerts when new listings appear. Export to JSON, CSV, Excel, or HTML.

### 🔍 What does Craigslist Cars & Trucks Scraper do?

**Craigslist Cars & Trucks Scraper** extracts **public vehicle listings** from Craigslist and delivers them as clean, structured data. Point it at any city, apply your filters, and get an organized dataset instead of endlessly refreshing search pages. Run it on the **Apify platform** for API access, scheduling, integrations, monitoring, and downloadable results.

- **Find deals faster** — monitor a city and get alerted the moment a matching car is posted
- **Track the market** — analyze pricing, popular models, and regional availability over time
- **Source inventory** — spot underpriced vehicles to flip or add to your lot
- **Generate leads** — build lists of active private sellers and dealers for permitted outreach
- **Feed your tools** — export to spreadsheets, dashboards, CRMs, or analytics pipelines

### 📊 What data can you extract from Craigslist?

Every listing includes core details, and you can optionally enrich each one with the full description, vehicle specs, and complete photo gallery:

| Data point | Always included | With full details |
|---|:-:|:-:|
| 🚗 **Title** | ✅ | ✅ |
| 💰 **Price** | ✅ | ✅ |
| 📍 **Location** (area, neighborhood) | ✅ | ✅ (+ precise coordinates, postal code) |
| 📅 **Posted date** | ✅ | ✅ |
| 📸 **Photos** | ✅ (thumbnails + full size) | ✅ (complete gallery) |
| 🛣️ **Mileage** | ✅ (when shown) | ✅ |
| 📝 **Full description** | — | ✅ |
| 🏭 **Make / model / year** | — | ✅ |
| ⚙️ **Transmission, fuel, body, drivetrain** | — | ✅ |
| 🎨 **Paint color & condition** | — | ✅ |
| 🔖 **VIN** | — | ✅ (when provided) |
| 🔗 **Listing URL** | ✅ | ✅ |

### 🚀 How to scrape Craigslist cars & trucks

No coding required — set it up in a couple of minutes.

1. **Create a free Apify account** using your email.
2. **Open Craigslist Cars & Trucks Scraper.**
3. **Enter a location** — a city and state/province (e.g. `Los Angeles, California` or `Toronto, Ontario`).
4. **Add filters** (optional) — make/model, price range, year range, seller type, or a free-text keyword.
5. **Choose how much detail** you want and click **Start**.
6. **Download your data** in JSON, CSV, Excel, or HTML — or pull it via API.

### ⬇️ Input

Configure everything visually, or paste JSON directly:

```json
{
    "location": "Los Angeles, California",
    "searchDistance": 50,
    "purveyor": "owner",
    "autoMakeModel": "Toyota Tacoma",
    "minPrice": 5000,
    "maxPrice": 25000,
    "minYear": 2015,
    "maxYear": 2022,
    "enrichDetails": "new-only",
    "discordWebhookUrl": ""
}
````

**Key options:**

- **Location** — a city and state/province; the scraper automatically targets the right Craigslist region for you.
- **Search radius** *(optional)* — pull in nearby areas within a set distance in miles.
- **Make & model / keyword** — narrow to a specific vehicle or search term.
- **Price & year** — set minimum and maximum bounds.
- **Seller type** — by owner, by dealer, or all.
- **Detail level** — collect the full description, specs, and photo gallery for every listing, only new ones, or none.
- **Skip previously seen listings** — remember listings between runs so you only see fresh inventory (ideal for scheduled monitoring).

### ⬆️ Output

Each vehicle is saved as a structured record. Core fields are always present; the `enriched` section is added when full details are enabled:

```json
{
    "pid": "7931994123",
    "title": "2018 Toyota Tacoma TRD Sport",
    "price": 28500,
    "priceFormatted": "$28,500",
    "postedAt": "2026-07-05T14:22:00.000Z",
    "location": {
        "description": "san fernando valley",
        "neighborhood": "Van Nuys",
        "lat": 34.19,
        "lon": -118.45
    },
    "autoMiles": 61200,
    "thumbnailUrl": "https://images.craigslist.org/…_50x50c.jpg",
    "fullImageUrls": ["https://images.craigslist.org/…_1200x900.jpg"],
    "detailUrl": "https://losangeles.craigslist.org/…/7931994123.html",
    "isNew": true,
    "enriched": {
        "description": "One owner, clean title, well maintained…",
        "year": "2018",
        "makeModel": "Toyota Tacoma",
        "attributes": {
            "transmission": "automatic",
            "fuel": "gas",
            "title status": "clean",
            "paint color": "grey"
        },
        "status": "active"
    }
}
```

You can download the dataset in various formats such as JSON, HTML, CSV, or Excel.

### 💰 How much does it cost to scrape Craigslist?

Craigslist Cars & Trucks Scraper runs on Apify's **pay-per-use** model — you only pay for the resources a run consumes, and this scraper is designed to be lightweight. Collecting core listing data is very cheap; adding full details costs a little more per listing. Use the detail-level setting and result caps to keep runs efficient.

**Free tier:** New Apify users get monthly free credits — enough to run this scraper on a schedule and monitor a city at no cost.

### 💬 Discord notifications for new listings

Never miss a deal. Add a Discord webhook and get an instant alert whenever a new matching car is posted:

1. Create a webhook in your Discord server (**Server Settings → Integrations → Webhooks**).
2. Copy the webhook URL.
3. Paste it into the **Discord Webhook URL** field.
4. Choose your preferences — notify only on new listings, and pick a thumbnail or full-size image.

Each alert includes the vehicle photo, title, price, location, posting time, and a direct link.

### 🔄 Deduplication across runs

The scraper remembers listings from previous runs, so you can:

- **Monitor new inventory** — run on a schedule and only see fresh listings
- **Avoid duplicates** — build a unique dataset over time
- **Get alerts for new items only** — no spam from listings you've already seen

### 🔗 Integrations

Connect Craigslist Cars & Trucks Scraper to your favorite tools:

- **Google Sheets** — auto-export new listings to a spreadsheet
- **Zapier & Make** — trigger workflows when new vehicles are found
- **Slack & Discord** — get notifications in your channels
- **Webhooks** — send data to any URL when a run finishes
- **API** — integrate directly with your own applications

### ❓ FAQ

#### How does Craigslist Cars & Trucks Scraper work?

It works just like searching Craigslist yourself — it opens the cars & trucks results for your chosen city, applies your filters, and collects the publicly visible details from each listing (and, optionally, opens each posting for the full description and specs), only far faster and at scale.

#### Can I monitor a city continuously?

Yes. Turn on **skip previously seen listings**, schedule the run (e.g. every few minutes or hourly), and add a Discord webhook to get alerted the moment a new car appears.

#### Can I scrape multiple cities?

Each run targets one location and radius. To cover several cities, run the scraper multiple times with different locations, or schedule a run per city.

#### Why are some fields missing?

Craigslist listings vary by seller. Core fields are always captured; specs like VIN, transmission, or paint color appear only when the seller filled them in and full-detail collection is enabled.

#### Is it legal to scrape Craigslist?

Scraping publicly available data is generally legal. This scraper only collects publicly visible listing information — no private user data or content behind access controls. Always use scraped data responsibly and in line with applicable laws and Craigslist's Terms of Use.

### 📞 Support and feedback

- **Questions or a bug?** Open an issue on the Actor's **Issues** tab.
- **Need a field added or a custom solution?** Let us know — we'd love to help.

***

*Craigslist Cars & Trucks Scraper is not affiliated with or endorsed by Craigslist. Use responsibly and in accordance with Craigslist's Terms of Use.*

# Actor input Schema

## `location` (type: `string`):

City and state/province, e.g. `Los Angeles, California`, `Dallas, Texas`, `Toronto, Ontario`. Automatically resolved to the nearest craigslist region. This is the easiest way to target an area — leave the advanced Search Path below empty when you use it. (Defaults to Los Angeles if both this and Search Path are empty.)

## `searchPath` (type: `string`):

Advanced: raw region + category path, used only when Location is empty. Format `{region}-{state}/{categoryAbbr}`, e.g. `los-angeles-ca/cta` (cars+trucks all), `los-angeles-ca/cto` (by owner), `los-angeles-ca/ctd` (by dealer), `newyork-ny/cta`, `chicago-il/cta`.

Category codes:

- `cta` = cars+trucks all
- `cto` = cars+trucks by owner
- `ctd` = cars+trucks by dealer

## `searchDistance` (type: `integer`):

Optional. Search radius in miles around the resolved location. When set, craigslist also pulls in listings from neighboring areas (e.g. SD, IE, OC) within this radius. Leave empty to get just the single metro.

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

Minimum price in dollars (server-side filter). 0 or empty = no minimum.

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

Maximum price in dollars (server-side filter). 0 or empty = no maximum.

## `purveyor` (type: `string`):

Filter on owner-listed vs dealer-listed.

## `bundleDuplicates` (type: `boolean`):

Hide listings that are reposts of others (server-side). Saves ~5% bandwidth and reduces noise.

## `query` (type: `string`):

Optional keyword filter (e.g. `Tesla`, `low miles`, `manual`). Matches against the title.

## `autoMakeModel` (type: `string`):

Server-side make/model filter (e.g. `Tesla Model S`, `Honda Civic`).

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

Server-side filter on model year.

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

Server-side filter on model year.

## `enrichDetails` (type: `string`):

When to fetch the per-posting HTML detail page.

## `maxNewListingsPerRun` (type: `integer`):

Hard cap on detail-page fetches per scraper run. Protects against bandwidth blowups on cold-start.

## `useDeduplication` (type: `boolean`):

Remember pids from previous runs in the actor's KV store and skip them. Required for sensible Discord notifications and detail-enrichment cost control on a polling schedule.

## `discordWebhookUrl` (type: `string`):

Discord webhook URL. Server Settings → Integrations → Webhooks → New Webhook → Copy URL. Leave empty to disable.

## `discordNotifyOnlyNew` (type: `boolean`):

Send a notification only for listings that weren't seen in a previous run.

## `discordImageDisplay` (type: `string`):

How to display the listing image in Discord.

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

Apify proxy or custom proxy settings.

## Actor input object example

```json
{
  "location": "Los Angeles, California",
  "minPrice": 0,
  "maxPrice": 0,
  "purveyor": "owner",
  "bundleDuplicates": true,
  "enrichDetails": "new-only",
  "maxNewListingsPerRun": 100,
  "useDeduplication": true,
  "discordNotifyOnlyNew": true,
  "discordImageDisplay": "thumbnail",
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

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

Quick view of all listings emitted by this run.

## `fullDetails` (type: `string`):

Listings flattened to surface enriched detail-page fields.

## `allListings` (type: `string`):

Full dataset including any nested enriched fields.

## `runStats` (type: `string`):

Wire bytes, request counts, duration, errors.

# 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 = {
    "location": "Los Angeles, California"
};

// Run the Actor and wait for it to finish
const run = await client.actor("raidr-api/craigslist-vehicle-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 = { "location": "Los Angeles, California" }

# Run the Actor and wait for it to finish
run = client.actor("raidr-api/craigslist-vehicle-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 '{
  "location": "Los Angeles, California"
}' |
apify call raidr-api/craigslist-vehicle-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Craigslist Vehicle Scraper + Instant Private Listing Results",
        "description": "Scrape Craigslist vehicles by make, model, year, price, and mileage. Features exact listing dates, smart age filtering, and deduplication. Optimized for lowest cost per run using advanced extraction techniques. Get instant vehicle results with filtering for private listings only.",
        "version": "0.0",
        "x-build-id": "ZWCj7JYuEo9IIDrFZ"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/raidr-api~craigslist-vehicle-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-raidr-api-craigslist-vehicle-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/raidr-api~craigslist-vehicle-scraper/runs": {
            "post": {
                "operationId": "runs-sync-raidr-api-craigslist-vehicle-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/raidr-api~craigslist-vehicle-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-raidr-api-craigslist-vehicle-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": {
                    "location": {
                        "title": "📍 Location",
                        "type": "string",
                        "description": "City and state/province, e.g. `Los Angeles, California`, `Dallas, Texas`, `Toronto, Ontario`. Automatically resolved to the nearest craigslist region. This is the easiest way to target an area — leave the advanced Search Path below empty when you use it. (Defaults to Los Angeles if both this and Search Path are empty.)"
                    },
                    "searchPath": {
                        "title": "🔎 Search Path (advanced override)",
                        "type": "string",
                        "description": "Advanced: raw region + category path, used only when Location is empty. Format `{region}-{state}/{categoryAbbr}`, e.g. `los-angeles-ca/cta` (cars+trucks all), `los-angeles-ca/cto` (by owner), `los-angeles-ca/ctd` (by dealer), `newyork-ny/cta`, `chicago-il/cta`.\n\nCategory codes:\n- `cta` = cars+trucks all\n- `cto` = cars+trucks by owner\n- `ctd` = cars+trucks by dealer"
                    },
                    "searchDistance": {
                        "title": "🎯 Search radius (miles)",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Optional. Search radius in miles around the resolved location. When set, craigslist also pulls in listings from neighboring areas (e.g. SD, IE, OC) within this radius. Leave empty to get just the single metro."
                    },
                    "minPrice": {
                        "title": "💲 Min price ($)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Minimum price in dollars (server-side filter). 0 or empty = no minimum.",
                        "default": 0
                    },
                    "maxPrice": {
                        "title": "💲 Max price ($)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum price in dollars (server-side filter). 0 or empty = no maximum.",
                        "default": 0
                    },
                    "purveyor": {
                        "title": "👤 Purveyor",
                        "enum": [
                            "owner",
                            "dealer",
                            "all"
                        ],
                        "type": "string",
                        "description": "Filter on owner-listed vs dealer-listed.",
                        "default": "owner"
                    },
                    "bundleDuplicates": {
                        "title": "🪞 Hide duplicate reposts",
                        "type": "boolean",
                        "description": "Hide listings that are reposts of others (server-side). Saves ~5% bandwidth and reduces noise.",
                        "default": true
                    },
                    "query": {
                        "title": "🔤 Free-text query",
                        "type": "string",
                        "description": "Optional keyword filter (e.g. `Tesla`, `low miles`, `manual`). Matches against the title."
                    },
                    "autoMakeModel": {
                        "title": "🚗 Make and model filter",
                        "type": "string",
                        "description": "Server-side make/model filter (e.g. `Tesla Model S`, `Honda Civic`)."
                    },
                    "minYear": {
                        "title": "📅 Min model year",
                        "minimum": 1900,
                        "maximum": 2100,
                        "type": "integer",
                        "description": "Server-side filter on model year."
                    },
                    "maxYear": {
                        "title": "📅 Max model year",
                        "minimum": 1900,
                        "maximum": 2100,
                        "type": "integer",
                        "description": "Server-side filter on model year."
                    },
                    "enrichDetails": {
                        "title": "🔬 Enrichment mode",
                        "enum": [
                            "never",
                            "new-only",
                            "always"
                        ],
                        "type": "string",
                        "description": "When to fetch the per-posting HTML detail page.",
                        "default": "new-only"
                    },
                    "maxNewListingsPerRun": {
                        "title": "🔢 Max enrichments per run",
                        "minimum": 0,
                        "maximum": 360,
                        "type": "integer",
                        "description": "Hard cap on detail-page fetches per scraper run. Protects against bandwidth blowups on cold-start.",
                        "default": 100
                    },
                    "useDeduplication": {
                        "title": "🔄 Skip previously seen listings",
                        "type": "boolean",
                        "description": "Remember pids from previous runs in the actor's KV store and skip them. Required for sensible Discord notifications and detail-enrichment cost control on a polling schedule.",
                        "default": true
                    },
                    "discordWebhookUrl": {
                        "title": "🔗 Webhook URL",
                        "type": "string",
                        "description": "Discord webhook URL. Server Settings → Integrations → Webhooks → New Webhook → Copy URL. Leave empty to disable."
                    },
                    "discordNotifyOnlyNew": {
                        "title": "🆕 Notify only on new",
                        "type": "boolean",
                        "description": "Send a notification only for listings that weren't seen in a previous run.",
                        "default": true
                    },
                    "discordImageDisplay": {
                        "title": "🖼️ Image style",
                        "enum": [
                            "thumbnail",
                            "full",
                            "none"
                        ],
                        "type": "string",
                        "description": "How to display the listing image in Discord.",
                        "default": "thumbnail"
                    },
                    "proxyConfiguration": {
                        "title": "🌐 Proxy configuration",
                        "type": "object",
                        "description": "Apify proxy or custom proxy settings.",
                        "default": {
                            "useApifyProxy": false
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```