# Walmart Intelligence Scraper (`jdtpnjtp/walmart-intelligence-scraper`) Actor

Extract Walmart products, prices and reviews: title, brand, price, rollback, rating, review count, stock, seller, specs and review text. Search, category, bestsellers, deals, product detail and reviews in one Actor. Pay per result.

- **URL**: https://apify.com/jdtpnjtp/walmart-intelligence-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 Scraper

Scrape Walmart products, prices and reviews at scale. **Products from $1 / 1,000, reviews from $0.60 / 1,000, full product detail $3.60 / 1,000.** Search the catalog, browse categories, pull best sellers and rollback deals, get full product detail and collect reviews, then export thousands of clean rows in a single run. Pay only for the rows you keep.

No setup, no browser, no infrastructure to manage. Pick what you need under **What to scrape**, press **Start**, and get flat tables out: **Products** and **Reviews**.

> Prefer a single-purpose tool? Data Forge also ships the focused **Walmart Product Scraper** and **Walmart Reviews Scraper**.

### Why this Actor?

One umbrella Actor covers 6 Walmart data surfaces and can combine them in a single run, so you skip wiring separate tools together and joining their output by hand. Winning cells are in bold.

| Capability | This Actor | Typical single-purpose Walmart actors |
|---|---|---|
| Walmart surfaces in one Actor | **6: search, product detail, best sellers, deals, category URLs, reviews** | 1 surface per actor |
| Product detail + reviews in one run | **Yes - the Product 360 mode below** | Run 2 actors, then join the output yourself |
| Search-to-detail enrichment | **1 toggle - `includeProductDetails`** | Not offered |
| Sort orders on search and deals | **5: best match, price low, price high, best seller, newest** | Limited or none |
| Best sellers and rollback deals by category | **Both, category-scoped** | Separate actors, or missing |
| Combined product + review intelligence | **1 dataset, 6 row types** | 2 datasets to reconcile |
| Billing | **Pay per result, $5 free monthly credit** | Often per-run or a subscription |

### What does the Walmart Scraper do?

It turns a keyword, a product ID, a category or a deals list into structured Walmart data. Tick 1 or more data types and the Actor pulls exactly that:

| Data type | What it returns |
|---|---|
| 🔎 **Search** | Products matching your keyword, paginated. |
| 📦 **Product detail** | A full record for specific products (specs, images, model, brand, seller). |
| 🏆 **Best sellers** / 🔥 **Deals** | Best-seller and rollback / clearance lists by category. |
| 🗂 **Category** | Browse a Walmart category. |
| ⭐ **Reviews** | Product reviews, sorted and paginated. |

The dataset opens on ready-made views (**Products**, **Reviews**), so the right columns are in front of you.

### What data can you get from Walmart?

**Per product:** item ID, title, brand, price, was-price, rollback flag, rating, review count, in-stock status, seller name, model number, UPC, images and the product URL.

**Per review:** reviewer name, star rating, review title, review text, date, helpful votes and verified-purchase flag.

Each row also carries the raw source object under a `data` field, so nothing the page exposes is dropped.

### Input modes

4 published example tasks map 1:1 to the common jobs below. Copy a JSON block into the input editor, or open the matching example task and press **Start**.

#### 1. Product 360 - detail plus reviews in one run

Sellers and product teams: pull a product's full spec sheet and up to 100 recent reviews for the same item in a single run.

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

#### 2. Market snapshot - search enriched with full details

Category managers: map a keyword's top 40 listings and enrich each one with a full product-detail record.

```json
{
  "searchQueries": ["air fryer"],
  "dataTypes": ["search"],
  "includeProductDetails": true,
  "maxResultsPerType": 40
}
```

#### 3. Category intelligence with details

Merchandisers: walk a Walmart category page and enrich the first 40 items with full detail.

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

#### 4. Best-sellers deep-dive

Trend and sourcing analysts: rank a category's best sellers and enrich the top 40 with full detail.

```json
{
  "dataTypes": ["bestsellers"],
  "bestsellersDealsCategory": "electronics",
  "includeProductDetails": true,
  "maxResultsPerType": 40
}
```

### How to scrape Walmart

1. Under **What to scrape**, tick the data types you want. **Search** is prefilled, so the Actor runs on the first click.
2. Fill the matching input: keywords for Search, item IDs or product URLs for Product detail / Reviews, a category URL for Category. Product input is adaptive: an item ID or a product URL both resolve.
3. Set the sort, deals category and reviews options in the collapsible sections.
4. Press **Start**. Export to JSON, CSV, Excel or Google Sheets, or pull from the Apify API.

#### Input example

```json
{
  "dataTypes": ["search"],
  "searchQueries": ["air fryer"],
  "sort": "best_seller",
  "maxResultsPerType": 40,
  "includeProductDetails": true
}
```

