# UsedVending.com Scraper (`crawlerbros/used-vending-scraper`) Actor

Scrape UsedVending.com listings - used vending machines, food trucks, concession trailers, mobile business trucks/trailers, tiny homes and more. Browse by category or keyword search with price-range and state filters, get title, price, condition, location, specs, images and listing URL.

- **URL**: https://apify.com/crawlerbros/used-vending-scraper.md
- **Developed by:** [Crawler Bros](https://apify.com/crawlerbros) (community)
- **Categories:** E-commerce, Automation, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 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.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

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

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

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

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

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

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

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

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

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

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


# README

## UsedVending.com Scraper

Scrape [UsedVending.com](https://www.usedvending.com/) — the largest marketplace for used vending machines, food trucks, concession trailers, and other mobile-business equipment. Browse any of the site's 65+ equipment categories or run a free-text keyword search across the whole marketplace, then filter by state, price range and sold status. HTTP-only, no login, no proxy, no cookies required.

### What this actor does

- **Two modes:** `Browse by category` (fast, walks one category's listing pages) and `Keyword search` (free-text search across the whole marketplace, optionally narrowed by category, with relevance enforced entirely client-side since the site's own search endpoint does not filter by keyword)
- **65+ categories:** every food-truck, food-trailer, vending-machine, mobile-business, tiny-home, horse-trailer and step-van sub-category the site actually uses in its navigation
- **State filter:** restrict results to any one of the 50 US states + DC
- **Price range filter:** min/max USD, applied reliably client-side
- **Sold-listing control:** SOLD listings are excluded by default; opt in to include them
- **Shipping filter:** optionally keep only listings the site confirms can be shipped/transported to you
- **Sort:** by price (low/high), date posted (newest/oldest), biggest price reduction first, or state (A-Z)
- **Full listing detail:** description, full photo gallery, specifications, equipment list, condition, manufacturer/model/year, shipping availability and walkaround video (when the listing has one)
- **Empty fields are omitted** — every record only contains data the listing actually provides

### Output per listing

- `itemId` — the site's own listing code (e.g. `IN-T-227Y3`)
- `title`, `description`
- `category`, `categorySlug` — derived from the listing's own breadcrumb trail (matches the `category` input's value set)
- `price`, `priceCurrency`, `wasPrice` (when the listing shows a markdown from a higher price)
- `condition` — `Used`, `New`, `Refurbished` or `Damaged`, as stated by the listing
- `manufacturer`, `model`, `year` — parsed from the listing's own specification table when present
- `state`, `stateAbbr`
- `sold` — true if the listing is marked SOLD
- `images[]`, `thumbnailUrl` — full-resolution photo URLs
- `videoUrl` — YouTube walkaround-video link, when the listing has one
- `shippingAvailable` — `true`/`false` when the listing explicitly states it can (or cannot -- pickup only) be shipped/transported; omitted when the site publishes no shipping signal for that listing
- `specifications[]`, `equipmentList[]` — `{label, value}` pairs exactly as published
- `listingUrl`
- `datePosted`, `dateUpdated`
- `scrapedAt`

Seller/dealer identity is not published on listing pages (inquiries route through UsedVending itself), so no seller field is emitted.

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `mode` | string | `byCategory` | `byCategory` / `search` |
| `category` | string | `used-food-concession-trailers` | Equipment category (primary axis for `byCategory`; optional narrowing filter for `search`) |
| `keyword` | string | – | Free-text search term (mode=`search`) |
| `state` | string | – | Restrict to one US state |
| `priceMin` | integer | – | Drop listings priced below this (USD) |
| `priceMax` | integer | – | Drop listings priced above this (USD) |
| `sortBy` | string | `` (site order) | `priceLowHigh` / `priceHighLow` / `dateNewest` / `dateOldest` / `priceReduction` / `state` |
| `includeSold` | boolean | `false` | Include listings already marked SOLD |
| `shippingOnly` | boolean | `false` | Only include listings confirmed shippable/transportable (excludes pickup-only and unlabeled listings) |
| `maxItems` | integer | `20` | Hard cap on returned listings (1–500) |

#### Example: browse the biggest category (food concession trailers)

```json
{
  "mode": "byCategory",
  "category": "used-food-concession-trailers",
  "maxItems": 20
}
````

#### Example: keyword search, narrowed to Texas, under $30k

```json
{
  "mode": "search",
  "keyword": "ice cream",
  "state": "TX",
  "priceMax": 30000,
  "maxItems": 25
}
```

#### Example: cheapest vending machines first

```json
{
  "mode": "byCategory",
  "category": "used-vending-machines",
  "sortBy": "priceLowHigh",
  "maxItems": 50
}
```

### Use cases

- **Route operators** sourcing used vending machines by brand/type and budget
- **Food-truck entrepreneurs** comparing food trucks vs. trailers vs. new-build pricing
- **Price benchmarking** for used commercial mobile-business equipment
- **Market research** on regional supply (by state) across equipment categories
- **Lead generation** for equipment financing / insurance targeting recent listings

### FAQ

**Do I need a proxy or login?** No — the site is fully public. The actor runs with Apify's free `AUTO` proxy group disabled by default; no cookies or credentials are used.

**Why is `category` sometimes different from the category I searched?** `category`/`categorySlug` reflect the listing's own canonical category (read from its breadcrumb trail), which is the ground truth for that item — occasionally a listing is cross-referenced under a category page different from its own primary category.

**Why do some fields not appear on some listings?** Only fields the listing actually publishes are included — no blank/placeholder values are ever emitted. For example, `wasPrice` only appears when a listing shows a markdown from an original price, and `manufacturer`/`model`/`year` only appear when the listing's spec table states them.

**Does `sortBy` change which listings are returned?** No — it only orders the returned page of results; `maxItems` and the other filters determine which listings are included. `priceReduction` sorts listings with the biggest markdown (`wasPrice` minus `price`) first; `state` sorts alphabetically by state name.

**What does `shippingOnly` do?** When enabled, only listings whose page explicitly states "Pickup or have it transported!" are kept (`shippingAvailable: true`). Listings marked "Pickup Only for this item" are excluded, as are listings where the site published no shipping signal at all -- an unknown shipping status is never assumed to mean shippable.

**What is `videoUrl`?** Some listings embed a YouTube walkaround video; when present, its canonical watch URL is included. Most listings don't have one, so the field is omitted rather than left blank.

**What does `condition` mean here?** It reflects the schema.org `itemCondition` UsedVending.com publishes per listing (`Used`, `New`, `Refurbished`, or `Damaged`). Most listings — including many marked "NEW BUILD" — are still tagged `Used` by the site itself; this actor reports exactly what the listing states rather than inferring anything.

**How current is the data?** Listings carry their own `datePosted`/`dateUpdated` timestamps straight from the site; the actor always fetches live.

**How does keyword search work?** UsedVending.com's own `keyword` search parameter does not actually filter results server-side (verified: a real keyword and a nonsense one return the same page). This actor instead scans marketplace listings and keeps only those whose title, description, category, manufacturer or model contain every word of your keyword (case-insensitive) -- giving you working keyword search where the site itself doesn't filter at all.

# Actor input Schema

## `mode` (type: `string`):

`Browse by category` walks a single category's listing pages (fast, reliable). `Keyword search` runs a free-text search across the whole marketplace, optionally narrowed by category.

## `category` (type: `string`):

Equipment category to browse (mode=Browse by category), or to narrow results to (mode=Keyword search, optional).

## `keyword` (type: `string`):

Free-text search term (mode=Keyword search), e.g. `ice cream`, `coffee`, `taco`.

## `state` (type: `string`):

Only return listings located in this US state.

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

Drop listings priced below this amount.

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

Drop listings priced above this amount.

## `sortBy` (type: `string`):

Order of returned records (applied after fetching, does not affect which listings match).

## `includeSold` (type: `boolean`):

By default, listings already marked SOLD are excluded. Enable to include them.

## `shippingOnly` (type: `boolean`):

Only include listings the site confirms can be shipped or transported to you (excludes listings marked pickup-only, and listings where the site published no shipping signal at all).

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

Hard cap on the number of listings returned.

## Actor input object example

```json
{
  "mode": "byCategory",
  "category": "used-food-concession-trailers",
  "state": "",
  "sortBy": "",
  "includeSold": false,
  "shippingOnly": false,
  "maxItems": 20
}
```

# Actor output Schema

## `listings` (type: `string`):

Dataset containing all scraped UsedVending.com listings.

# 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 = {
    "mode": "byCategory",
    "category": "used-food-concession-trailers",
    "state": "",
    "sortBy": "",
    "includeSold": false,
    "shippingOnly": false,
    "maxItems": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/used-vending-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 = {
    "mode": "byCategory",
    "category": "used-food-concession-trailers",
    "state": "",
    "sortBy": "",
    "includeSold": False,
    "shippingOnly": False,
    "maxItems": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("crawlerbros/used-vending-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 '{
  "mode": "byCategory",
  "category": "used-food-concession-trailers",
  "state": "",
  "sortBy": "",
  "includeSold": false,
  "shippingOnly": false,
  "maxItems": 20
}' |
apify call crawlerbros/used-vending-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "UsedVending.com Scraper",
        "description": "Scrape UsedVending.com listings - used vending machines, food trucks, concession trailers, mobile business trucks/trailers, tiny homes and more. Browse by category or keyword search with price-range and state filters, get title, price, condition, location, specs, images and listing URL.",
        "version": "1.0",
        "x-build-id": "hr1fGWJeeMuQ9d00R"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/crawlerbros~used-vending-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-crawlerbros-used-vending-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/crawlerbros~used-vending-scraper/runs": {
            "post": {
                "operationId": "runs-sync-crawlerbros-used-vending-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/crawlerbros~used-vending-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-crawlerbros-used-vending-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": [
                    "mode"
                ],
                "properties": {
                    "mode": {
                        "title": "Mode",
                        "enum": [
                            "byCategory",
                            "search"
                        ],
                        "type": "string",
                        "description": "`Browse by category` walks a single category's listing pages (fast, reliable). `Keyword search` runs a free-text search across the whole marketplace, optionally narrowed by category.",
                        "default": "byCategory"
                    },
                    "category": {
                        "title": "Category",
                        "enum": [
                            "",
                            "used-food-concession-trailers",
                            "new-build-food-trailers-for-sale",
                            "used-food-concession-trailers/kitchen-food-trailers",
                            "used-food-concession-trailers/concession-trailers",
                            "used-food-concession-trailers/bakery-trailer",
                            "used-food-concession-trailers/barbecue-bbq-food-trailer",
                            "used-food-concession-trailers/catering-food-trailer",
                            "used-food-concession-trailers/corn-roasting-trailer",
                            "used-food-concession-trailers/coffee-trailer",
                            "used-food-concession-trailers/ice-cream-trailer",
                            "used-food-concession-trailers/used-bbq-smoker-trailers",
                            "used-food-concession-trailers/pizza-trailer",
                            "used-food-concession-trailers/snowball-trailer",
                            "used-mobile-food-trucks",
                            "new-build-food-trucks-for-sale",
                            "used-mobile-food-trucks/all-purpose-food-truck",
                            "used-mobile-food-trucks/ice-cream-truck",
                            "used-mobile-food-trucks/barbecue-bbq-food-truck",
                            "used-mobile-food-trucks/pizza-food-truck",
                            "used-mobile-food-trucks/catering-food-truck",
                            "used-mobile-food-trucks/snowball-truck",
                            "used-mobile-food-trucks/taco-food-truck",
                            "used-mobile-food-trucks/coffee-beverage-truck",
                            "used-mobile-food-trucks/bakery-truck",
                            "used-mobile-food-trucks/lunch-serving-truck",
                            "used-vending-machines",
                            "used-vending-machines/bagged-ice-vending-machines",
                            "used-vending-machines/bagged-ice-vending-machines/kooler-ice-vending-machines",
                            "used-vending-machines/bagged-ice-vending-machines/everest-ice-vending-machines",
                            "used-vending-machines/bagged-ice-vending-machines/just-ice-vending-machines",
                            "used-vending-machines/bagged-ice-vending-machines/twice-the-ice-vending-machines",
                            "used-vending-machines/bagged-ice-vending-machines/other-brands",
                            "used-vending-machines/snack-soda-combo-vending-machines",
                            "used-vending-machines/snack-soda-combo-vending-machines/ams-combo-vending-machines",
                            "used-vending-machines/snack-soda-combo-vending-machines/antares-office-deli-vending-combos",
                            "used-vending-machines/snack-soda-combo-vending-machines/automatic-products-combo-vending-machines",
                            "used-vending-machines/snack-soda-combo-vending-machines/crane-national-combo-vending-machines",
                            "used-vending-machines/snack-soda-combo-vending-machines/usi-wittern-combo-machines",
                            "used-vending-machines/snack-soda-combo-vending-machines/seaga-combo-vending-machines",
                            "used-vending-machines/snack-soda-combo-vending-machines/other-combos",
                            "used-vending-machines/healthy-snack-soda-combo-vending-machines",
                            "used-vending-machines/healthy-snack-soda-combo-vending-machines/healthy-you-combo-vending-machines",
                            "used-vending-machines/healthy-snack-soda-combo-vending-machines/natural-combo-vending-machines",
                            "used-vending-machines/healthy-snack-soda-combo-vending-machines/healthier-4-u-combo-vending-machines",
                            "used-vending-machines/healthy-snack-soda-combo-vending-machines/grow-healthy-combo-vending-machines",
                            "used-vending-machines/healthy-snack-soda-combo-vending-machines/fresh-vending-combo-machines",
                            "used-vending-machines/healthy-snack-soda-combo-vending-machines/other-healthy-vending",
                            "mobile-business-trucks-mobile-business-trailers",
                            "mobile-business-trucks-mobile-business-trailers/mobile-boutique-truck",
                            "mobile-business-trucks-mobile-business-trailers/mobile-hair-nail-salon-truck",
                            "mobile-business-trucks-mobile-business-trailers/party-gaming-trailer",
                            "mobile-business-trucks-mobile-business-trailers/pet-care-dog-grooming-veterinary-trucks",
                            "mobile-business-trucks-mobile-business-trailers/restroom-bathroom-trailers",
                            "mobile-business-trucks-mobile-business-trailers/mobile-billboard-trucks-for-sale",
                            "mobile-business-trucks-mobile-business-trailers/mobile-clinics",
                            "mobile-business-trucks-mobile-business-trailers/other-mobile-businesses",
                            "tiny-homes-for-sale",
                            "tiny-homes-for-sale/2-bedroom-tiny-homes",
                            "tiny-homes-for-sale/tiny-homes-on-wheels",
                            "tiny-homes-for-sale/airstream",
                            "tiny-homes-for-sale/motorhome-rvs-for-sale",
                            "living-quarters-horse-trailers-for-sale",
                            "living-quarters-horse-trailers-for-sale/2-horse-lq-trailers",
                            "living-quarters-horse-trailers-for-sale/3-horse-lq-trailers",
                            "living-quarters-horse-trailers-for-sale/4-horse-lq-trailers",
                            "used-step-vans"
                        ],
                        "type": "string",
                        "description": "Equipment category to browse (mode=Browse by category), or to narrow results to (mode=Keyword search, optional).",
                        "default": ""
                    },
                    "keyword": {
                        "title": "Keyword",
                        "type": "string",
                        "description": "Free-text search term (mode=Keyword search), e.g. `ice cream`, `coffee`, `taco`."
                    },
                    "state": {
                        "title": "State",
                        "enum": [
                            "",
                            "AL",
                            "AK",
                            "AZ",
                            "AR",
                            "CA",
                            "CO",
                            "CT",
                            "DE",
                            "DC",
                            "FL",
                            "GA",
                            "HI",
                            "ID",
                            "IL",
                            "IN",
                            "IA",
                            "KS",
                            "KY",
                            "LA",
                            "ME",
                            "MD",
                            "MA",
                            "MI",
                            "MN",
                            "MS",
                            "MO",
                            "MT",
                            "NE",
                            "NV",
                            "NH",
                            "NJ",
                            "NM",
                            "NY",
                            "NC",
                            "ND",
                            "OH",
                            "OK",
                            "OR",
                            "PA",
                            "RI",
                            "SC",
                            "SD",
                            "TN",
                            "TX",
                            "UT",
                            "VT",
                            "VA",
                            "WA",
                            "WV",
                            "WI",
                            "WY"
                        ],
                        "type": "string",
                        "description": "Only return listings located in this US state.",
                        "default": ""
                    },
                    "priceMin": {
                        "title": "Min price (USD)",
                        "minimum": 0,
                        "maximum": 5000000,
                        "type": "integer",
                        "description": "Drop listings priced below this amount."
                    },
                    "priceMax": {
                        "title": "Max price (USD)",
                        "minimum": 0,
                        "maximum": 5000000,
                        "type": "integer",
                        "description": "Drop listings priced above this amount."
                    },
                    "sortBy": {
                        "title": "Sort by",
                        "enum": [
                            "",
                            "priceLowHigh",
                            "priceHighLow",
                            "dateNewest",
                            "dateOldest",
                            "priceReduction",
                            "state"
                        ],
                        "type": "string",
                        "description": "Order of returned records (applied after fetching, does not affect which listings match).",
                        "default": ""
                    },
                    "includeSold": {
                        "title": "Include sold listings",
                        "type": "boolean",
                        "description": "By default, listings already marked SOLD are excluded. Enable to include them.",
                        "default": false
                    },
                    "shippingOnly": {
                        "title": "Shipping/transport available only",
                        "type": "boolean",
                        "description": "Only include listings the site confirms can be shipped or transported to you (excludes listings marked pickup-only, and listings where the site published no shipping signal at all).",
                        "default": false
                    },
                    "maxItems": {
                        "title": "Max items",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Hard cap on the number of listings returned.",
                        "default": 20
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
