# The Warehouse NZ Scraper | Search, URLs, Details, Reviews (`abotapi/thewarehouse-co-nz-scraper`) Actor

Scrape The Warehouse New Zealand search results, category pages, and direct product URLs. Extract prices, availability, brand, images, breadcrumbs, attributes, product details, and optional customer reviews. Supports search mode, URL mode, sorting, pagination, and MCP connector export.

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

## Pricing

from $1.00 / 1,000 result items

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

## The Warehouse NZ Scraper

Scrape product data from The Warehouse New Zealand thewarehouse.co.nz in a clean, structured format.

This actor supports two scraping modes:

* **Search mode** — scrape products from one or more keyword searches.
* **URL mode** — scrape from pasted Warehouse search, category, or product URLs.

It can collect product cards, enrich records from product detail pages, extract review data where available, and optionally export product summaries to connected apps through MCP connectors.

### What this actor is for

Use this actor when you need structured product data from The Warehouse NZ without manually copying product pages or search results.

It is useful for:

* product research
* price monitoring
* catalog discovery
* ecommerce analysis
* marketplace tracking
* review collection
* internal product workflows

The actor can discover products from search and category pages, or enrich specific products when you already have the exact product URLs.

### Output

Each product record can include:

* product URL
* product ID
* title
* brand
* price
* price range text
* currency
* availability
* main image
* full image gallery
* breadcrumbs
* category path
* marketplace flags
* seller name, where available
* rating summary fields
* product details, when detail enrichment is enabled
* customer reviews, when review extraction is enabled

The output is written to the default Apify dataset and can be exported as JSON, CSV, Excel, or through the Apify API.

### Reviews

Review extraction is optional.

When customer reviews are available, the actor normalizes them into a consistent structure, including fields such as:

* `id`
* `productId`
* `rating`
* `title`
* `body`
* `authorAlias`
* `publishedAt`
* `verifiedPurchaser`
* `badges`
* `secondaryRatings`
* vote counts

Not every product exposes review data. If no reviews are available, the product record is still saved normally.

### Input highlights

Key input fields include:

* `mode` — choose `search` or `url`
* `queries` — search terms for search mode
* `urls` — Warehouse search, category, or product URLs for URL mode
* `fetchDetails` — enrich product cards using product detail pages
* `fetchReviews` — fetch normalized customer reviews
* `maxReviewsPerProduct` — limit the number of reviews collected per product
* `sortBy` — sort search results by relevance, price, rating, newest, best sellers, or name
* `maxItems` — maximum number of products to save
* `maxPages` — maximum number of result pages to visit
* `proxy` — proxy configuration
* `mcpConnectors` — optional MCP connector IDs for app export
* `notionParentPageUrl` — parent Notion page URL for Notion export
* `maxNotifyListings` — maximum number of products sent to connectors

### Sorting options

Search mode supports the following sort options:

* relevance
* price ascending
* price descending
* top rated
* newest
* best sellers
* name ascending
* name descending

### URL mode

URL mode accepts:

* search result URLs
* category URLs
* direct product URLs

This is useful when you want to scrape a specific Warehouse page or enrich known products instead of starting from keyword search.

### Detail enrichment

When `fetchDetails` is enabled, the actor visits product detail pages to improve the quality and completeness of each record.

Detail enrichment can add or improve:

* product description
* attributes
* image gallery
* breadcrumbs
* category path
* availability
* marketplace and seller fields

Detail enrichment is recommended when you need higher-quality product records rather than lightweight search-result data.

### Export to your apps with MCP connectors

You can optionally send a copy of scraped product summaries into the apps you already use through Model Context Protocol connectors.

Supported connector targets include:

* Notion
* Airtable
* Linear
* Apify

To use connector export:

1. Authorize a connector in Apify under **Settings → Integrations**.
2. Add one or more connector IDs to `mcpConnectors`.
3. If exporting to Notion, set `notionParentPageUrl`.
4. Use `maxNotifyListings` to limit how many products are sent to connectors in a single run.

Connector export is a side channel only:

* it does not change the dataset output
* it does not block a successful scrape
* connector failures are logged and skipped

### What gets sent to connectors

Each connector receives a condensed, human-readable product summary, including fields such as:

* title
* product URL
* price
* availability
* brand
* seller
* key product fields

The full structured JSON record always remains available in the Apify dataset.

### Typical use cases