### Output

Each dataset item has a `row_type` field, so the 6 surfaces stay easy to filter and split.

| `row_type` | What it is | Key fields |
|---|---|---|
| `search_result` | 1 listing from a keyword search | name, brand, price, rating, seller\_name, in\_stock, url |
| `category_result` | 1 listing from a category browse | name, brand, price, rating, in\_stock, url |
| `product_detail` | Full detail record for 1 product | name, brand, price, model\_number, upc, rating, review\_count, image\_url |
| `bestseller` | 1 item from a category best-sellers list | name, brand, price, rating, url |
| `deal` | 1 rollback / clearance item | name, brand, price, original\_price, url |
| `review` | 1 product review | author, rating, title, text, date, verified\_purchase, helpful\_count |

#### Output examples

Search-result row:

```json
{
  "query": "air fryer",
  "row_type": "search_result",
  "us_item_id": "967557625",
  "name": "Ninja AF101 Air Fryer, 4 Qt",
  "brand": "Ninja",
  "price": 89.0,
  "original_price": 119.0,
  "rating": 4.8,
  "review_count": 38400,
  "seller_name": "Walmart.com",
  "in_stock": true,
  "url": "https://www.walmart.com/ip/967557625"
}
```

Product-detail row:

```json
{
  "query": "18533160127",
  "row_type": "product_detail",
  "us_item_id": "18533160127",
  "name": "Ninja AF101 Air Fryer, 4 Qt, Black and Grey",
  "brand": "Ninja",
  "price": 89.0,
  "original_price": 119.0,
  "rating": 4.8,
  "review_count": 38400,
  "model_number": "AF101",
  "upc": "622356561105",
  "url": "https://www.walmart.com/ip/18533160127"
}
```

Review row:

```json
{
  "query": "18533160127",
  "row_type": "review",
  "review_id": "a1b2c3d4",
  "author": "Jamie R.",
  "rating": 5,
  "title": "Works great",
  "text": "Crispy results each time, easy to clean.",
  "date": "2026-05-22",
  "verified_purchase": true,
  "helpful_count": 12
}
```

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

You pay per result, billed by Apify, with no subscription. With the **$5 free monthly credit** you can pull, for example:

- **~8,300 reviews** (reviews from $0.60 / 1,000), or
- **~5,000 product listings** (products from $1 / 1,000), or
- **~1,380 full product details** ($3.60 / 1,000).

Detail fan-out is opt-in, so a default search run stays cheap. Failed items (a product that no longer exists, an out-of-stock region) are returned for visibility and are **never charged**.

### What can you use Walmart data for?

- **Price and assortment monitoring** - track price, rollback status and availability across a catalog.
- **Competitor and market research** - compare brands, ratings and price bands in a category.
- **Best-seller and deal tracking** - watch what is rising and discounted by category.
- **Product intelligence** - specs, images, model and seller for catalog enrichment.
- **Review mining and sentiment** - feed product reviews into NLP for CX insight.
- **Reseller and arbitrage sourcing** - spot clearance and rollback opportunities at scale.
- **MAP and pricing compliance** - monitor seller prices against policy.

### Is it legal to scrape Walmart?

Scraping publicly available Walmart data is legal in most jurisdictions when you collect only public information and respect personal-data laws such as GDPR and CCPA. This Actor returns only data a visitor can see on Walmart.com. You are responsible for how you use the output, so consult a lawyer for your specific case.

### FAQ

**Can I run just 1 data type?** Yes. Tick only what you need under **What to scrape**; the rest stays idle and uncharged.

**Can I get product detail and reviews for the same item in 1 run?** Yes - that is the Product 360 mode. Pass `productIds` and set `dataTypes` to `["product", "reviews"]`; both surfaces land in the same dataset, keyed by `us_item_id`.

**When should I use this Actor vs the split actors?** Use this umbrella when you want 2 or more surfaces, or a product + review combo, in a single run. Reach for **Walmart Product Scraper** or **Walmart Reviews Scraper** when you only need 1 surface at high volume and want the leanest input form.

**What happens with a bad product ID or a dead listing?** The Actor writes a free error row (with `error_code` and `error_message`), then keeps going with the next item. You are not charged for error rows, and 1 bad input does not stop the run.

**How fresh is the data?** Rows are fetched live from Walmart on each run, so prices, stock and ratings reflect the moment the Actor runs.

**How many reviews can I get per product?** Up to the `maxReviewsPerProduct` cap you set (1 to 1,000), in your chosen sort order.

**Can I enrich a search or category with full detail?** Yes. Turn on `includeProductDetails` and each listing row is enriched with a product-detail record (adds a product-detail charge per enriched row).

