# Home Depot Scraper (`khadinakbar/home-depot-scraper`) Actor

Scrape Home Depot products by keyword search, product URL, or 9-digit item ID. Returns prices, brand, model, ratings, reviews, pickup/delivery stock, specs, and images. ZIP-aware pricing. SerpApi-backed, HTTP-only, MCP-ready. PPE — $0.005 per product, $0.002 per review.

- **URL**: https://apify.com/khadinakbar/home-depot-scraper.md
- **Developed by:** [Khadin Akbar](https://apify.com/khadinakbar) (community)
- **Categories:** E-commerce, MCP servers, Automation
- **Stats:** 1 total users, 1 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $5.00 / 1,000 product scrapeds

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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

## Home Depot Scraper — Products, Prices, Specs & Reviews

Scrape **Home Depot** product data at scale — by **keyword search**, **product URL**, or **9‑digit item ID** — and get back clean, structured JSON with prices, brand, model number, ratings, review counts, in‑store pickup and delivery availability, specifications, images, and customer reviews. ZIP‑aware so prices and stock match the store you care about.

Built **HTTP‑only and MCP‑ready** — no browser, no cookies, no proxy setup. It calls Home Depot's data through a reliable managed pipeline that handles the site's Akamai anti‑bot protection for you, so runs stay fast and dependable.

> **Why this actor:** Home Depot is one of the hardest US retail sites to scrape reliably. This actor trades brittle browser automation for a managed data path, so you get ~99% run reliability instead of flaky captcha walls — at a flat, predictable per‑product price.

### What you can do with it

- **Price & promotion monitoring** — track prices, "was" prices, and on‑sale flags by ZIP.
- **Catalog & competitor research** — pull a category or keyword's worth of products with brand, model, and ratings.
- **Stock checks** — see pickup/delivery availability for a target ZIP.
- **Review mining** — collect customer reviews for sentiment and product‑quality analysis.
- **AI agents / MCP** — a clean tool call for Claude, ChatGPT, or any MCP client: query in, structured products out.

### Input modes (use any combination)

| Mode | Field | Example | Notes |
|------|-------|---------|-------|
| Keyword search | `searchQueries` | `["cordless drill"]` | Paginated up to `maxResults`. |
| Product URL | `productUrls` | `https://www.homedepot.com/p/.../326680222` | Product URLs fetched in full; search/category URLs treated as keywords. |
| Product ID | `productIds` | `["326680222"]` | 9‑digit Home Depot item number. Fastest, most reliable. |

Plus options: `deliveryZip` (localized pricing), `maxResults`, `maxResultsPerQuery`, `includeProductDetails` (specs + description + images), `includeReviews`.

### Example input

```json
{
  "searchQueries": ["cordless drill", "patio furniture"],
  "productIds": ["326680222"],
  "deliveryZip": "30301",
  "maxResults": 100,
  "includeProductDetails": false,
  "includeReviews": false
}
````

### Output

One flat record per product (and one per review when `includeReviews` is on). Example product record:

```json
{
  "recordType": "product",
  "productId": "326680222",
  "title": "ONE+ 18V Cordless 3/8 in. Drill/Driver Kit with Battery and Charger",
  "brand": "RYOBI",
  "modelNumber": "PCL201K1",
  "price": 49.97,
  "originalPrice": 79.00,
  "onSale": true,
  "currency": "USD",
  "rating": 4.61,
  "reviewsCount": 3901,
  "pickupAvailable": true,
  "deliveryAvailable": true,
  "availabilityText": "Pickup available · Delivery available",
  "thumbnail": "https://images.thdstatic.com/...jpg",
  "url": "https://www.homedepot.com/p/RYOBI-.../326680222",
  "deliveryZip": "30301",
  "searchQuery": "cordless drill",
  "scrapedAt": "2026-06-19T12:34:56.000Z",
  "source": "serpapi:home_depot"
}
```

With `includeProductDetails: true`, records also carry `images[]`, `breadcrumbs[]`, `specifications{}`, and `description`. Review records carry `reviewRating`, `reviewTitle`, `reviewText`, `reviewAuthor`, `reviewDate`, and `verifiedPurchase`.

#### Output field reference

| Field | Type | Description |
|-------|------|-------------|
| `productId` | string | Home Depot 9‑digit item ID. |
| `title` | string | Product title. |
| `brand` | string | Brand / manufacturer. |
| `modelNumber` | string | Manufacturer model number. |
| `price` | number | Current price (USD) for the ZIP. |
| `originalPrice` | number | List price when on sale. |
| `onSale` | boolean | True when discounted. |
| `rating` | number | Average rating 0–5. |
| `reviewsCount` | integer | Total review count. |
| `pickupAvailable` | boolean | In‑store pickup for the ZIP. |
| `deliveryAvailable` | boolean | Delivery for the ZIP. |
| `availabilityText` | string | Human‑readable stock summary. |
| `images` | array | All image URLs (detail mode). |
| `specifications` | object | Spec name → value (detail mode). |
| `description` | string | Full description (detail mode). |
| `url` | string | Canonical product URL. |
| `deliveryZip` | string | ZIP used for pricing. |
| `scrapedAt` | string | ISO‑8601 scrape timestamp. |

### Pricing

This actor uses **pay‑per‑event** billing:

| Event | Price | When |
|-------|-------|------|
| Actor start | $0.00005 | Once per run. |
| Product scraped | **$0.005** | Per product written to the dataset. |
| Review scraped | $0.002 | Per review (only when `includeReviews` is on). |

No bring‑your‑own‑API‑key, no proxy bill, no hidden setup fee. A 100‑product run costs about **$0.50**. You only pay for products actually returned.

### Using it as an MCP tool

Exposed via Apify MCP as `apify--home-depot-scraper`. Point any MCP client at `https://mcp.apify.com?tools=khadinakbar/home-depot-scraper`. Give it a keyword, URL, or product ID and it returns structured products an agent can reason over directly.

### How it works & reliability

Home Depot is protected by **Akamai Bot Manager**, which blocks raw HTTP clients and datacenter IPs at the perimeter. Instead of fighting that with a fragile headless browser, this actor routes requests through a managed data pipeline that solves the anti‑bot layer and returns the same product, search, and review data the Home Depot site uses. Calls are made **serially with automatic retry and exponential backoff**, so a single transient hiccup never fails your whole run. If every input genuinely returns nothing after retries, the run fails honestly with a clear message rather than charging you for an empty dataset.

### FAQ

**Is this US‑only?** Yes. Home Depot product data is sourced from Home Depot US. ZIP‑level pricing requires a US ZIP.

**Do I need a proxy or API key?** No. Everything is handled for you. Just provide a keyword, URL, or product ID.

**How do I get accurate local prices?** Set `deliveryZip` to your target market's 5‑digit ZIP. Prices and stock vary by store.

**Why is `maxResults` capped at 600?** Home Depot search results top out around 576 per keyword. Use multiple, more specific keywords to go wider.

**Can I get full specifications and images?** Set `includeProductDetails: true`. This adds one lookup per product and enriches each record with specs, description, breadcrumbs, and all images.

**What about reviews?** Set `includeReviews: true`. Each customer review becomes its own record, billed at $0.002.

**Runs return 0 products — why?** Either the keyword genuinely has no matches (a clean, free "0 results" success), or Home Depot's upstream was temporarily unavailable (the run fails with a clear message — just retry shortly).

### Related actors

- **walmart-data-extractor** — the same product/price/review shape for Walmart.com.
- **amazon-product-intelligence** — Amazon product data and intelligence.
- **google-shopping-scraper** — cross‑retailer shopping results.

### Legal & compliance

This actor collects **publicly available** product information from Home Depot. It does not log in, bypass paywalls, or collect personal data beyond public reviewer display names. You are responsible for using the data in compliance with Home Depot's Terms of Service, applicable laws (including copyright and database rights), and any privacy regulations relevant to your jurisdiction. Use it for legitimate purposes such as price monitoring, market research, and competitive analysis. This actor is not affiliated with, endorsed by, or sponsored by The Home Depot, Inc. "The Home Depot" is a trademark of its respective owner.

# Actor input Schema

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

Free-text keyword searches run on Home Depot (e.g. 'cordless drill'). Each keyword is paginated up to the maxResults cap and returns product cards with price, brand, model, rating, and stock. Use this when you want to discover products by term rather than fetch a known item. NOT a product URL or item ID — for those use the productUrls or productIds fields.

## `productUrls` (type: `array`):

Home Depot URLs to scrape. A product URL (containing '/p/.../<9-digit-id>') is fetched as a single product; a search or category URL ('/s/...', '/b/...') is treated as a keyword search. Use this when you already have Home Depot links from a sitemap, spreadsheet, or prior run. NOT for bare IDs — put 9-digit numbers in productIds.

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

Home Depot 9-digit internal product IDs (the trailing number in a product URL, e.g. '326680222'). Each ID is fetched directly via the product engine — the fastest, most reliable mode. Use this when you have a list of known SKUs to refresh prices or stock for. NOT model numbers or UPCs — only the 9-digit Home Depot item number works.

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

When true, every product found in search mode is enriched with a second call that adds specifications, full description, all images, and detailed fulfillment. This makes runs slower and costs one extra SerpApi call per product. Defaults to false. Product-ID and product-URL modes always return full detail regardless of this flag.

## `includeReviews` (type: `boolean`):

When true, customer reviews returned by Home Depot for each detailed product are emitted as separate records (one per review) alongside the product records. Reviews are billed at $0.002 each. Defaults to false. Requires product detail, so this implies includeProductDetails for search-mode products.

## `deliveryZip` (type: `string`):

US 5-digit ZIP code used to localize pricing, pickup, and delivery availability (e.g. '30301'). Home Depot prices and stock vary by store, so set this to the buyer's market for accurate data. Defaults to empty, which uses Home Depot's national default. NOT a city name or store ID — only a 5-digit ZIP.

## `maxResults` (type: `integer`):

Maximum number of product records to return across all search keywords and URLs combined (product-ID lookups are always fetched in full and not capped by this). Search results are paginated 24 per page until this cap is hit. Defaults to 48. Range 1–600; Home Depot search tops out near 576 results per keyword.

## `maxResultsPerQuery` (type: `integer`):

Optional per-keyword cap so one broad term does not consume the entire maxResults budget. For example, with three keywords and maxResultsPerQuery 24 you get up to 72 products. Defaults to 0, which means no per-keyword limit (only the global maxResults applies). Ignored for product-ID and product-URL modes.

## Actor input object example

```json
{
  "searchQueries": [
    "cordless drill",
    "patio furniture"
  ],
  "productUrls": [
    "https://www.homedepot.com/p/RYOBI-ONE-18V-Cordless-Drill-PCL201K1/326680222"
  ],
  "productIds": [
    "326680222",
    "312530372"
  ],
  "includeProductDetails": false,
  "includeReviews": false,
  "deliveryZip": "30301",
  "maxResults": 48,
  "maxResultsPerQuery": 0
}
```

# Actor output Schema

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

All Home Depot product and review records scraped in this run. Download as JSON, CSV, Excel, HTML, or RSS.

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

End-of-run JSON with product/review counts, SerpApi calls, charges, stop reason, and warning samples.

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

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

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "searchQueries": [
        "cordless drill"
    ],
    "maxResults": 48
};

