# OfferUp Vehicle Scraper + Instant Results (`raidr-api/offerup-vehicle-scraper`) Actor

Scrape OfferUp for 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/offerup-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.99 / 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.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

## 🚗 OfferUp Vehicle Scraper

Scrape used cars, trucks, SUVs, and other vehicles from [OfferUp](https://offerup.com/) by ZIP code, with rich filtering by make, year, price, mileage, body style, transmission, drivetrain, condition, and fuel efficiency. Export clean vehicle listing data to JSON, CSV, Excel, or HTML — or send it straight to your own tools.

### 🔍 What does OfferUp Vehicle Scraper do?

**OfferUp Vehicle Scraper** extracts **public vehicle listings** from OfferUp and turns them into structured, ready-to-use data. Instead of scrolling the app for hours, you get a clean dataset you can sort, filter, and analyze in seconds. Run it on the **Apify platform** for API access, scheduling, integrations, monitoring, and downloadable datasets.

- **Monitor local inventory** — track used-car listings across any ZIP code and radius
- **Compare prices** — see how asking prices differ by area, make, model, and year
- **Source deals** — spot underpriced vehicles worth flipping or adding to your lot
- **Generate leads** — build prospect lists of active sellers for permitted outreach
- **Feed your tools** — export to spreadsheets, dashboards, CRMs, or analytics pipelines

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

Every listing includes the core fields below, with extra vehicle details filled in whenever OfferUp publishes them:

| 🚗 Vehicle title | 💰 Price | 📍 Location (city, state) |
|---|---|---|
| 🏷️ Condition | 🛣️ Mileage | 📸 Listing photo |
| 🔗 Listing URL | 🆔 Listing ID | 📅 Newest-first ordering |

### 🚀 How to scrape OfferUp vehicles

OfferUp Vehicle Scraper is built for beginners and pros alike — no coding required.

1. **Create a free Apify account** using your email.
2. **Open OfferUp Vehicle Scraper.**
3. **Enter a ZIP code** and choose a search radius.
4. **Add filters** (optional) — make, year range, price range, mileage, body style, transmission, drivetrain, condition, or minimum MPG.
5. **Set Maximum Results** and click **Start**.
6. **Download your data** in JSON, CSV, Excel, or HTML — or pull it via API.

### ⬇️ Input

Set everything visually in the input form, or paste JSON directly:

```json
{
    "zipcode": "77002",
    "radius": "80",
    "sort": "-posted",
    "priceMin": 5000,
    "priceMax": 25000,
    "vehicleYearMin": 2010,
    "vehicleYearMax": 2020,
    "vehicleMakes": ["td", "hb"],
    "vehicleMileageMax": "100000",
    "conditions": ["USED", "OPEN_BOX"],
    "vehicleStyles": ["s", "t"],
    "vehicleTransmissions": ["a"],
    "vehicleDrivetrains": ["a", "f"],
    "vehicleMpgMin": "20",
    "maxItems": 500
}
````

**Available filters:** ZIP code, search radius, sort order, minimum/maximum price, make, minimum/maximum model year, maximum mileage, body style (car, SUV, truck, van), transmission, drivetrain, condition, and minimum MPG. Leave any filter empty to include everything.

### ⬆️ Output

Each vehicle is saved as a structured record in your dataset, ready to download in JSON, CSV, Excel, or HTML:

```json
{
    "listingId": "2838ddef-e743-39ee-8600-8b855ca47ad8",
    "title": "2018 Toyota Camry",
    "price": "$14,500",
    "locationName": "Houston, TX",
    "conditionText": "Good",
    "vehicleMiles": "87300",
    "imageUrl": "https://images.offerup.com/example.jpg",
    "listingUrl": "https://offerup.com/item/detail/2838ddef-e743-39ee-8600-8b855ca47ad8"
}
```

#### Data table

| Field | Description |
|---|---|
| `listingId` | OfferUp listing identifier |
| `title` | Listing title |
| `price` | Display price |
| `locationName` | Public display location (city, state) |
| `conditionText` | Condition label when present |
| `vehicleMiles` | Vehicle mileage when present |
| `imageUrl` | Primary listing image URL |
| `listingUrl` | Public OfferUp listing URL |

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

OfferUp Vehicle Scraper runs on Apify's **pay-per-use** model — you only pay for the resources a run consumes. Small, filtered runs are inexpensive; cost scales with how many listings you collect. Use **Maximum Results** and filters to keep each run bounded.

**Free tier:** New Apify users get monthly free credits — enough to scrape hundreds of vehicle listings at no cost.

### ✨ Tips for best results

1. **Start small** — run with a low **Maximum Results** first to confirm your filters look right, then scale up.
2. **Filter before you scale** — narrowing by make, price, or year keeps runs fast and focused.
3. **Schedule recurring runs** — set up daily or hourly runs to monitor a market continuously.
4. **Widen the radius** if a ZIP code returns few results, or tighten it to stay hyper-local.

### 🔗 Integrations

Connect OfferUp Vehicle Scraper to the tools you already use:

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

### 🛠️ Using the API

Run the scraper and pull results programmatically with the Apify API:

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_API_TOKEN")

run_input = {
    "zipcode": "77002",
    "priceMax": 25000,
    "maxItems": 50
}

run = client.actor("your-username/offerup-vehicle-scraper").call(run_input=run_input)

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["title"], item["price"])
```

### ❓ FAQ

#### How does OfferUp Vehicle Scraper work?

It works just like browsing OfferUp yourself — it opens the public vehicle feed for your chosen ZIP code, applies your filters, and collects the publicly visible details from each listing, only far faster and at scale.

#### Can I scrape multiple locations?

Each run targets one ZIP code and radius. To cover several areas, run the scraper multiple times with different ZIP codes, or schedule automated runs for each location.

#### Why are some fields missing?

OfferUp shows different details depending on category, region, and listing type. The scraper captures the common vehicle fields and leaves anything a seller didn't provide empty.

#### Is it legal to scrape OfferUp?

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

### 📞 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.

***

*OfferUp Vehicle Scraper is not affiliated with or endorsed by OfferUp. Use responsibly and in accordance with OfferUp's Terms of Service.*

# Actor input Schema

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

ZIP code used as the center point for the OfferUp vehicle search.

## `radius` (type: `string`):

Distance around the ZIP code. Leave as no limit to let OfferUp return the broad default feed.

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

Maximum number of unique listings to save to the dataset.

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

How OfferUp should order the feed results.

## `priceMin` (type: `integer`):

Minimum listing price. Leave empty for no minimum.

## `priceMax` (type: `integer`):

Maximum listing price. Leave empty for no maximum.

## `vehicleMakes` (type: `array`):

Filter by one or more vehicle makes. Leave empty to include all makes.

## `vehicleYearMin` (type: `integer`):

Minimum vehicle model year. Leave empty for no minimum.

## `vehicleYearMax` (type: `integer`):

Maximum vehicle model year. Leave empty for no maximum.

## `vehicleMileageMax` (type: `string`):

Only include vehicles at or below this mileage. Leave as no limit to include all mileage values.

## `vehicleStyles` (type: `array`):

Filter by vehicle body style. Leave empty to include all styles.

## `vehicleTransmissions` (type: `array`):

Filter by transmission type. Leave empty to include all transmissions.

## `vehicleDrivetrains` (type: `array`):

Filter by drivetrain. Leave empty to include all drivetrains.

## `vehicleMpgMin` (type: `string`):

Minimum fuel efficiency. Leave as no limit to include all MPG values.

## `conditions` (type: `array`):

Filter by OfferUp listing condition. Leave empty to include every condition.

## Actor input object example

```json
{
  "zipcode": "77002",
  "radius": "",
  "maxItems": 500,
  "sort": "",
  "vehicleMileageMax": "",
  "vehicleMpgMin": ""
}
```

# Actor output Schema

## `results` (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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("raidr-api/offerup-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 = {}

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "OfferUp Vehicle Scraper + Instant Results",
        "description": "Scrape OfferUp for 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": "uIMOG4NCqp6sHg4ra"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/raidr-api~offerup-vehicle-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-raidr-api-offerup-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~offerup-vehicle-scraper/runs": {
            "post": {
                "operationId": "runs-sync-raidr-api-offerup-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~offerup-vehicle-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-raidr-api-offerup-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",
                "required": [
                    "zipcode"
                ],
                "properties": {
                    "zipcode": {
                        "title": "📍 ZIP Code",
                        "type": "string",
                        "description": "ZIP code used as the center point for the OfferUp vehicle search.",
                        "default": "77002"
                    },
                    "radius": {
                        "title": "🗺️ Search Radius",
                        "enum": [
                            "",
                            "25",
                            "80",
                            "100",
                            "200",
                            "5000"
                        ],
                        "type": "string",
                        "description": "Distance around the ZIP code. Leave as no limit to let OfferUp return the broad default feed.",
                        "default": ""
                    },
                    "maxItems": {
                        "title": "📦 Maximum Results",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Maximum number of unique listings to save to the dataset.",
                        "default": 500
                    },
                    "sort": {
                        "title": "↕️ Sort Results By",
                        "enum": [
                            "",
                            "-posted",
                            "distance",
                            "price",
                            "-price",
                            "-vehicle_year",
                            "vehicle_miles"
                        ],
                        "type": "string",
                        "description": "How OfferUp should order the feed results.",
                        "default": ""
                    },
                    "priceMin": {
                        "title": "💵 Minimum Price",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Minimum listing price. Leave empty for no minimum."
                    },
                    "priceMax": {
                        "title": "💰 Maximum Price",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum listing price. Leave empty for no maximum."
                    },
                    "vehicleMakes": {
                        "title": "🚘 Vehicle Makes",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Filter by one or more vehicle makes. Leave empty to include all makes.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "ab",
                                "ac",
                                "ad",
                                "aj",
                                "an",
                                "ap",
                                "bb",
                                "bf",
                                "bi",
                                "bj",
                                "c",
                                "cc",
                                "cd",
                                "d",
                                "dc",
                                "de",
                                "dh",
                                "e",
                                "fb",
                                "fc",
                                "fd",
                                "fe",
                                "ga",
                                "ge",
                                "hb",
                                "he",
                                "hf",
                                "i",
                                "ic",
                                "j",
                                "jb",
                                "k",
                                "lb",
                                "ld",
                                "lf",
                                "lg",
                                "lh",
                                "mb",
                                "me",
                                "mf",
                                "mh",
                                "mi",
                                "mk",
                                "ml",
                                "n",
                                "o",
                                "pe",
                                "pf",
                                "pg",
                                "r",
                                "re",
                                "s",
                                "sb",
                                "sc",
                                "sh",
                                "sl",
                                "sn",
                                "tc",
                                "td",
                                "vb",
                                "vc"
                            ],
                            "enumTitles": [
                                "Abarth",
                                "Acura",
                                "Alfa Romeo",
                                "AM General",
                                "Aston Martin",
                                "Audi",
                                "Bentley",
                                "BMW",
                                "Bugatti",
                                "Buick",
                                "Cadillac",
                                "Chevrolet",
                                "Chrysler",
                                "Daewoo",
                                "Daihatsu",
                                "Datsun",
                                "Dodge",
                                "Eagle",
                                "Ferrari",
                                "Fiat",
                                "Fisker",
                                "Ford",
                                "Genesis",
                                "GMC",
                                "Honda",
                                "Hummer",
                                "Hyundai",
                                "Infiniti",
                                "Isuzu",
                                "Jaguar",
                                "Jeep",
                                "Kia",
                                "Lamborghini",
                                "Land Rover",
                                "Lexus",
                                "Lincoln",
                                "Lotus",
                                "Maserati",
                                "Mazda",
                                "McLaren",
                                "Mercedes-Benz",
                                "Mercury",
                                "Mini",
                                "Mitsubishi",
                                "Nissan",
                                "Oldsmobile",
                                "Plymouth",
                                "Pontiac",
                                "Porsche",
                                "Ram",
                                "Rolls-Royce",
                                "Saab",
                                "Saturn",
                                "Scion",
                                "Smart",
                                "Subaru",
                                "Suzuki",
                                "Tesla",
                                "Toyota",
                                "Volkswagen",
                                "Volvo"
                            ]
                        }
                    },
                    "vehicleYearMin": {
                        "title": "📅 Minimum Year",
                        "minimum": 1936,
                        "type": "integer",
                        "description": "Minimum vehicle model year. Leave empty for no minimum."
                    },
                    "vehicleYearMax": {
                        "title": "📅 Maximum Year",
                        "minimum": 1936,
                        "type": "integer",
                        "description": "Maximum vehicle model year. Leave empty for no maximum."
                    },
                    "vehicleMileageMax": {
                        "title": "🧭 Maximum Mileage",
                        "enum": [
                            "",
                            "0",
                            "25000",
                            "50000",
                            "75000",
                            "100000",
                            "125000",
                            "150000",
                            "175000",
                            "200000"
                        ],
                        "type": "string",
                        "description": "Only include vehicles at or below this mileage. Leave as no limit to include all mileage values.",
                        "default": ""
                    },
                    "vehicleStyles": {
                        "title": "🚙 Body Styles",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Filter by vehicle body style. Leave empty to include all styles.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "c",
                                "s",
                                "t",
                                "v"
                            ],
                            "enumTitles": [
                                "Car",
                                "SUV",
                                "Truck",
                                "Van"
                            ]
                        }
                    },
                    "vehicleTransmissions": {
                        "title": "⚙️ Transmissions",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Filter by transmission type. Leave empty to include all transmissions.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "a",
                                "m"
                            ],
                            "enumTitles": [
                                "Automatic",
                                "Manual"
                            ]
                        }
                    },
                    "vehicleDrivetrains": {
                        "title": "🛞 Drivetrains",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Filter by drivetrain. Leave empty to include all drivetrains.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "a",
                                "f",
                                "r"
                            ],
                            "enumTitles": [
                                "AWD/4WD",
                                "FWD",
                                "RWD"
                            ]
                        }
                    },
                    "vehicleMpgMin": {
                        "title": "⛽ Minimum MPG",
                        "enum": [
                            "",
                            "10",
                            "20",
                            "30",
                            "40"
                        ],
                        "type": "string",
                        "description": "Minimum fuel efficiency. Leave as no limit to include all MPG values.",
                        "default": ""
                    },
                    "conditions": {
                        "title": "🏷️ Listing Conditions",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Filter by OfferUp listing condition. Leave empty to include every condition.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "NEW",
                                "REFURBISHED",
                                "OPEN_BOX",
                                "USED",
                                "BROKEN",
                                "OTHER"
                            ],
                            "enumTitles": [
                                "New",
                                "Excellent",
                                "Very good",
                                "Good",
                                "Fair",
                                "For parts"
                            ]
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
