# Walmart Price Tracker by ZIP Code & Stock Monitor (`kamerozkan/walmart-multi-zip-monitor`) Actor

Walmart price tracker for exact products across US ZIP codes. Compare verified local prices, digital stock, fulfillment, and automatic change detection.

- **URL**: https://apify.com/kamerozkan/walmart-multi-zip-monitor.md
- **Developed by:** [Kamer Ozkan](https://apify.com/kamerozkan) (community)
- **Categories:** E-commerce
- **Stats:** 2 total users, 0 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $5.10 / 1,000 validated product × zip checks

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
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

## Walmart Price Tracker by ZIP Code & Stock Monitor

Compare the same [Walmart.com](https://www.walmart.com/) products across multiple US ZIP codes in one run. See the verified selected store, local price, digital availability, seller, fulfillment, and what changed since the previous check.

Built for retail arbitrage teams, resellers, pricing analysts, and operators monitoring known products. Enter Walmart item IDs or product URLs, add ZIP codes, and run.

### What you get

- Compare exact products across up to five ZIP codes per run.
- Spot regional price gaps, restocks, stock changes, seller changes, and fulfillment changes.
- Keep product-and-ZIP-specific history with a stable `monitorName`.
- Return every result or hide unchanged rows and keep only baselines, changes, and failures.
- Pay $0.006 per successful validated product × ZIP check. Failed and partial checks are free. Platform and proxy usage are included.

This Actor monitors known products. It does not perform keyword search, category crawling, review collection, or full catalog discovery.

### Real regional price proof

This is real output from a 100-check cloud run completed on July 22, 2026. The run delivered 100 validated results with zero final failures. The same gallon of milk showed a $1.79 price gap, a 67.8% difference from the lowest verified local price.

| Requested ZIP | Resolved store ZIP | Store ID | Local price | Digital availability |
|---|---|---:|---:|---|
| 10001 | 07094 | 3520 | $4.43 | IN_STOCK |
| 90210 | 91502 | 5686 | $3.93 | IN_STOCK |
| 60601 | 60639 | 5402 | $2.72 | IN_STOCK |
| 33101 | 33147 | 4303 | $3.12 | IN_STOCK |
| 75201 | 75204 | 3341 | $2.64 | IN_STOCK |

Product: `10450114`, Great Value Whole Vitamin D Milk, Gallon. Prices and availability are point-in-time Walmart.com signals. The selected store was verified for every accepted result.

The same run also found a local availability difference for product `10534289`, Great Value Seasoned Potato Hash Brown Patties. It was digitally in stock in four requested markets and out of stock for requested ZIP `60601`, resolved to store `5402`.

### Quick start

Enter Walmart item IDs or product URLs, then add up to five ZIP codes:

```json
{
  "products": [
    { "itemId": "10450118", "reference": "milk-half-gallon" },
    { "itemId": "10315355", "reference": "bread-regional-watch" }
  ],
  "zipCodes": ["10001", "60601", "90210"],
  "monitorName": "daily-us-watchlist",
  "includeUnchanged": true
}
````

Two products across three ZIP codes create six validated checks. The current production limit is **100 product × ZIP combinations per run**.

### Real output example

Each dataset item represents one product × ZIP result. This baseline row comes from the same 100-check cloud run:

```json
{
  "inputRef": "diverse-002",
  "itemId": "10315355",
  "zipCodeRequested": "60601",
  "zipCodeResolved": "60639",
  "locationApplied": true,
  "storeId": "5402",
  "storeDistanceMiles": 6.61,
  "status": "success",
  "reasonCode": null,
  "title": "Great Value White Round Top Bread Loaf, 20 oz",
  "price": 1.78,
  "currency": "USD",
  "availability": "IN_STOCK",
  "sellerName": "Walmart.com",
  "sellerType": "WALMART",
  "offerScope": "LOCAL_FULFILLMENT",
  "fulfillment": {
    "shipping": "AVAILABLE",
    "pickup": "AVAILABLE",
    "delivery": "AVAILABLE"
  },
  "previous": null,
  "changes": [],
  "isFirstObservation": true,
  "fetchedAt": "2026-07-22T11:17:29.318Z",
  "schemaVersion": "1.1.0"
}
```

Export the default dataset as JSON, CSV, Excel, XML, or JSONL. The Actor also writes an `OUTPUT` summary with matrix accounting, reason counts, health status, circuit-breaker state, billing evidence, time to first row, and runtime statistics.

### Automatic price and stock change detection

Set a stable `monitorName` to compare each successful observation with the prior successful observation for the same product and ZIP.

With `includeUnchanged: true`, the Actor returns every validated row and attaches `previous` plus `changes` when history exists.

With `includeUnchanged: false`, it returns only:

- The first baseline for each product × ZIP.
- Rows with a real price, availability, seller, store, offer-scope, or fulfillment change.
- Explicit failure rows.

Successfully checked but unchanged rows are hidden from the dataset. The validated check is still charged because Walmart was queried and the store context was verified.

This example shows the format produced when a later observation contains a price drop:

```json
{
  "previous": { "price": 1.78, "availability": "IN_STOCK", "storeId": "5402" },
  "changes": [
    { "field": "price", "from": 1.78, "to": 1.48, "type": "PRICE_DROP" }
  ]
}
```

Use [Apify schedules](https://docs.apify.com/schedules) to run checks automatically. Connect the dataset or run events to your own webhook, Discord workflow, Make, Zapier, or another destination when you want notifications. The Actor detects and structures changes; it does not send alerts until you connect an integration.

### How location validation works

A Walmart product can show different prices, availability, sellers, and fulfillment options by location. A generic product row can quietly show the wrong market, especially when a ZIP parameter is accepted but never verified.

For every product × ZIP combination, the Actor:

- Resolves the requested ZIP to Walmart's selectable store context.
- Pins the product request to that store.
- Verifies the returned store ID before accepting the row.
- Keeps `zipCodeRequested` separate from the selected store's physical `zipCodeResolved`.
- Compares history by `monitorName + itemId + ZIP`, so one market never contaminates another.
- Emits typed changes such as `PRICE_DROP`, `PRICE_RISE`, `RESTOCKED`, `OUT_OF_STOCK`, and fulfillment changes.
- Charges only successful validated checks.

### Input reference

| Field | Required | Description |
|---|---:|---|
| `products` | Yes | 1-100 objects containing a Walmart `itemId` or Walmart product `url`; optional `reference` is returned as `inputRef`. |
| `zipCodes` | Yes | 1-5 valid five-digit US ZIP codes. |
| `monitorName` | No | Stable 3-64 character name for product-and-ZIP-specific history. Required when `includeUnchanged` is false. |
| `includeUnchanged` | No | Defaults to true. Set false for baseline/change/failure-only output. |

The complete matrix must not exceed 100 checks. For example, 20 products × 5 ZIP codes is valid; 5 products × 50 ZIP codes is not. Split larger watchlists into sequential Actor tasks with different monitor names.

Production request concurrency, US residential routing, retry bounds, and systemic-failure behavior use the validated release profile rather than unsafe user-controlled tuning knobs.

### Status and failure accounting

Only rows that pass store-context and critical-field validation become `success`.

Other outcomes remain visible and structured:

- `partial`: data was present but did not meet the paid-result contract.
- `not_found`: the product repeatedly resolved as unavailable or removed on a fresh session.
- `no_store`: Walmart returned no selectable store for the ZIP.
- `blocked`: human verification, transport defense, or the ZIP circuit breaker stopped the request.
- `timeout` or `invalid`: explicit request or input failure.

Failed and partial rows are free. If every check fails for a systemic reason and no validated row exists, the Actor writes diagnostic `OUTPUT` data and fails the run instead of presenting a false green success.

### Pricing

The current price is **$0.006 per successfully delivered validated check**, or $6 per 1,000. One validated check is one product in one ZIP.

| Successful checks | Price |
|---:|---:|
| 25 | $0.15 |
| 100 | $0.60 |
| 1,000 | $6.00 |

- Platform and proxy usage are included.
- Failed and partial checks are free.
- A successful unchanged check hidden by `includeUnchanged: false` is charged once.
- A row rejected by the customer's maximum run charge is not delivered and is not charged as a validated check.

Apify shows the exact estimated and final run price in Console. Start with a small test before scheduling a full 100-check matrix.

### API example

Run the Walmart price monitor from Node.js:

```javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('kamerozkan/walmart-multi-zip-monitor').call({
  products: [
    { itemId: '10450118', reference: 'milk-half-gallon' },
    { itemId: '10315355', reference: 'bread-regional-watch' },
  ],
  zipCodes: ['10001', '60601', '90210'],
  monitorName: 'daily-us-watchlist',
  includeUnchanged: false,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

You can also call the Actor through HTTP, Python, CLI, webhooks, schedules, Make, Zapier, or Apify's MCP integrations. See the [Apify API documentation](https://docs.apify.com/api/v2) and [dataset documentation](https://docs.apify.com/platform/storage/dataset).

### Choosing this Actor vs. a general Walmart scraper

Choose this Actor when your question is:

> What is the validated local price, digital availability, seller, and fulfillment state of these exact products across these exact ZIP codes? What changed since my last run?

Choose a general-purpose [Walmart scraper in Apify Store](https://apify.com/store?search=walmart) when you primarily need keyword discovery, category crawling, reviews, every marketplace offer, rich catalog content, or thousands of products in one run. Those are useful but different jobs. This Actor deliberately optimizes for a bounded, auditable multi-location monitoring matrix.

### Limits and data meaning

- Walmart.com US only.
- Maximum 100 product × ZIP checks and five ZIP codes per run.
- Known item IDs or product URLs only; no keyword or category discovery.
- `availability`, pickup, delivery, and shipping are Walmart.com's digital signals for the verified selected-store context. They are **not a guarantee that a unit is physically on the shelf** when a person arrives.
- A requested ZIP may legitimately resolve to a store whose physical ZIP differs. Both values and the Walmart-reported distance remain visible.
- Website responses and anti-automation defenses can change. Bounded retries, fresh sessions, validation, explicit failures, circuit breakers, and critical health reporting reduce silent bad data; they cannot promise uninterrupted access.

### FAQ

#### Does this scrape every Walmart seller offer?

No. It returns the selected offer and tells you whether that offer is locally fulfillable or shipping-only. Use a seller-offer scraper if you need every marketplace offer.

#### Can it guarantee shelf inventory?

No online scraper can observe the physical shelf directly. This Actor verifies that Walmart's response belongs to the intended selected store; it does not convert a website signal into a shelf guarantee.

#### Can I monitor more than 100 checks?

Yes. Split the workload into sequential tasks of at most 100 combinations. Keep each task's monitor name stable and unique.

#### Why did my first change-only run return rows?

The first successful observation is the baseline. Later unchanged observations are suppressed; later real changes are emitted.

#### Are failures billed?

No. Failed and partial checks are free. A successful validated check is billed even when an unchanged row is hidden by change-only output.

### Support

Open an issue from the Actor page if a result looks wrong or a run fails. Include the Apify run ID, requested ZIP codes, Walmart item IDs, and the expected versus actual behavior. Do not post API tokens, login details, customer information, or other personal data.

### Release notes

#### Current release

- Verified selected-store context for every accepted result.
- Product-and-ZIP-specific history and typed change detection.
- Explicit full-matrix status accounting.
- Pay-per-result billing for successful validated checks only.
- Dataset and `OUTPUT` schemas for API and AI-agent discovery.

### Responsible use

This independent Actor is not affiliated with, endorsed by, or sponsored by Walmart. It processes publicly accessible product data without customer login, checkout, user-supplied cookies, or personal data. Users are responsible for complying with applicable laws and website terms in their jurisdiction.

# Actor input Schema

## `products` (type: `array`):

Add 1-100 Walmart item IDs or product URLs. Use reference to keep your own SKU or label in every result row.

## `zipCodes` (type: `array`):

Add 1-5 valid five-digit US ZIP codes. Every product is checked in every ZIP.

## `monitorName` (type: `string`):

Stable 3-64 character name used to compare this run with the previous successful observation for the same item and ZIP.

## `monitorKey` (type: `string`):

Deprecated compatibility field for existing saved tasks. New integrations should use monitorName.

## `includeUnchanged` (type: `boolean`):

Keep every validated row. Turn off to return only first baselines, real changes, and explicit failures. monitorName is required when off. Every successful validated check is billed even when an unchanged row is hidden from the dataset.

## `maxConcurrency` (type: `integer`):

Fixed at the production-validated safe value.

## `proxyMode` (type: `string`):

US Residential Proxy is the validated production route.

## `failOnCriticalHealth` (type: `boolean`):

Fails the run after writing diagnostics when every check returns a systemic failure and no validated row is produced.

## Actor input object example

```json
{
  "products": [
    {
      "itemId": "10450118",
      "reference": "milk-half-gallon"
    }
  ],
  "zipCodes": [
    "10001",
    "90210"
  ],
  "includeUnchanged": true,
  "maxConcurrency": 1,
  "proxyMode": "RESIDENTIAL",
  "failOnCriticalHealth": true
}
```

# Actor output Schema

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

Default dataset containing one delivered row per emitted product × ZIP result.

## `runSummary` (type: `string`):

OUTPUT record with accounting, health status, reason counts, circuit-breaker state, billing, and runtime metrics.

# 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 = {
    "products": [
        {
            "itemId": "10450118",
            "reference": "milk-half-gallon"
        }
    ],
    "zipCodes": [
        "10001",
        "90210"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("kamerozkan/walmart-multi-zip-monitor").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 = {
    "products": [{
            "itemId": "10450118",
            "reference": "milk-half-gallon",
        }],
    "zipCodes": [
        "10001",
        "90210",
    ],
}

# Run the Actor and wait for it to finish
run = client.actor("kamerozkan/walmart-multi-zip-monitor").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 '{
  "products": [
    {
      "itemId": "10450118",
      "reference": "milk-half-gallon"
    }
  ],
  "zipCodes": [
    "10001",
    "90210"
  ]
}' |
apify call kamerozkan/walmart-multi-zip-monitor --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=kamerozkan/walmart-multi-zip-monitor",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Walmart Price Tracker by ZIP Code & Stock Monitor",
        "description": "Walmart price tracker for exact products across US ZIP codes. Compare verified local prices, digital stock, fulfillment, and automatic change detection.",
        "version": "0.0",
        "x-build-id": "qGeTosScjUSR0YBDe"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/kamerozkan~walmart-multi-zip-monitor/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-kamerozkan-walmart-multi-zip-monitor",
                "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/kamerozkan~walmart-multi-zip-monitor/runs": {
            "post": {
                "operationId": "runs-sync-kamerozkan-walmart-multi-zip-monitor",
                "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/kamerozkan~walmart-multi-zip-monitor/run-sync": {
            "post": {
                "operationId": "run-sync-kamerozkan-walmart-multi-zip-monitor",
                "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": [
                    "products",
                    "zipCodes"
                ],
                "properties": {
                    "products": {
                        "title": "Walmart products",
                        "minItems": 1,
                        "maxItems": 100,
                        "type": "array",
                        "description": "Add 1-100 Walmart item IDs or product URLs. Use reference to keep your own SKU or label in every result row.",
                        "items": {
                            "type": "object",
                            "additionalProperties": false,
                            "properties": {
                                "itemId": {
                                    "title": "Walmart item ID",
                                    "type": "string",
                                    "description": "Numeric Walmart item ID, usually visible at the end of the product URL.",
                                    "editor": "textfield",
                                    "pattern": "^[0-9]{5,20}$"
                                },
                                "url": {
                                    "title": "Walmart product URL",
                                    "type": "string",
                                    "description": "Alternative to itemId: a walmart.com product URL containing a numeric item ID.",
                                    "editor": "textfield",
                                    "pattern": "^https://([A-Za-z0-9-]+\\.)?walmart\\.com/ip/.+/[0-9]{5,20}(?:[/?#].*)?$"
                                },
                                "reference": {
                                    "title": "Your reference",
                                    "type": "string",
                                    "description": "Optional customer SKU, alert label, or internal identifier returned as inputRef.",
                                    "editor": "textfield",
                                    "minLength": 1,
                                    "maxLength": 128
                                }
                            }
                        }
                    },
                    "zipCodes": {
                        "title": "US ZIP codes",
                        "minItems": 1,
                        "maxItems": 5,
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Add 1-5 valid five-digit US ZIP codes. Every product is checked in every ZIP.",
                        "items": {
                            "type": "string",
                            "pattern": "^[0-9]{5}$"
                        }
                    },
                    "monitorName": {
                        "title": "Monitor name",
                        "pattern": "^[A-Za-z0-9._-]{3,64}$",
                        "minLength": 3,
                        "maxLength": 64,
                        "type": "string",
                        "description": "Stable 3-64 character name used to compare this run with the previous successful observation for the same item and ZIP."
                    },
                    "monitorKey": {
                        "title": "Legacy monitor key",
                        "type": "string",
                        "description": "Deprecated compatibility field for existing saved tasks. New integrations should use monitorName."
                    },
                    "includeUnchanged": {
                        "title": "Include unchanged observations",
                        "type": "boolean",
                        "description": "Keep every validated row. Turn off to return only first baselines, real changes, and explicit failures. monitorName is required when off. Every successful validated check is billed even when an unchanged row is hidden from the dataset.",
                        "default": true
                    },
                    "maxConcurrency": {
                        "title": "Validated request concurrency",
                        "minimum": 1,
                        "maximum": 1,
                        "type": "integer",
                        "description": "Fixed at the production-validated safe value.",
                        "default": 1
                    },
                    "proxyMode": {
                        "title": "Validated proxy route",
                        "enum": [
                            "RESIDENTIAL"
                        ],
                        "type": "string",
                        "description": "US Residential Proxy is the validated production route.",
                        "default": "RESIDENTIAL"
                    },
                    "failOnCriticalHealth": {
                        "title": "Fail on systemic outage",
                        "type": "boolean",
                        "description": "Fails the run after writing diagnostics when every check returns a systemic failure and no validated row is produced.",
                        "default": true
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