// Run the Actor and wait for it to finish
const run = await client.actor("khadinakbar/home-depot-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "searchQueries": ["cordless drill"],
    "maxResults": 48,
}

# Run the Actor and wait for it to finish
run = client.actor("khadinakbar/home-depot-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "searchQueries": [
    "cordless drill"
  ],
  "maxResults": 48
}' |
apify call khadinakbar/home-depot-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Home Depot Scraper",
        "description": "Scrape Home Depot products by keyword search, product URL, or 9-digit item ID. Returns prices, brand, model, ratings, reviews, pickup/delivery stock, specs, and images. ZIP-aware pricing. SerpApi-backed, HTTP-only, MCP-ready. PPE — $0.005 per product, $0.002 per review.",
        "version": "1.0",
        "x-build-id": "66p1b5hPugwYKZM2M"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/khadinakbar~home-depot-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-khadinakbar-home-depot-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/khadinakbar~home-depot-scraper/runs": {
            "post": {
                "operationId": "runs-sync-khadinakbar-home-depot-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/khadinakbar~home-depot-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-khadinakbar-home-depot-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "searchQueries": {
                        "title": "Search keywords",
                        "type": "array",
                        "description": "Free-text keyword searches run on Home Depot (e.g. 'cordless drill'). Each keyword is paginated up to the maxResults cap and returns product cards with price, brand, model, rating, and stock. Use this when you want to discover products by term rather than fetch a known item. NOT a product URL or item ID — for those use the productUrls or productIds fields.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "productUrls": {
                        "title": "Product or search URLs",
                        "type": "array",
                        "description": "Home Depot URLs to scrape. A product URL (containing '/p/.../<9-digit-id>') is fetched as a single product; a search or category URL ('/s/...', '/b/...') is treated as a keyword search. Use this when you already have Home Depot links from a sitemap, spreadsheet, or prior run. NOT for bare IDs — put 9-digit numbers in productIds.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "productIds": {
                        "title": "Product IDs (9-digit)",
                        "type": "array",
                        "description": "Home Depot 9-digit internal product IDs (the trailing number in a product URL, e.g. '326680222'). Each ID is fetched directly via the product engine — the fastest, most reliable mode. Use this when you have a list of known SKUs to refresh prices or stock for. NOT model numbers or UPCs — only the 9-digit Home Depot item number works.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "includeProductDetails": {
                        "title": "Fetch full product details",
                        "type": "boolean",
                        "description": "When true, every product found in search mode is enriched with a second call that adds specifications, full description, all images, and detailed fulfillment. This makes runs slower and costs one extra SerpApi call per product. Defaults to false. Product-ID and product-URL modes always return full detail regardless of this flag.",
                        "default": false
                    },
                    "includeReviews": {
                        "title": "Extract customer reviews",
                        "type": "boolean",
                        "description": "When true, customer reviews returned by Home Depot for each detailed product are emitted as separate records (one per review) alongside the product records. Reviews are billed at $0.002 each. Defaults to false. Requires product detail, so this implies includeProductDetails for search-mode products.",
                        "default": false
                    },
                    "deliveryZip": {
                        "title": "Delivery ZIP code",
                        "type": "string",
                        "description": "US 5-digit ZIP code used to localize pricing, pickup, and delivery availability (e.g. '30301'). Home Depot prices and stock vary by store, so set this to the buyer's market for accurate data. Defaults to empty, which uses Home Depot's national default. NOT a city name or store ID — only a 5-digit ZIP."
                    },
                    "maxResults": {
                        "title": "Max products",
                        "minimum": 1,
                        "maximum": 600,
                        "type": "integer",
                        "description": "Maximum number of product records to return across all search keywords and URLs combined (product-ID lookups are always fetched in full and not capped by this). Search results are paginated 24 per page until this cap is hit. Defaults to 48. Range 1–600; Home Depot search tops out near 576 results per keyword.",
                        "default": 48
                    },
                    "maxResultsPerQuery": {
                        "title": "Max products per keyword",
                        "minimum": 0,
                        "maximum": 600,
                        "type": "integer",
                        "description": "Optional per-keyword cap so one broad term does not consume the entire maxResults budget. For example, with three keywords and maxResultsPerQuery 24 you get up to 72 products. Defaults to 0, which means no per-keyword limit (only the global maxResults applies). Ignored for product-ID and product-URL modes.",
                        "default": 0
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
