# Meijer Product Price Scraper (`lokki/meijer-product-price-scraper`) Actor

Scrape public Meijer product pages and search/category pages for product names, prices, availability, images, UPC/SKU data, and URLs. Built for grocery price monitoring, local retail research, and competitive pricing workflows.

- **URL**: https://apify.com/lokki/meijer-product-price-scraper.md
- **Developed by:** [Ian Dikhtiar](https://apify.com/lokki) (community)
- **Categories:** AI, E-commerce, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.90 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## Meijer Product Price Scraper

### Track Meijer prices, availability, and product data at scale

Need reliable Meijer grocery and retail price data without manually checking hundreds of products? This actor turns Meijer search terms and product URLs into clean, structured product rows with prices, stock status, UPC/SKU identifiers, product URLs, and images.

Use it to monitor competitors, build grocery price datasets, enrich product catalogs, compare market baskets by location, or power retail intelligence workflows.

### Why use this actor?

Meijer product pages and search results can be difficult to scrape with a normal browser crawler. Automated sessions may hit edge protection or return `Access Denied` instead of product data.

This actor is built around that reality. For search terms, it uses Meijer's public product-search data path first, which is faster and more reliable than waiting for rendered search pages. Browser extraction remains available as a fallback for direct product and category URLs.

That means you get practical output instead of a scraper that looks good in theory and dies on the first real run.

### What you can do with it

- Monitor Meijer prices for grocery, household, baby, pet, health, and personal-care products
- Compare product prices across a market basket
- Resolve ZIP codes/cities to nearby Meijer stores and attach store context
- Generate price, brand, availability, query, category, and location intelligence
- Track availability changes over time
- Build UPC/SKU-matched retail datasets
- Enrich internal catalogs with Meijer names, images, URLs, and pricing
- Research category assortment and brand coverage
- Feed dashboards, spreadsheets, BI tools, or pricing intelligence systems

### What data do you get?

Each result is a normalized product row:

```json
{
  "productName": "Meijer Whole Milk, Gallon",
  "price": 3.1,
  "salePrice": null,
  "regularPrice": null,
  "currency": "USD",
  "availability": "In stock",
  "brand": "Meijer",
  "size": "Gallon",
  "sku": "4125010200",
  "upc": "4125010200",
  "imageUrl": "https://www.meijer.com/content/dam/meijer/product/...jpg",
  "url": "https://www.meijer.com/shopping/product/meijer-whole-milk-gallon/4125010200.html",
  "sourceType": "listing",
  "storeContext": "49525",
  "extractionConfidence": "constructor-api",
  "searchQuery": "milk",
  "resolvedSearchQuery": "milk",
  "scrapedAt": "2026-05-13T16:00:00.000Z"
}
````

### Key benefits

#### Built for price monitoring

Submit product keywords like `milk`, `eggs`, `toothpaste`, `dog food`, or `paper towels` and receive structured rows ready for tracking, comparison, and analysis.

#### Better reliability for search inputs

Keyword searches use Meijer's public search data path instead of relying only on browser-rendered pages, reducing failures from blocked search pages.

#### Location-aware outputs

Pass ZIP codes or city/state searches and the actor resolves nearby Meijer stores, then attaches store ID, store name, address, city, state, ZIP, distance, and market key to product rows.

#### Built-in analytics intelligence

Every run can generate a `SUMMARY` record with totals, cheapest and most expensive products, average prices, query-level stats, location-level stats, availability counts, brand counts, and category signals.

#### Clean product identifiers

The actor captures UPC/SKU-style identifiers when available, making it much easier to join Meijer products against your own catalog or external datasets.

#### Ready for business workflows

Output includes product name, price, availability, brand, size, image, URL, source query, and scrape timestamp. No messy DOM cleanup required.

#### Handles overlapping inputs

If multiple search terms return the same product, the actor deduplicates rows so your dataset stays cleaner.

#### Browser fallback included

For direct product URLs and some category/listing pages, the actor can still use Playwright browser extraction when useful.

### Input examples

#### Search by keywords

Best for broad price monitoring and category research.

```json
{
  "queries": ["milk", "eggs", "bread", "toothpaste", "paper towels"],
  "locations": ["49525", "Detroit, MI"],
  "maxStoresPerLocation": 1,
  "maxItems": 100,
  "includeAnalytics": true,
  "includeProductDetails": false
}
```

#### Scrape Meijer URLs

Use this when you already have product or search URLs.

```json
{
  "startUrls": [
    { "url": "https://www.meijer.com/shopping/search.html?text=coffee" },
    { "url": "https://www.meijer.com/shopping/product/meijer-whole-milk-gallon/4125010200.html" }
  ],
  "maxItems": 50,
  "includeProductDetails": true
}
```

#### Larger market-basket run

```json
{
  "queries": [
    "milk", "eggs", "bread", "butter", "cheese",
    "chicken", "ground beef", "bananas", "paper towels", "toothpaste"
  ],
  "maxItems": 250,
  "maxPages": 50,
  "includeProductDetails": false,
  "proxyConfiguration": { "useApifyProxy": true }
}
```

### Input fields

| Field | Type | Best for |
| --- | --- | --- |
| `queries` | array of strings | Fast, reliable product search by keyword. Recommended for most runs. |
| `startUrls` | array | Meijer search, category, or product URLs. |
| `locations` | array of strings | Optional ZIP codes or city/state queries. Resolves nearby Meijer stores and adds store context. |
| `locationRadiusMiles` | integer | Store search radius. Default: `50`. |
| `maxStoresPerLocation` | integer | Nearby stores to include per location query. Default: `1`. |
| `includeAnalytics` | boolean | Adds per-row price intelligence and writes a run-level `SUMMARY`. Default: `true`. |
| `maxItems` | integer | Total product rows to save. Default: `100`. Max: `5000`. |
| `maxPages` | integer | Browser fallback safety limit. Default: `50`. |
| `zipCode` | string | Optional store-area label saved as `storeContext`. |
| `includeProductDetails` | boolean | Open product detail pages for richer extraction when using URL crawling. |
| `proxyConfiguration` | object | Optional Apify proxy settings for browser fallback pages. |

### Output fields

| Field | Meaning |
| --- | --- |
| `productName` | Product title from Meijer. |
| `price` | Current detected product price. |
| `salePrice` | Sale price when separately available. |
| `regularPrice` | Regular/list price when separately available. |
| `currency` | Usually `USD`. |
| `availability` | Normalized stock status, e.g. `In stock` or `Out of stock`. |
| `brand` | Product brand when available. |
| `size` | Parsed size or pack description when available. |
| `sku` | Meijer product identifier when available. |
| `upc` | UPC/EAN-style identifier when available. |
| `imageUrl` | Product image URL. |
| `url` | Product page URL. |
| `sourceType` | `listing` or `product`. |
| `storeContext` | ZIP/store label from input, if provided. |
| `locationQuery` | Original location query, such as a ZIP code or city/state. |
| `storeId` | Resolved Meijer store ID when available. |
| `storeName` | Resolved store display name. |
| `storeAddress`, `storeCity`, `storeState`, `storeZip` | Resolved store address fields. |
| `storeDistanceMiles` | Distance from the location query when available. |
| `marketKey` | Store/location grouping key used for analytics. |
| `priceRankForQueryLocation` | Rank within the same query + location group. |
| `priceDeltaFromQueryLocationAvg` | Difference from the average price for the same query + location group. |
| `isLowestPriceForQueryLocation` | Whether this is the cheapest row in its query + location group. |
| `isHighestPriceForQueryLocation` | Whether this is the most expensive row in its query + location group. |
| `priceBucket` | Price band such as `under_2`, `2_to_5`, `5_to_10`, `10_to_25`, or `25_plus`. |
| `extractionConfidence` | Extraction source, such as `constructor-api` or `json-ld`. |
| `searchQuery` | Original keyword that produced the product. |
| `resolvedSearchQuery` | Actual fallback query used, if different. |
| `scrapedAt` | Timestamp for the extracted row. |

### Reliability proof

This actor was tested against a 50-input Meijer search set across grocery, household, pet, baby, health, and personal-care categories.

Validation result:

- **50 / 50 search inputs succeeded**
- **250 product rows extracted**
- **250 / 250 rows had price, product name, URL, and availability**

Tested terms included `milk`, `eggs`, `bread`, `coffee`, `chicken`, `ground beef`, `bananas`, `paper towels`, `toothpaste`, `diapers`, `vitamins`, `tylenol`, and `trash bags`.

### Recommended settings

For most use cases:

```json
{
  "queries": ["milk", "eggs", "bread"],
  "maxItems": 100,
  "includeProductDetails": false
}
```

Use `includeProductDetails: true` when you specifically need richer metadata from product pages and are comfortable with slower browser-based crawling.

### Analytics summary

When `includeAnalytics` is enabled, the actor writes a `SUMMARY` record to the default key-value store. It includes:

- run totals and coverage
- products with price and availability
- unique UPC and brand counts
- cheapest and most expensive products
- query-level price intelligence
- location/store-level price intelligence
- brand frequency
- availability counts
- category signals
- warnings from partial failures

### Important notes

- Meijer prices and availability can vary by store, fulfillment method, account state, and time.
- `zipCode` is recorded as context, but exact store-specific pricing should be verified for high-stakes decisions.
- Direct browser extraction can still be blocked by Meijer's edge protection if proxies are not suitable.
- The actor does not log in, add products to cart, or access account-specific offers.

### FAQ

#### Does this actor require a Meijer account?

No. It extracts publicly available product data.

#### Is this better for search terms or product URLs?

Search terms are the strongest path. They are faster and more reliable because they use Meijer's public product-search data path. Product URLs are supported through browser/page extraction.

#### Can I run many keywords at once?

Yes. The actor was validated against 50 search inputs in one run.

#### What happens if a query returns duplicate products?

Duplicates are removed using product URL, SKU/UPC, name, and price signals.

#### What if one query returns fewer results than expected?

The actor performs a deeper fill pass to use remaining `maxItems` capacity where possible.

### Local development

```bash
npm install
npm test
npm start
```

For local runs, put your input in `storage/key_value_stores/default/INPUT.json` or run through Apify tooling.

# Actor input Schema

## `startUrls` (type: `array`):

Product pages, search results, or category pages from meijer.com.

## `queries` (type: `array`):

Search terms such as milk, eggs, paper towels, vitamins, or dog food. Recommended for fastest and most reliable runs.

## `locations` (type: `array`):

Optional ZIP codes or city/state location queries. The actor resolves nearby Meijer stores and attaches store/location context to each product row.

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

Optional single ZIP code. Prefer the Locations field for multi-location runs. This value is recorded as storeContext and used as a fallback location query.

## `locationRadiusMiles` (type: `integer`):

Radius used when resolving nearby Meijer stores for each location query.

## `maxStoresPerLocation` (type: `integer`):

How many nearby stores to attach per location query. Use 1 for concise market-basket runs, more for regional comparisons.

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

Stop after this many product rows across all queries and locations.

## `maxPages` (type: `integer`):

Safety limit for browser-fallback pages, including product pages discovered from search/category pages.

## `includeAnalytics` (type: `boolean`):

Adds per-row price intelligence and writes a SUMMARY key-value-store record with query, location, brand, availability, and price analytics.

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

When enabled, URL/browser fallback pages may enqueue product detail pages for richer extraction.

## `proxyConfiguration` (type: `object`):

Optional Apify proxy settings. Residential proxies are recommended if Meijer blocks browser-fallback traffic.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.meijer.com/shopping/search.html?text=milk"
    }
  ],
  "queries": [
    "milk",
    "eggs"
  ],
  "locations": [
    "49525"
  ],
  "locationRadiusMiles": 50,
  "maxStoresPerLocation": 1,
  "maxItems": 100,
  "maxPages": 50,
  "includeAnalytics": true,
  "includeProductDetails": true,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `products` (type: `string`):

Default dataset containing product names, prices, availability, UPC/SKU data, images, URLs, store/location context, source query, and price intelligence fields.

## `productsTable` (type: `string`):

Apify Console dataset view for browsing Meijer product prices and availability.

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

Run-level intelligence with query, location, brand, availability, category, and price analytics.

# 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 = {
    "startUrls": [
        {
            "url": "https://www.meijer.com/shopping/search.html?text=milk"
        }
    ],
    "queries": [
        "milk",
        "eggs"
    ],
    "locations": [
        "49525"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("lokki/meijer-product-price-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 = {
    "startUrls": [{ "url": "https://www.meijer.com/shopping/search.html?text=milk" }],
    "queries": [
        "milk",
        "eggs",
    ],
    "locations": ["49525"],
}

# Run the Actor and wait for it to finish
run = client.actor("lokki/meijer-product-price-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 '{
  "startUrls": [
    {
      "url": "https://www.meijer.com/shopping/search.html?text=milk"
    }
  ],
  "queries": [
    "milk",
    "eggs"
  ],
  "locations": [
    "49525"
  ]
}' |
apify call lokki/meijer-product-price-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Meijer Product Price Scraper",
        "description": "Scrape public Meijer product pages and search/category pages for product names, prices, availability, images, UPC/SKU data, and URLs. Built for grocery price monitoring, local retail research, and competitive pricing workflows.",
        "version": "1.0",
        "x-build-id": "jiqzWQ93ToX5gVWQp"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/lokki~meijer-product-price-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-lokki-meijer-product-price-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/lokki~meijer-product-price-scraper/runs": {
            "post": {
                "operationId": "runs-sync-lokki-meijer-product-price-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/lokki~meijer-product-price-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-lokki-meijer-product-price-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": {
                    "startUrls": {
                        "title": "Meijer URLs",
                        "type": "array",
                        "description": "Product pages, search results, or category pages from meijer.com.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "queries": {
                        "title": "Search terms",
                        "type": "array",
                        "description": "Search terms such as milk, eggs, paper towels, vitamins, or dog food. Recommended for fastest and most reliable runs.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "locations": {
                        "title": "Locations / ZIP codes",
                        "type": "array",
                        "description": "Optional ZIP codes or city/state location queries. The actor resolves nearby Meijer stores and attaches store/location context to each product row.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "zipCode": {
                        "title": "Legacy ZIP code / store area",
                        "type": "string",
                        "description": "Optional single ZIP code. Prefer the Locations field for multi-location runs. This value is recorded as storeContext and used as a fallback location query."
                    },
                    "locationRadiusMiles": {
                        "title": "Location search radius miles",
                        "minimum": 1,
                        "maximum": 200,
                        "type": "integer",
                        "description": "Radius used when resolving nearby Meijer stores for each location query.",
                        "default": 50
                    },
                    "maxStoresPerLocation": {
                        "title": "Stores per location",
                        "minimum": 1,
                        "maximum": 10,
                        "type": "integer",
                        "description": "How many nearby stores to attach per location query. Use 1 for concise market-basket runs, more for regional comparisons.",
                        "default": 1
                    },
                    "maxItems": {
                        "title": "Maximum products",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Stop after this many product rows across all queries and locations.",
                        "default": 100
                    },
                    "maxPages": {
                        "title": "Maximum pages",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Safety limit for browser-fallback pages, including product pages discovered from search/category pages.",
                        "default": 50
                    },
                    "includeAnalytics": {
                        "title": "Include analytics intelligence",
                        "type": "boolean",
                        "description": "Adds per-row price intelligence and writes a SUMMARY key-value-store record with query, location, brand, availability, and price analytics.",
                        "default": true
                    },
                    "includeProductDetails": {
                        "title": "Open product detail pages",
                        "type": "boolean",
                        "description": "When enabled, URL/browser fallback pages may enqueue product detail pages for richer extraction.",
                        "default": true
                    },
                    "proxyConfiguration": {
                        "title": "Proxy settings",
                        "type": "object",
                        "description": "Optional Apify proxy settings. Residential proxies are recommended if Meijer blocks browser-fallback traffic.",
                        "default": {
                            "useApifyProxy": 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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
