# Walmart Product Scraper (`jdtpnjtp/walmart-product-scraper`) Actor

Scrape Walmart products by keyword, ID, or category URL. Get title, brand, price, rollback, rating, review count, stock, seller, specs, images. Modes: search, product detail, bestsellers, deals, category. Pay per result.

- **URL**: https://apify.com/jdtpnjtp/walmart-product-scraper.md
- **Developed by:** [Data Forge](https://apify.com/jdtpnjtp) (community)
- **Categories:** E-commerce, Automation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.10 / 1,000 product results

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 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

## Walmart Product Scraper

Scrape Walmart products by keyword, product ID, or category URL and get clean, structured rows: title, brand, price, rollback, rating, review count, stock, seller, specs, and images. **Products from $1 / 1,000 results**, and you can pull thousands of products in one run. Pay only per result, no subscription.

### Why this Actor?

Most Walmart scrapers stop at keyword search. This one pulls 5 data surfaces, sorts by price and recency, resolves item IDs to full product pages, and keeps running when one input goes bad.

| Capability | Walmart Product Scraper (Data Forge) | Typical Walmart scrapers |
|---|---|---|
| Data surfaces in one run | **5: search, product detail, best sellers, deals, category URLs** | Search only |
| Sorting | **Price low to high, price high to low, best seller, newest** | Relevance only |
| Detail lookup by item ID | **Resolve a `us_item_id` to its full product page** | Not available |
| Bad input handling | **Free error row, the run keeps going** | One bad input fails the run |
| Billing | **Pay per result** | Flat monthly pricing |

### What does the Walmart Product Scraper do?

The Walmart Product Scraper turns Walmart.com into structured data you can analyze. Feed it search keywords, product IDs, or category URLs and it returns a flat row per product with pricing, ratings, stock, and seller fields. Pick one mode or combine several in a single run.

| Mode | What you give it | What you get back |
|---|---|---|
| 🔎 Search | A keyword like `laptop` | Paginated listing rows for the search |
| 📦 Product detail | A product ID or Walmart URL | Detail rows with specs, model, UPC, images |
| 🏆 Bestsellers | A category (optional) | Ranked top-selling listing rows |
| 🔥 Deals | A category (optional) | Discounted and rollback listing rows |
| 🗂 Category browse | A category path or URL | Listing rows for that category |

Turn on **Fan out to product detail** and each listing row is enriched with a second call that pulls its product page (specifications, images, model number).

### What data can you get from a Walmart product?

Each row carries top-level columns plus the complete product object nested under `data`:

- **name** - product title
- **brand** - manufacturer brand
- **price** - current selling price
- **original_price** - pre-discount list price (rollback signal)
- **rating** - average star rating, 1.0 to 5.0
- **review_count** - number of customer reviews
- **seller_name** - Walmart.com or the marketplace seller
- **availability** / **in_stock** - stock status as text and boolean
- **id** / **us_item_id** - catalog ID and the numeric item ID used for reviews and offers
- **model_number** / **upc** - manufacturer model and barcode (detail rows)
- **url** / **image_url** - product link and primary image
- **data** - the complete payload, including specifications and the image gallery

#### Output row types

The `row_type` field labels each row so mixed runs stay easy to split:

| `row_type` | Emitted by | What the row holds |
|---|---|---|
| `search_result` | Search mode | Listing row for a keyword search |
| `product_detail` | Product mode or fan-out | Full detail row with specs, model, UPC, images |
| `bestseller` | Bestsellers mode | Ranked top-selling listing row |
| `deal` | Deals mode | Rollback or clearance listing row |
| `category_result` | Category mode | Listing row for a category page |

### Input modes

Seven ready-to-run recipes. Paste one into the input, press Start, and export JSON, CSV, or Excel.

#### 1. Search with prices and ratings

A merchandiser pulling a 100-row price-and-rating snapshot for one keyword.

```json
{
  "searchQueries": ["laptop"],
  "dataTypes": ["search"],
  "maxResultsPerType": 100
}
````

#### 2. Cheapest first

A deal hunter who wants the lowest-priced listings sorted to the top.

```json
{
  "searchQueries": ["tv"],
  "dataTypes": ["search"],
  "sort": "price_low",
  "maxResultsPerType": 100
}
```

#### 3. Best sellers by category

A category manager tracking the top-selling products in electronics.

```json
{
  "dataTypes": ["bestsellers"],
  "bestsellersDealsCategory": "electronics",
  "maxResultsPerType": 100
}
```

#### 4. Daily deals monitor

An arbitrage seller watching fresh rollbacks and clearance each morning.

```json
{
  "dataTypes": ["deals"],
  "maxResultsPerType": 100
}
```

#### 5. Product details by item ID

An analyst resolving a known `us_item_id` to specs, model number, and images.

```json
{
  "productIds": ["18533160127"],
  "dataTypes": ["product"]
}
```

#### 6. Category page by URL

A researcher mapping a category straight from its Walmart browse URL.

```json
{
  "categoryUrls": ["https://www.walmart.com/browse/electronics/3944"],
  "dataTypes": ["category"],
  "maxResultsPerType": 100
}
```

#### 7. New arrivals

A trend-spotter surfacing the newest laptops added to Walmart.

```json
{
  "searchQueries": ["laptop"],
  "dataTypes": ["search"],
  "sort": "new",
  "maxResultsPerType": 100
}
```

### How to scrape Walmart products

1. Open the actor. The **Search queries** field is prefilled with `laptop`, so a first run returns real data with zero setup.
2. In **Data types to scrape**, choose the modes you want: Search, Product detail, Bestsellers, Deals, or Category browse.
3. Add your inputs: keywords in Search queries, product IDs or URLs in Product IDs, or paths in Category URLs.
4. Set **Max results per type** (20 for a quick sample, 100 for a solid dataset).
5. Optionally turn on **Fan out to product detail** to enrich each listing with its product page.
6. Click **Start** and export the dataset as JSON, CSV, or Excel.

#### Input example

```json
{
  "searchQueries": ["laptop", "4k tv"],
  "dataTypes": ["search"],
  "maxResultsPerType": 50,
  "sort": "best_match",
  "includeProductDetails": false
}
```

#### Output example

A search listing row:

```json
{
  "query": "laptop",
  "row_type": "search_result",
  "id": "5EI9XQX3W2YN",
  "us_item_id": "853065593",
  "name": "HP 15.6\" Laptop, Intel Core i5, 8GB RAM, 256GB SSD, Silver",
  "brand": "HP",
  "price": 379.00,
  "original_price": 499.00,
  "rating": 4.4,
  "review_count": 1283,
  "seller_name": "Walmart.com",
  "availability": "In stock",
  "in_stock": true,
  "url": "https://www.walmart.com/ip/HP-15-6-Laptop/853065593",
  "image_url": "https://i5.walmartimages.com/asr/abc123.jpeg",
  "data": { "...": "complete product object" }
}
```

A product detail row:

```json
{
  "query": "853065593",
  "row_type": "product_detail",
  "id": "5EI9XQX3W2YN",
  "us_item_id": "853065593",
  "name": "HP 15.6\" Laptop, Intel Core i5-1334U, 8GB RAM, 256GB SSD, Windows 11, Silver",
  "brand": "HP",
  "price": 379.00,
  "original_price": 499.00,
  "rating": 4.4,
  "review_count": 1283,
  "availability": "In stock",
  "model_number": "15-fd0083wm",
  "upc": "196068861234",
  "url": "https://www.walmart.com/ip/HP-15-6-Laptop/853065593",
  "image_url": "https://i5.walmartimages.com/asr/abc123.jpeg",
  "data": { "specifications": { "Processor": "Intel Core i5-1334U", "RAM": "8 GB", "Storage": "256 GB SSD", "Screen Size": "15.6 in" }, "images": ["https://i5.walmartimages.com/asr/abc123.jpeg"] }
}
```

### How much does it cost to scrape Walmart products?

You pay per result, billed by Apify on top of your plan.

- **Listing rows** (search, category, bestsellers, deals): $0.001 each, so **$1 per 1,000 products**.
- **Product detail rows**: $0.0036 each, so **$3.60 per 1,000 detail rows**.

Worked math: the **$5 in free monthly credits** on the Apify free plan covers about **5,000 listing rows** ($5 / $0.001). Want the deep dataset? Scrape 1,000 search listings and fan out product detail on each for roughly **$4.60** ($1 for listings + $3.60 for detail). Error rows stay free, so failed lookups never cost you.

### What can you use Walmart product data for?

- **Price monitoring** - track price and rollback changes across thousands of SKUs on a schedule.
- **Competitor research** - benchmark your catalog against Walmart pricing, ratings, and stock.
- **Assortment analysis** - map what brands and products sell in a category and at what price points.
- **Arbitrage sourcing** - surface rollbacks and clearance deals to flip on other marketplaces.
- **MAP compliance** - watch for sellers breaking minimum advertised price.
- **Stock and availability tracking** - know when products go in and out of stock.
- **Review and rating intelligence** - rank products by review volume and average rating.
- **Catalog enrichment** - fill your product database with model numbers, UPCs, specs, and images.
- **Dynamic repricing** - feed live Walmart prices into your own pricing engine.

### Is it legal to scrape Walmart?

Scraping publicly available data is generally legal in the US, and this actor collects only public product information that any shopper can see, without private or account-gated data. You are responsible for how you use the output. Review Walmart's terms of service, respect copyright and database rights, and avoid collecting personal data. If in doubt, consult a lawyer.

### Related actors

Part of the Data Forge marketplace fleet:

- **[Walmart Reviews Scraper](https://apify.com/jdtpnjtp/walmart-reviews-scraper)** - pull product reviews with rating, title, text, author, date, and verified-purchase status.
- **[Walmart Intelligence Scraper](https://apify.com/jdtpnjtp/walmart-intelligence-scraper)** - the umbrella actor combining product search, detail, and reviews in one run.
- **[Amazon Products Scraper](https://apify.com/jdtpnjtp/amazon-products)** - the same structured-row approach for Amazon search and product detail.

### FAQ

**Do I need a Walmart account?**
No. You provide keywords, product IDs, or category URLs. No credentials are required.

**Is it legal to scrape Walmart product data?**
Collecting public data is generally legal in the US, and this actor reads only public catalog fields a shopper sees, with no account-gated or personal data. You are responsible for how you use the output, so review Walmart's terms and your local law. See the legality note above for detail.

**How fresh is the data?**
Each run pulls the current Walmart catalog, so prices, rollbacks, ratings, and stock reflect what is live when the run starts. Re-run on a schedule to keep a fresh dataset.

**What happens if one of my queries is bad?**
A dead keyword, missing product ID, or broken URL returns a free error row and the run keeps going. One bad input never kills the batch, and error rows are not billed.

**Can I schedule this for price monitoring?**
Yes. Use Apify Schedules to run the actor hourly, daily, or on a custom cron, then diff each dataset to track price, rollback, and stock moves over time.

**What input formats work for products?**
Use a catalog ID, a numeric item ID, or a Walmart product URL. The actor normalizes each one for you.

**Can I run this from my own code or an AI agent?**
Yes. Start runs and read results through the Apify API, the JavaScript and Python SDKs, or MCP for AI agents and assistants. JSON, CSV, and Excel exports are available programmatically.

**Why are some fields empty?**
Listing rows carry fewer fields than detail rows. An empty value means the field does not apply to that row type or was not published for that product. Model number and UPC appear on detail rows.

**How many products can I scrape per run?**
Set Max results per type up to 500 per vertical, and combine modes to pull thousands of products in a single run.

**How do I get specs and the product image gallery?**
Use Product detail mode, or turn on Fan out to product detail so each listing row is enriched with its product page.

### Support

[![Telegram](https://img.shields.io/badge/Telegram-Chat-26A5E4?style=for-the-badge\&logo=telegram\&logoColor=white)](https://t.me/j4dtpnj2tp)
[![WhatsApp](https://img.shields.io/badge/WhatsApp-Message-25D366?style=for-the-badge\&logo=whatsapp\&logoColor=white)](https://wa.me/380686031542)
[![Email](https://img.shields.io/badge/Email-jdtpnjtp%40gmail.com-EA4335?style=for-the-badge\&logo=gmail\&logoColor=white)](mailto:jdtpnjtp@gmail.com)

# Actor input Schema

## `searchQueries` (type: `array`):

Keyword searches (e.g. `laptop`, `4k tv`). Each is paginated up to the per-type cap. Optional if you provide product IDs / category URLs / select Bestsellers or Deals.

## `productIds` (type: `array`):

Walmart products by ID (catalog id or numeric item id) or product URL. Each is pulled as a full product detail.

## `categoryUrls` (type: `array`):

Walmart category paths or URLs (e.g. `/browse/electronics/3944`). Each is browsed up to the per-type cap.

## `dataTypes` (type: `array`):

Which verticals to pull. Search needs queries, Product needs IDs, Category needs URLs. Bestsellers / Deals run only when explicitly selected.

## `maxResultsPerType` (type: `integer`):

Upper bound on results per vertical / input item. 20 = quick sample, 100 = solid dataset.

## `includeProductDetails` (type: `boolean`):

When on, every listing row is enriched with a second call pulling its full product page (specs, all images, model number). This adds a product-detail charge per result on top of the listing event.

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

Order of search and deals results.

## `bestsellersDealsCategory` (type: `string`):

Optional Walmart category ID to scope bestsellers and deals.

## Actor input object example

```json
{
  "searchQueries": [
    "laptop"
  ],
  "productIds": [],
  "categoryUrls": [],
  "dataTypes": [
    "search"
  ],
  "maxResultsPerType": 20,
  "includeProductDetails": false,
  "sort": "best_match"
}
```

# Actor output Schema

## `dataset` (type: `string`):

Default dataset; row\_type discriminates search\_result / category\_result / bestseller / deal / product\_detail. Full payload under data.

## `summary` (type: `string`):

OUTPUT key: product\_results, product\_details, errors, total\_rows, estimated\_cost\_usd, limit\_reached, actor\_version.

# 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 = {
    "searchQueries": [
        "laptop"
    ],
    "productIds": [],
    "categoryUrls": [],
    "dataTypes": [
        "search"
    ],
    "maxResultsPerType": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("jdtpnjtp/walmart-product-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 = {
    "searchQueries": ["laptop"],
    "productIds": [],
    "categoryUrls": [],
    "dataTypes": ["search"],
    "maxResultsPerType": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("jdtpnjtp/walmart-product-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 '{
  "searchQueries": [
    "laptop"
  ],
  "productIds": [],
  "categoryUrls": [],
  "dataTypes": [
    "search"
  ],
  "maxResultsPerType": 20
}' |
apify call jdtpnjtp/walmart-product-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Walmart Product Scraper",
        "description": "Scrape Walmart products by keyword, ID, or category URL. Get title, brand, price, rollback, rating, review count, stock, seller, specs, images. Modes: search, product detail, bestsellers, deals, category. Pay per result.",
        "version": "1.0",
        "x-build-id": "IdWgNZrUWtxnLeflz"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/jdtpnjtp~walmart-product-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-jdtpnjtp-walmart-product-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/jdtpnjtp~walmart-product-scraper/runs": {
            "post": {
                "operationId": "runs-sync-jdtpnjtp-walmart-product-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/jdtpnjtp~walmart-product-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-jdtpnjtp-walmart-product-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "searchQueries": {
                        "title": "Search queries",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Keyword searches (e.g. `laptop`, `4k tv`). Each is paginated up to the per-type cap. Optional if you provide product IDs / category URLs / select Bestsellers or Deals.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "productIds": {
                        "title": "Product IDs or URLs",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Walmart products by ID (catalog id or numeric item id) or product URL. Each is pulled as a full product detail.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "categoryUrls": {
                        "title": "Category URLs",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Walmart category paths or URLs (e.g. `/browse/electronics/3944`). Each is browsed up to the per-type cap.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "dataTypes": {
                        "title": "Data types to scrape",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Which verticals to pull. Search needs queries, Product needs IDs, Category needs URLs. Bestsellers / Deals run only when explicitly selected.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "search",
                                "product",
                                "bestsellers",
                                "deals",
                                "category"
                            ],
                            "enumTitles": [
                                "🔎 Search",
                                "📦 Product detail (by ID)",
                                "🏆 Bestsellers",
                                "🔥 Deals",
                                "🗂 Category browse"
                            ]
                        },
                        "default": [
                            "search",
                            "product",
                            "bestsellers",
                            "deals",
                            "category"
                        ]
                    },
                    "maxResultsPerType": {
                        "title": "Max results per type",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Upper bound on results per vertical / input item. 20 = quick sample, 100 = solid dataset.",
                        "default": 40
                    },
                    "includeProductDetails": {
                        "title": "Fan out listings to full product detail",
                        "type": "boolean",
                        "description": "When on, every listing row is enriched with a second call pulling its full product page (specs, all images, model number). This adds a product-detail charge per result on top of the listing event.",
                        "default": false
                    },
                    "sort": {
                        "title": "Search / deals sort",
                        "enum": [
                            "best_match",
                            "price_low",
                            "price_high",
                            "best_seller",
                            "new"
                        ],
                        "type": "string",
                        "description": "Order of search and deals results.",
                        "default": "best_match"
                    },
                    "bestsellersDealsCategory": {
                        "title": "Bestsellers / deals category ID",
                        "type": "string",
                        "description": "Optional Walmart category ID to scope bestsellers and deals."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