**Can I call it from code?** Yes. Run it via the Apify API, the Apify client SDKs, or an MCP server, and read results from the dataset.

### Related actors

Part of the Data Forge Walmart and marketplace fleet:

- **[Walmart Product Scraper](https://apify.com/jdtpnjtp/walmart-product-scraper)** - focused product search, category, best sellers, deals and detail.
- **[Walmart Reviews Scraper](https://apify.com/jdtpnjtp/walmart-reviews-scraper)** - focused, high-volume review extraction.
- **[Amazon Scraper](https://apify.com/jdtpnjtp/amazon)** - products, prices and reviews across Amazon marketplaces.

***

### Support

Built and maintained by **Data Forge**. Need custom fields, higher volume or a quick answer?

[![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-Contact-EA4335?style=for-the-badge\&logo=gmail\&logoColor=white)](mailto:jdtpnjtp@gmail.com)

# Actor input Schema

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

Which verticals to run. Search needs queries, Product/Reviews need product ids, Category needs URLs. Bestsellers / Deals run only when explicitly selected.

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

Keyword searches (e.g. `laptop`, `4k tv`).

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

Walmart products by ID (catalog id or numeric item id) or product URL. Used by Product detail and Reviews.

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

Walmart category paths or URLs (e.g. `/browse/electronics/3944`).

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

Upper bound on results per vertical / input item (1-500).

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

When on, every listing row is enriched with a full product-detail call (adds a product-detail charge per result).

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

Order of search and deals results.

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

Optional Walmart category ID to scope bestsellers and deals.

## `reviewsSort` (type: `string`):

Sort order for the Reviews vertical.

## `maxReviewsPerProduct` (type: `integer`):

Cap on reviews per product for the Reviews vertical (1-1000).

## Actor input object example

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

# Actor output Schema

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

Default dataset; row\_type discriminates search\_result / category\_result / bestseller / deal / product\_detail / review. Full payload under data. Views: Overview / Products / Reviews.

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

OUTPUT key: data\_types, product\_results, product\_details, reviews, 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 = {
    "dataTypes": [
        "search"
    ],
    "searchQueries": [
        "laptop"
    ],
    "productIds": [],
    "categoryUrls": [],
    "maxResultsPerType": 20
};

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

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Walmart Intelligence Scraper",
        "description": "Extract Walmart products, prices and reviews: title, brand, price, rollback, rating, review count, stock, seller, specs and review text. Search, category, bestsellers, deals, product detail and reviews in one Actor. Pay per result.",
        "version": "1.0",
        "x-build-id": "pIjuceSj14AUEcMXa"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/jdtpnjtp~walmart-intelligence-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-jdtpnjtp-walmart-intelligence-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-intelligence-scraper/runs": {
            "post": {
                "operationId": "runs-sync-jdtpnjtp-walmart-intelligence-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-intelligence-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-jdtpnjtp-walmart-intelligence-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": {
                    "dataTypes": {
                        "title": "Data types to scrape",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Which verticals to run. Search needs queries, Product/Reviews need product ids, Category needs URLs. Bestsellers / Deals run only when explicitly selected.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "search",
                                "product",
                                "bestsellers",
                                "deals",
                                "category",
                                "reviews"
                            ],
                            "enumTitles": [
                                "🔎 Search",
                                "📦 Product detail (by id)",
                                "🏆 Bestsellers",
                                "🔥 Deals",
                                "🗂 Category browse",
                                "⭐ Reviews"
                            ]
                        },
                        "default": [
                            "search",
                            "product",
                            "bestsellers",
                            "deals",
                            "category",
                            "reviews"
                        ]
                    },
                    "searchQueries": {
                        "title": "Search queries",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Keyword searches (e.g. `laptop`, `4k tv`).",
                        "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. Used by Product detail and Reviews.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "categoryUrls": {
                        "title": "Category URLs",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Walmart category paths or URLs (e.g. `/browse/electronics/3944`).",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxResultsPerType": {
                        "title": "Max results per type",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Upper bound on results per vertical / input item (1-500).",
                        "default": 40
                    },
                    "includeProductDetails": {
                        "title": "Fan out listings to full product detail",
                        "type": "boolean",
                        "description": "When on, every listing row is enriched with a full product-detail call (adds a product-detail charge per result).",
                        "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."
                    },
                    "reviewsSort": {
                        "title": "Reviews sort",
                        "enum": [
                            "relevancy",
                            "submission-desc",
                            "submission-asc",
                            "rating-desc",
                            "rating-asc"
                        ],
                        "type": "string",
                        "description": "Sort order for the Reviews vertical.",
                        "default": "relevancy"
                    },
                    "maxReviewsPerProduct": {
                        "title": "Max reviews per product",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Cap on reviews per product for the Reviews vertical (1-1000).",
                        "default": 40
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