* Scrape Warehouse NZ search results by keyword.
* Monitor prices and availability for selected products.
* Collect product and review data for ecommerce research.
* Enrich known product URLs with detail-page data.
* Send product summaries into Notion for research tracking.
* Push product records into Airtable for manual review.
* Trigger internal workflows using Apify or MCP-connected tools.
* Keep the full dataset in Apify while mirroring a smaller working set into operational apps.

### Output notes

* Search mode walks result pages until `maxItems` or `maxPages` is reached.
* URL mode supports search, category, and product URLs.
* Detail enrichment improves product descriptions, attributes, images, breadcrumbs, category paths, and availability.
* Review extraction is optional because not every product exposes review data.
* If `mcpConnectors` is empty, the actor writes only to the default Apify dataset.

### Local checks completed

The following checks were completed successfully:

* `npm run typecheck`
* `npm run build`
* live search mode
* URL mode
* sort coverage
* detail enrichment
* review extraction

# Actor input Schema

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

Use search mode for keyword search. Use URL mode when you already have The Warehouse search, category, or product URLs.
## `queries` (type: `array`):

One or more keywords to search. Each query is searched separately.
## `sortBy` (type: `string`):

Maps directly to the storefront search sort rules. URL mode preserves whatever sort is already encoded in the pasted URL.
## `urls` (type: `array`):

Search, category, or product URLs. Pagination starts from the page encoded in the URL when present and walks forward.
## `fetchDetails` (type: `boolean`):

Open each product page for description, brand, structured attributes, breadcrumbs, image gallery and availability.
## `fetchReviews` (type: `boolean`):

Also collect product reviews when the page exposes a review API or inline review markup.
## `maxReviewsPerProduct` (type: `integer`):

Cap on reviews collected per product when Fetch customer reviews is on. Set 0 for all available reviews returned by the detected endpoint.
## `includeUnavailable` (type: `boolean`):

Keep products marked unavailable or out of stock. Turn off to return only likely in-stock products when the page exposes availability.
## `maxItems` (type: `integer`):

Maximum matching products to save. Leave empty or set 0 for unlimited. This is the run's only default cap.
## `maxPages` (type: `integer`):

Leave empty or set 0 for unlimited; the run stops at Max products. Use this only when you want an explicit page cap.
## `mcpConnectors` (type: `array`):

