# Row52 Junkyard & Salvage Yard Parts Scraper (`crawlerbros/row52-junkyard-parts-scraper`) Actor

Find which self-service junkyard (Pick-n-Pull) has a matching donor vehicle in stock. Search by year/make/model plus ZIP + radius, look up an exact VIN, browse a specific yard's newest arrivals, or list every yard location across the US and Canada.

- **URL**: https://apify.com/crawlerbros/row52-junkyard-parts-scraper.md
- **Developed by:** [Crawler Bros](https://apify.com/crawlerbros) (community)
- **Categories:** E-commerce, Automation, Agents
- **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 web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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

## Row52 Junkyard & Salvage Yard Parts Scraper

Find which self-service junkyard has the exact donor vehicle you need — before you drive there. This actor searches Row52's live self-service junkyard inventory (Pick-n-Pull yards across the US and Canada) by year, make, model, and location, so you can see which yard has a matching vehicle in stock, what row/aisle it's parked in, and when it arrived — all without visiting the site yourself.

Built for DIY auto-repair shoppers, independent repair shops, and part-out sellers who need to find a specific used part fast.

### What this actor does

- **Search by year / make / model** — find every matching vehicle currently in inventory
- **Search near a ZIP or postal code** — filter to yards within a chosen radius (10 / 25 / 50 / 100 / 250 / 500 miles), covering both US ZIP codes and Canadian postal codes
- **Look up an exact VIN** — check whether one specific vehicle has turned up at any yard
- **Browse a single yard's newest arrivals** — see what's just been added to a specific junkyard
- **List every yard location** — a directory of every participating self-service yard, with address, phone, hours, and map link
- **Empty fields are always omitted** — every record only contains data that was actually returned

### Output — vehicle record (`search`, `byVin`, `byYard` modes)

| Field | Description |
|---|---|
| `vehicleId` | Row52's internal vehicle ID |
| `vin` | Full 17-character VIN |
| `year`, `make`, `model` | Vehicle year / manufacturer / model |
| `color`, `engine`, `transmission`, `trim` | When reported |
| `row` | Row/aisle location inside the yard |
| `barCodeNumber` | Yard inventory tag number |
| `dateAdded` | Date the vehicle arrived at the yard |
| `imageCount`, `commentCount` | Counts, when > 0 |
| `thumbnailUrl`, `largeImageUrl`, `smallImageUrl` | Yard-row photos of the vehicle |
| `yardId`, `yardName`, `yardCode` | Which yard has it |
| `yardCity`, `yardState`, `yardZip` | Yard location |
| `yardPhone`, `yardHours` | Yard contact info |
| `yardLatitude`, `yardLongitude` | Yard coordinates |
| `yardMapUrl`, `yardWebUrl`, `yardPartsPricingUrl` | Yard links (store map, detail page, parts price list) |
| `distanceMiles` | Distance from the searched ZIP/postal code (only when one was given) |
| `sourceUrl` | Direct link to the vehicle's Row52 detail page |
| `recordType` | `"vehicle"` |
| `scrapedAt` | UTC timestamp of the scrape |

### Output — yard record (`listYards` mode)

| Field | Description |
|---|---|
| `yardId`, `yardName`, `yardCode` | Yard identifiers |
| `address1`, `address2`, `city` | Street address |
| `state`, `stateAbbreviation` | State/province |
| `zipCode`, `phone`, `hours` | Contact info |
| `latitude`, `longitude` | Coordinates |
| `mapUrl` | Store-locator map link |
| `webUrl` | Yard detail page on the operator's own site |
| `partsPricingUrl` | Published parts price list |
| `isActive`, `allowPullers` | Whether the yard is currently active / allows self-pull |
| `distanceMiles` | Distance from the searched ZIP/postal code (only when one was given) |
| `sourceUrl` | Same as `webUrl` |
| `recordType` | `"yard"` |
| `scrapedAt` | UTC timestamp of the scrape |

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `mode` | select | `search` | `search` / `byVin` / `byYard` / `listYards` |
| `year` | int | – | Exact model year (1950–2027). Takes priority over `yearMin`/`yearMax` |
| `yearMin` | int | – | Lower bound of a model-year range, inclusive (used when `year` is blank) |
| `yearMax` | int | – | Upper bound of a model-year range, inclusive (used when `year` is blank) |
| `make` | select | – | Vehicle manufacturer (66 makes) |
| `model` | string | – | Case-insensitive substring match, e.g. `Civic` |
| `zipCode` | string | – | US ZIP or Canadian postal code |
| `radius` | select | `50` | Miles: 10 / 25 / 50 / 100 / 250 / 500 (used with `zipCode`) |
| `vin` | string | – | Exact VIN (mode=`byVin`) |
| `yardId` | int | – | Numeric yard ID (mode=`byYard`) |
| `yardName` | string | – | Yard/city name substring (mode=`byYard`) |
| `state` | select | – | US state / Canadian province (mode=`listYards`) |
| `sortBy` | select | `dateAdded` | `dateAdded` / `year` / `make` / `model` / `yard` |
| `sortOrder` | select | `desc` | `asc` / `desc` |
| `maxItems` | int | `30` | Hard cap on emitted records (1–2000) |

#### Example: 2015 Honda Civic within 50 miles of Sacramento, CA

```json
{
  "mode": "search",
  "year": 2015,
  "make": "Honda",
  "model": "Civic",
  "zipCode": "95814",
  "radius": 50
}
````

Note: Row52 participating yards are concentrated in specific metro areas (see
`listYards`) -- a ZIP far from any yard (e.g. Beverly Hills, 90210, which is
200+ miles from the nearest yard) will correctly return 0 vehicles for any
radius under 250 miles. Pick a ZIP near a yard the directory lists, or widen
the radius / drop the ZIP filter for a nationwide search.

#### Example: Ford F-150s from model years 2010-2018

```json
{
  "mode": "search",
  "make": "Ford",
  "model": "F-150",
  "yearMin": 2010,
  "yearMax": 2018
}
```

#### Example: newest arrivals at the Sacramento yard

```json
{
  "mode": "byYard",
  "yardName": "Sacramento"
}
```

#### Example: VIN lookup

```json
{
  "mode": "byVin",
  "vin": "2HGFB2F9XFH550172"
}
```

#### Example: every yard in California

```json
{
  "mode": "listYards",
  "state": "California"
}
```

### Use cases

- **DIY auto repair** — find a specific used part (bumper, door, engine) before driving to a yard
- **Independent repair shops** — check multiple yards at once for a matching donor vehicle
- **Part-out sellers & flippers** — track newly arrived vehicles at a yard to grab parts early
- **Salvage/VIN research** — confirm whether a specific VIN has shown up at any participating yard
- **Yard directory & logistics** — get hours, phone numbers, and map links for trip planning across multiple yards

### FAQ

**Do I need a Row52 account, cookies, or proxy?**
No. This actor uses Row52's public inventory feed directly — no login, cookies, or proxy configuration required.

**Is this affiliated with Row52 or Pick-n-Pull?**
No, this is an independent third-party actor that reads Row52's public inventory listings. It is not affiliated with, endorsed by, or operated by Row52.com or Pick-n-Pull.

**Which regions are covered?**
Every Row52-participating self-service yard in the US and Canada. Use `listYards` (optionally filtered by `state`) to see the full current directory.

**Why is `model` a free-text field instead of a dropdown?**
Row52 tracks over 1,400 distinct model names across 66 makes — too many to list as one dropdown. Typing a partial name (e.g. `Silver` for Silverado) matches any model containing that text.

**Why didn't my search return every field?**
Fields like `color`, `engine`, `transmission`, and `trim` are only present when the yard recorded them for that specific vehicle. Empty fields are never included in the output.

**How fresh is the data?**
Every run queries Row52's live inventory feed directly, so results reflect the current state of the yard's inventory at the moment the actor runs.

# Actor input Schema

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

What to fetch.

## `year` (type: `integer`):

Exact model year to match, e.g. 2015. Takes priority over Year from/Year to if both are set. Leave blank to use a year range instead, or leave all three blank to match any year.

## `yearMin` (type: `integer`):

Lower bound of a model-year range (inclusive), e.g. 2010. Ignored if 'Vehicle year' (exact) is set. Leave blank for no lower bound.

## `yearMax` (type: `integer`):

Upper bound of a model-year range (inclusive), e.g. 2018. Ignored if 'Vehicle year' (exact) is set. Leave blank for no upper bound.

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

Vehicle manufacturer. Leave blank to match any make.

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

Free-text, case-insensitive match against the model name, e.g. `Civic` or `Silverado`. Leave blank to match any model.

## `zipCode` (type: `string`):

US 5-digit ZIP or Canadian postal code (e.g. `90210` or `T2B 1N2`). Used with Radius to find nearby yards. Leave blank to search all yards nationwide.

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

Only used when ZIP / postal code is set. These are the exact radius options Row52's own search form offers.

## `vin` (type: `string`):

Full 17-character Vehicle Identification Number to look up.

## `yardId` (type: `integer`):

Numeric Row52 location ID. Use `listYards` mode first to find IDs, or use Yard name instead.

## `yardName` (type: `string`):

Free-text, case-insensitive match against the yard name or city, e.g. `Sacramento` or `Antelope`.

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

Restrict the yard directory to one US state or Canadian province. Leave blank to list every yard.

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

Field to sort matching vehicles by.

## `sortOrder` (type: `string`):

Ascending or descending.

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

Hard cap on emitted records.

## Actor input object example

```json
{
  "mode": "search",
  "year": 2015,
  "make": "Honda",
  "model": "Civic",
  "radius": "50",
  "vin": "2HGFB2F9XFH550172",
  "yardName": "Sacramento",
  "sortBy": "dateAdded",
  "sortOrder": "desc",
  "maxItems": 30
}
```

# Actor output Schema

## `vehicles` (type: `string`):

Dataset containing all scraped vehicle and/or yard-location records.

# 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": "search",
    "year": 2015,
    "make": "Honda",
    "model": "Civic",
    "radius": "50",
    "vin": "2HGFB2F9XFH550172",
    "yardName": "Sacramento",
    "sortBy": "dateAdded",
    "sortOrder": "desc",
    "maxItems": 30
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/row52-junkyard-parts-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": "search",
    "year": 2015,
    "make": "Honda",
    "model": "Civic",
    "radius": "50",
    "vin": "2HGFB2F9XFH550172",
    "yardName": "Sacramento",
    "sortBy": "dateAdded",
    "sortOrder": "desc",
    "maxItems": 30,
}

# Run the Actor and wait for it to finish
run = client.actor("crawlerbros/row52-junkyard-parts-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": "search",
  "year": 2015,
  "make": "Honda",
  "model": "Civic",
  "radius": "50",
  "vin": "2HGFB2F9XFH550172",
  "yardName": "Sacramento",
  "sortBy": "dateAdded",
  "sortOrder": "desc",
  "maxItems": 30
}' |
apify call crawlerbros/row52-junkyard-parts-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Row52 Junkyard & Salvage Yard Parts Scraper",
        "description": "Find which self-service junkyard (Pick-n-Pull) has a matching donor vehicle in stock. Search by year/make/model plus ZIP + radius, look up an exact VIN, browse a specific yard's newest arrivals, or list every yard location across the US and Canada.",
        "version": "1.0",
        "x-build-id": "Iccz9HWgF0Z18ieDG"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/crawlerbros~row52-junkyard-parts-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-crawlerbros-row52-junkyard-parts-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~row52-junkyard-parts-scraper/runs": {
            "post": {
                "operationId": "runs-sync-crawlerbros-row52-junkyard-parts-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~row52-junkyard-parts-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-crawlerbros-row52-junkyard-parts-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": [
                            "search",
                            "byVin",
                            "byYard",
                            "listYards"
                        ],
                        "type": "string",
                        "description": "What to fetch.",
                        "default": "search"
                    },
                    "year": {
                        "title": "Vehicle year (mode=search, byYard)",
                        "minimum": 1950,
                        "maximum": 2027,
                        "type": "integer",
                        "description": "Exact model year to match, e.g. 2015. Takes priority over Year from/Year to if both are set. Leave blank to use a year range instead, or leave all three blank to match any year."
                    },
                    "yearMin": {
                        "title": "Year from (mode=search, byYard)",
                        "minimum": 1950,
                        "maximum": 2027,
                        "type": "integer",
                        "description": "Lower bound of a model-year range (inclusive), e.g. 2010. Ignored if 'Vehicle year' (exact) is set. Leave blank for no lower bound."
                    },
                    "yearMax": {
                        "title": "Year to (mode=search, byYard)",
                        "minimum": 1950,
                        "maximum": 2027,
                        "type": "integer",
                        "description": "Upper bound of a model-year range (inclusive), e.g. 2018. Ignored if 'Vehicle year' (exact) is set. Leave blank for no upper bound."
                    },
                    "make": {
                        "title": "Make (mode=search, byYard)",
                        "enum": [
                            "Acura",
                            "Alfa Romeo",
                            "AMC",
                            "Asuna",
                            "Audi",
                            "Bertone",
                            "BMW",
                            "Buick",
                            "Cadillac",
                            "Chevrolet",
                            "Chrysler",
                            "Daewoo",
                            "Daihatsu",
                            "Datsun",
                            "Dodge",
                            "Eagle",
                            "Fiat",
                            "Ford",
                            "Geo",
                            "GMC",
                            "Honda",
                            "Hummer",
                            "Hyundai",
                            "Infiniti",
                            "International",
                            "Isuzu",
                            "Jaguar",
                            "Jeep",
                            "Kia",
                            "Lancia",
                            "Land Rover",
                            "Lexus",
                            "Lincoln",
                            "Maserati",
                            "Mazda",
                            "Mercedes-Benz",
                            "Mercury",
                            "Merkur",
                            "MG",
                            "Mini",
                            "Mitsubishi",
                            "Nash",
                            "Nissan",
                            "Oldsmobile",
                            "Opel",
                            "Peugeot",
                            "Plymouth",
                            "Pontiac",
                            "Porsche",
                            "Ram",
                            "Rambler",
                            "Renault",
                            "Saab",
                            "Saturn",
                            "Scion",
                            "Smart",
                            "Sterling",
                            "Studebaker",
                            "Subaru",
                            "Suzuki",
                            "Toyota",
                            "Triumph",
                            "Volkswagen",
                            "Volvo",
                            "Willys",
                            "Yugo"
                        ],
                        "type": "string",
                        "description": "Vehicle manufacturer. Leave blank to match any make."
                    },
                    "model": {
                        "title": "Model contains (mode=search, byYard)",
                        "type": "string",
                        "description": "Free-text, case-insensitive match against the model name, e.g. `Civic` or `Silverado`. Leave blank to match any model."
                    },
                    "zipCode": {
                        "title": "ZIP / postal code (mode=search, listYards)",
                        "type": "string",
                        "description": "US 5-digit ZIP or Canadian postal code (e.g. `90210` or `T2B 1N2`). Used with Radius to find nearby yards. Leave blank to search all yards nationwide."
                    },
                    "radius": {
                        "title": "Radius in miles (mode=search, listYards)",
                        "enum": [
                            "10",
                            "25",
                            "50",
                            "100",
                            "250",
                            "500"
                        ],
                        "type": "string",
                        "description": "Only used when ZIP / postal code is set. These are the exact radius options Row52's own search form offers.",
                        "default": "50"
                    },
                    "vin": {
                        "title": "VIN (mode=byVin)",
                        "type": "string",
                        "description": "Full 17-character Vehicle Identification Number to look up."
                    },
                    "yardId": {
                        "title": "Yard ID (mode=byYard)",
                        "minimum": 1,
                        "maximum": 999999,
                        "type": "integer",
                        "description": "Numeric Row52 location ID. Use `listYards` mode first to find IDs, or use Yard name instead."
                    },
                    "yardName": {
                        "title": "Yard name contains (mode=byYard)",
                        "type": "string",
                        "description": "Free-text, case-insensitive match against the yard name or city, e.g. `Sacramento` or `Antelope`."
                    },
                    "state": {
                        "title": "State / province (mode=listYards)",
                        "enum": [
                            "Arizona",
                            "Arkansas",
                            "California",
                            "Florida",
                            "Georgia",
                            "Illinois",
                            "Indiana",
                            "Kansas",
                            "Massachusetts",
                            "Missouri",
                            "Nevada",
                            "Ohio",
                            "Oregon",
                            "Rhode Island",
                            "Texas",
                            "Utah",
                            "Virginia",
                            "Washington",
                            "Alberta",
                            "British Columbia"
                        ],
                        "type": "string",
                        "description": "Restrict the yard directory to one US state or Canadian province. Leave blank to list every yard."
                    },
                    "sortBy": {
                        "title": "Sort by (mode=search, byYard)",
                        "enum": [
                            "dateAdded",
                            "year",
                            "make",
                            "model",
                            "yard"
                        ],
                        "type": "string",
                        "description": "Field to sort matching vehicles by.",
                        "default": "dateAdded"
                    },
                    "sortOrder": {
                        "title": "Sort order",
                        "enum": [
                            "asc",
                            "desc"
                        ],
                        "type": "string",
                        "description": "Ascending or descending.",
                        "default": "desc"
                    },
                    "maxItems": {
                        "title": "Max items",
                        "minimum": 1,
                        "maximum": 2000,
                        "type": "integer",
                        "description": "Hard cap on emitted records.",
                        "default": 30
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