Optionally send the scraped results into the apps you already use, via Model Context Protocol (MCP) connectors. Authorize a connector once under Apify → Settings → Integrations, then select it here. Notion gets a page per item; other connectors receive a best-effort write or digest. Leave empty to skip — this never changes the dataset output. Supported: Notion (https://mcp.notion.com/mcp), Linear (https://mcp.linear.app/sse), Airtable (https://mcp.airtable.com/mcp), Apify (https://mcp.apify.com).
## `notionParentPageUrl` (type: `string`):

URL (or id) of the Notion page under which item pages are created. Required to enable the Notion export; ignored by other connectors.
## `maxNotifyListings` (type: `integer`):

Cap on items written to each connector per run. Does not affect the dataset.
## `proxy` (type: `object`):

Use a proxy configuration that matches your account and traffic needs. The default prefill is suitable for most production runs.

## Actor input object example

```json
{
  "mode": "search",
  "queries": [
    "toaster"
  ],
  "sortBy": "relevance",
  "urls": [
    "https://www.thewarehouse.co.nz/search?q=toaster"
  ],
  "fetchDetails": true,
  "fetchReviews": false,
  "maxReviewsPerProduct": 10,
  "includeUnavailable": true,
  "maxItems": 20,
  "maxPages": 0,
  "maxNotifyListings": 50,
  "proxy": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "NZ"
  }
}
````

# Actor output Schema

## `overview` (type: `string`):

No description

# 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 = {
    "queries": [
        "toaster"
    ],
    "urls": [
        "https://www.thewarehouse.co.nz/search?q=toaster"
    ],
    "proxy": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "apifyProxyCountry": "NZ"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("abotapi/thewarehouse-co-nz-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 = {
    "queries": ["toaster"],
    "urls": ["https://www.thewarehouse.co.nz/search?q=toaster"],
    "proxy": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "NZ",
    },
}

# Run the Actor and wait for it to finish
run = client.actor("abotapi/thewarehouse-co-nz-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 '{
  "queries": [
    "toaster"
  ],
  "urls": [
    "https://www.thewarehouse.co.nz/search?q=toaster"
  ],
  "proxy": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "NZ"
  }
}' |
apify call abotapi/thewarehouse-co-nz-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "The Warehouse NZ Scraper | Search, URLs, Details, Reviews",
        "description": "Scrape The Warehouse New Zealand search results, category pages, and direct product URLs. Extract prices, availability, brand, images, breadcrumbs, attributes, product details, and optional customer reviews. Supports search mode, URL mode, sorting, pagination, and MCP connector export.",
        "version": "0.1",
        "x-build-id": "oJ5peMYpneMPq24Dr"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/abotapi~thewarehouse-co-nz-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-abotapi-thewarehouse-co-nz-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/abotapi~thewarehouse-co-nz-scraper/runs": {
            "post": {
                "operationId": "runs-sync-abotapi-thewarehouse-co-nz-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/abotapi~thewarehouse-co-nz-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-abotapi-thewarehouse-co-nz-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "mode"
                ],
                "properties": {
                    "mode": {
                        "title": "Mode",
                        "enum": [
                            "search",
                            "url"
                        ],
                        "type": "string",
                        "description": "Use search mode for keyword search. Use URL mode when you already have The Warehouse search, category, or product URLs.",
                        "default": "search"
                    },
                    "queries": {
                        "title": "Search keywords",
                        "type": "array",
                        "description": "One or more keywords to search. Each query is searched separately.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "sortBy": {
                        "title": "Sort by",
                        "enum": [
                            "relevance",
                            "price_asc",
                            "price_desc",
                            "top_rated",
                            "newest",
                            "best_sellers",
                            "name_asc",
                            "name_desc"
                        ],
                        "type": "string",
                        "description": "Maps directly to the storefront search sort rules. URL mode preserves whatever sort is already encoded in the pasted URL.",
                        "default": "relevance"
                    },
                    "urls": {
                        "title": "The Warehouse URLs",
                        "type": "array",
                        "description": "Search, category, or product URLs. Pagination starts from the page encoded in the URL when present and walks forward.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "fetchDetails": {
                        "title": "Fetch product details",
                        "type": "boolean",
                        "description": "Open each product page for description, brand, structured attributes, breadcrumbs, image gallery and availability.",
                        "default": true
                    },
                    "fetchReviews": {
                        "title": "Fetch customer reviews",
                        "type": "boolean",
                        "description": "Also collect product reviews when the page exposes a review API or inline review markup.",
                        "default": false
                    },
                    "maxReviewsPerProduct": {
                        "title": "Max reviews per product",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Cap on reviews collected per product when Fetch customer reviews is on. Set 0 for all available reviews returned by the detected endpoint.",
                        "default": 10
                    },
                    "includeUnavailable": {
                        "title": "Include unavailable products",
                        "type": "boolean",
                        "description": "Keep products marked unavailable or out of stock. Turn off to return only likely in-stock products when the page exposes availability.",
                        "default": true
                    },
                    "maxItems": {
                        "title": "Max products",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum matching products to save. Leave empty or set 0 for unlimited. This is the run's only default cap.",
                        "default": 20
                    },
                    "maxPages": {
                        "title": "Max pages per query / URL",
                        "minimum": 0,
                        "maximum": 200,
                        "type": "integer",
                        "description": "Leave empty or set 0 for unlimited; the run stops at Max products. Use this only when you want an explicit page cap.",
                        "default": 0
                    },
                    "mcpConnectors": {
                        "title": "Pipe results into your apps (optional)",
                        "type": "array",
                        "description": "Optionally send the scraped results into the apps you already use, via Model Context Protocol (MCP) connectors. Authorize a connector once under Apify → Settings → Integrations, then select it here. Notion gets a page per item; other connectors receive a best-effort write or digest. Leave empty to skip — this never changes the dataset output. Supported: Notion (https://mcp.notion.com/mcp), Linear (https://mcp.linear.app/sse), Airtable (https://mcp.airtable.com/mcp), Apify (https://mcp.apify.com)."
                    },
                    "notionParentPageUrl": {
                        "title": "Notion parent page (Notion connector only)",
                        "type": "string",
                        "description": "URL (or id) of the Notion page under which item pages are created. Required to enable the Notion export; ignored by other connectors."
                    },
                    "maxNotifyListings": {
                        "title": "Max items to export per connector",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Cap on items written to each connector per run. Does not affect the dataset.",
                        "default": 50
                    },
                    "proxy": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Use a proxy configuration that matches your account and traffic needs. The default prefill is suitable for most production runs.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ],
                            "apifyProxyCountry": "NZ"
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```