# Home Depot Product Scraper (`automation-lab/home-depot-product-scraper`) Actor

Extract Home Depot products, prices, ratings, specifications, images, promotions, and ZIP/store-localized fulfillment from keywords and URLs.

- **URL**: https://apify.com/automation-lab/home-depot-product-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** E-commerce
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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/docs.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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 Product Scraper

Extract structured Home Depot product, price, rating, specification, image, promotion, and local fulfillment data from search terms and public product URLs.

Use it for retail intelligence, price monitoring, assortment research, contractor sourcing, brand tracking, and store-level availability checks.

No Home Depot login is required.

### What does Home Depot Product Scraper do?

Home Depot Product Scraper turns public `homedepot.com` pages into export-ready records.

Give it one or more:

- 🔎 Search keywords such as `cordless drill`
- 🔗 Home Depot search result URLs
- 🧰 Home Depot product detail URLs

The Actor returns unique products with identifiers, commercial data, content, social proof, and location-aware fulfillment details.

It handles Home Depot's public anti-bot layer with US residential browser sessions and bounded retries.

### Who is it for?

#### Retail pricing teams

Track current prices, original prices, promotions, and local inventory for comparable products.

#### Brands and manufacturers

Monitor how products appear on Home Depot, including titles, images, ratings, review counts, specifications, and availability.

#### Contractors and procurement teams

Compare products and check pickup, delivery, quantity, and store context before purchasing.

#### Market researchers

Build repeatable snapshots of categories, brands, assortments, and customer demand signals.

#### Data and automation teams

Feed clean Home Depot data into databases, dashboards, spreadsheets, webhooks, APIs, and AI agents.

### Why use this Home Depot scraper?

- ✅ Search by keyword or scrape exact product URLs
- ✅ Receive clean JSON, CSV, Excel, XML, and RSS exports
- ✅ Deduplicate products by Home Depot item ID
- ✅ Capture price, promotion, rating, images, and inventory in one row
- ✅ Localize fulfillment with a store ID and US ZIP code
- ✅ Avoid maintaining anti-bot browser infrastructure
- ✅ Pay only for the run start and products successfully saved
- ✅ Integrate through Apify API, schedules, webhooks, and MCP

### What Home Depot data can you extract?

| Field | Description |
|---|---|
| `itemId` | Home Depot Internet item ID |
| `productUrl` | Canonical public product URL |
| `title` | Product name |
| `brand` | Brand or manufacturer |
| `modelNumber` | Manufacturer model number |
| `storeSku` | Home Depot store SKU |
| `parentId` | Parent or product-family item ID |
| `productType` | Home Depot product classification |
| `price` | Current localized price when displayed |
| `originalPrice` | Original price when displayed |
| `promotion` | Promotion and savings metadata |
| `rating` | Average customer rating |
| `reviewCount` | Total customer review count |
| `imageUrls` | Full-size product image URLs |
| `description` | Product description on detail pages |
| `highlights` | Product highlights on detail pages |
| `specifications` | Name/value specification table |
| `categories` | Home Depot category hierarchy |
| `availability` | Buyable and discontinued status |
| `fulfillment` | Pickup, shipping, delivery, and inventory rows |
| `storeId` | Store context requested by the user |
| `zipCode` | Delivery ZIP context requested by the user |
| `sourceUrl` | Input page that produced the record |
| `scrapedAt` | UTC extraction timestamp |

Search pages naturally contain fewer detail fields than product pages.

Use product URLs when specifications and long descriptions are essential.

### How to scrape Home Depot products

1. Open the Actor input page.
2. Add one or more search keywords or Home Depot URLs.
3. Set a low `maxItems` value for your first test.
4. Enter the delivery ZIP code and Home Depot store ID you want to monitor.
5. Click **Start**.
6. Preview records in the **Home Depot products** dataset view.
7. Export the dataset or connect it to your workflow.

A first run with one keyword and 10 products is usually enough to validate the fields.

### Input options

#### Search keywords

`keywords` is an array of Home Depot search phrases.

Examples:

- `cordless drill`
- `french door refrigerator`
- `patio furniture`
- `Milwaukee M18`

#### Product or search URLs

`productUrls` accepts public Home Depot product pages and search result pages.

You can mix keyword and URL inputs in the same run.

#### Maximum products

`maxItems` is the global limit across every input.

Duplicate item IDs do not count twice.

#### Delivery ZIP code

`zipCode` sets the requested US delivery context.

The default is `30303`.

#### Home Depot store ID

`storeId` sets the requested store context for price and fulfillment data.

The default is `121`.

### Input example

```json
{
  "keywords": ["cordless drill", "impact driver"],
  "productUrls": [
    {
      "url": "https://www.homedepot.com/p/Whirlpool-25-cu-ft-French-Door-Refrigerator-in-Fingerprint-Resistant-Stainless-Steel-WRF555SDFZ/301711642"
    }
  ],
  "maxItems": 25,
  "zipCode": "30303",
  "storeId": "121"
}
````

### Output example

```json
{
  "itemId": "326680222",
  "productUrl": "https://www.homedepot.com/p/RYOBI-ONE-18V-Cordless-3-8-in-Drill-Driver-Kit-with-Compact-Battery-and-Charger-PCL201K1/326680222",
  "title": "ONE+ 18V Cordless 3/8 in. Drill/Driver Kit with Compact Battery and Charger",
  "brand": "RYOBI",
  "modelNumber": "PCL201K1",
  "storeSku": "1010127831",
  "price": 49.97,
  "originalPrice": 49.97,
  "currency": "USD",
  "rating": 4.6051,
  "reviewCount": 3991,
  "categories": ["Tools", "Power Tools", "Drills", "Power Drills"],
  "storeId": "121",
  "zipCode": "30303",
  "scrapedAt": "2026-07-14T06:26:48.616Z"
}
```

Fields unavailable on a source page are omitted rather than invented.

### How much does it cost to scrape Home Depot products?

This Actor uses pay-per-event pricing.

You pay a small run-start fee plus a per-product event for records successfully saved.

The exact tier price appears on the Actor pricing tab before you run it.

Residential browser traffic and compute are included in the Actor's pricing model; no separate proxy setup is needed.

Start with a low `maxItems` value to estimate the cost of your workflow.

### Price monitoring workflow

Schedule a run daily or weekly with stable keywords and location settings.

Export these fields into your database:

- `itemId`
- `price`
- `originalPrice`
- `promotion`
- `availability`
- `fulfillment`
- `scrapedAt`

Compare each snapshot with the previous one to detect price, promotion, or stock changes.

Use a webhook to notify Slack, email, or your internal system when values change.

### Local inventory and fulfillment

Home Depot data can vary by store and ZIP code.

The `fulfillment` array can include:

- Buy online, pick up in store
- Ship to home
- Express or scheduled delivery
- Store name and location ID
- Inventory quantity and stock flags
- Distance from the selected location
- Delivery timeline and charge

Availability is public but can change quickly.

Treat each run as a timestamped observation, not a reservation guarantee.

### Search pages versus product pages

Search pages are efficient for assortment discovery.

They usually include:

- IDs
- Titles and brands
- Prices and promotions
- Ratings and review counts
- Images
- Category paths
- Fulfillment summaries

Product pages are best for enrichment.

They can additionally include:

- Long descriptions
- Product highlights
- Full specification tables
- More images
- Rich product metadata

For a two-stage workflow, scrape search results first and then run selected `productUrl` values through a detail job.

### Tips for reliable runs

- 🎯 Keep the first run to 5–10 products.
- 📍 Use a real US ZIP code and its matching Home Depot store ID.
- 🔗 Prefer canonical Home Depot URLs.
- 🧩 Use detail URLs when specifications are required.
- ⏱️ Schedule at a reasonable frequency; inventory may change throughout the day.
- 🧹 Deduplicate downstream by `itemId` and `scrapedAt`.
- 🔄 Retry a failed run later if Home Depot temporarily restricts public traffic.

The Actor automatically rotates up to six residential sessions per source.

### Export formats

Apify datasets support:

- JSON
- JSONL
- CSV
- Excel
- XML
- RSS

Choose a clean export to omit hidden dataset metadata.

Large image and fulfillment arrays are preserved most naturally in JSON.

### Integrations

#### Google Sheets

Send each completed dataset to a spreadsheet for a lightweight price watch list.

#### Webhooks

Trigger an automation when the run succeeds, fails, or times out.

#### Make and Zapier

Connect product records to alerts, CRM objects, catalog audits, or reporting flows.

#### Amazon S3 and cloud storage

Archive timestamped JSON snapshots for historical analysis.

#### Databases and BI tools

Load stable item IDs and numeric fields into PostgreSQL, BigQuery, Snowflake, or a dashboard.

### API usage

#### JavaScript API access

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/home-depot-product-scraper').call({
  keywords: ['cordless drill'],
  maxItems: 10,
  zipCode: '30303',
  storeId: '121'
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

### API access with Python

```python
from apify_client import ApifyClient

client = ApifyClient('YOUR_APIFY_TOKEN')
run = client.actor('automation-lab/home-depot-product-scraper').call(run_input={
    'keywords': ['cordless drill'],
    'maxItems': 10,
    'zipCode': '30303',
    'storeId': '121',
})
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

### API access with cURL

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~home-depot-product-scraper/runs?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"keywords":["cordless drill"],"maxItems":10,"zipCode":"30303","storeId":"121"}'
```

Poll the returned run ID, then download items from its default dataset.

### Use with Apify MCP

Connect the Actor to AI assistants through the Apify MCP server:

`https://mcp.apify.com?tools=automation-lab/home-depot-product-scraper`

#### Claude Code setup

```bash
claude mcp add --transport http apify-home-depot "https://mcp.apify.com?tools=automation-lab/home-depot-product-scraper"
```

Then ask:

> Scrape 10 Home Depot cordless drills for store 121 and compare price, rating, and pickup quantity.

#### Claude Desktop setup

Add this server to the Claude Desktop MCP configuration:

```json
{
  "mcpServers": {
    "apify-home-depot": {
      "url": "https://mcp.apify.com?tools=automation-lab/home-depot-product-scraper"
    }
  }
}
```

Then ask:

> Extract this Home Depot refrigerator page and summarize its specifications and customer rating.

#### Cursor setup

Use the same `mcpServers` JSON in Cursor MCP settings and enable `apify-home-depot`.

#### VS Code setup

Add the same HTTP MCP URL through the VS Code MCP server settings, then select the Home Depot tool in agent mode.

#### Example prompts

- "Scrape 10 Home Depot cordless drills and rank them by rating and price."
- "Extract this Home Depot appliance page and summarize its dimensions and warranty."
- "Monitor patio furniture for ZIP 10001 and show products available for pickup."
- "Compare current price, original price, promotion, and inventory for these product URLs."

#### Agent workflow prompt

> Run a weekly Home Depot patio furniture monitor for ZIP 10001, store 6175, and flag products whose price changed.

MCP makes the Actor callable as a tool while datasets preserve the complete structured result.

### Scheduling and webhooks

Create an Apify schedule for recurring monitoring.

Use the same input on each run so item IDs and location context remain comparable.

A webhook can send the run dataset ID to your processing service.

Recommended pattern:

1. Schedule the Actor.
2. Receive a successful-run webhook.
3. Download the default dataset.
4. Compare it with the previous snapshot.
5. Store changes and send alerts.

### Data quality and limitations

Home Depot controls the source data and can change page structure, prices, inventory, and availability.

Some products intentionally hide prices or are store-only.

Search records may not contain full specifications.

A selected store may not serve every ZIP code.

The Actor extracts public observations and does not place orders, reserve inventory, or access accounts.

### Legality and responsible use

This Actor accesses public product pages without logging in.

You are responsible for your use case, collection volume, storage, and compliance with applicable laws and website terms.

Do not use the Actor to collect personal data, bypass access controls, or interfere with the source service.

Use reasonable schedules and retain only data needed for a legitimate purpose.

### Troubleshooting

#### Why did a run return no products?

Check that the URLs are public `homedepot.com` product or search pages and that keywords are not empty.

Home Depot may temporarily block public sessions; retry later if all six bounded sessions fail.

#### Why is price missing?

Some products hide price, require store selection, are unavailable, or expose price only for a different location.

Try a relevant store ID and ZIP code.

#### Why are specifications empty?

Search pages expose overview data.

Run the returned `productUrl` as a detail input for richer fields.

#### Why does inventory differ from the website?

Inventory changes quickly and may depend on location, quantity, delivery method, and source timing.

Use `scrapedAt`, `storeId`, and `zipCode` when comparing observations.

### FAQ

#### Does the Actor require a Home Depot account?

No.

It accesses public US product and search pages anonymously.

#### Can I scrape multiple keywords?

Yes.

Add several values to `keywords`; the global `maxItems` limit applies across them.

#### Are duplicate products returned?

No.

Records are deduplicated by Home Depot item ID within each run.

#### Can I scrape reviews?

The Actor returns aggregate rating and review count.

It does not output individual review records.

#### Can I monitor a specific store?

Yes.

Set `storeId` and `zipCode` and preserve those values across scheduled runs.

#### Does it support Canada or Mexico?

No.

The current Actor targets the public US `homedepot.com` catalog.

### Related scrapers

Combine this Actor with other automation-lab retail tools:

- [Amazon Product Scraper](https://apify.com/automation-lab/amazon-product-scraper)
- [Walmart Product Scraper](https://apify.com/automation-lab/walmart-product-scraper)
- [Google Shopping Scraper](https://apify.com/automation-lab/google-shopping-scraper)

Use source-specific IDs separately and join products by model number, GTIN, brand, or normalized title when appropriate.

### Support

If a valid public Home Depot input fails consistently, open an issue from the Actor page.

Include:

- The input URL or keyword
- Store ID and ZIP code
- Approximate run time
- The failing run URL
- The expected product or field

Do not include passwords, account cookies, payment details, or other secrets.

# Actor input Schema

## `keywords` (type: `array`):

Home Depot search terms such as cordless drill, refrigerator, or patio furniture.

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

Public homedepot.com product detail or search result URLs.

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

Stop after this many unique products across all inputs.

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

US ZIP code used for localized fulfillment data.

## `storeId` (type: `string`):

Numeric Home Depot store ID used for local price, pickup, and inventory context.

## Actor input object example

```json
{
  "keywords": [],
  "productUrls": [
    {
      "url": "https://www.homedepot.com/p/Whirlpool-25-cu-ft-French-Door-Refrigerator-in-Fingerprint-Resistant-Stainless-Steel-WRF555SDFZ/301711642"
    }
  ],
  "maxItems": 1,
  "zipCode": "30303",
  "storeId": "121"
}
```

# 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 = {
    "keywords": [],
    "productUrls": [
        {
            "url": "https://www.homedepot.com/p/Whirlpool-25-cu-ft-French-Door-Refrigerator-in-Fingerprint-Resistant-Stainless-Steel-WRF555SDFZ/301711642"
        }
    ],
    "maxItems": 1,
    "zipCode": "30303",
    "storeId": "121"
};

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

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

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

```

## Python example

```python
from apify_client import ApifyClient

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

# Prepare the Actor input
run_input = {
    "keywords": [],
    "productUrls": [{ "url": "https://www.homedepot.com/p/Whirlpool-25-cu-ft-French-Door-Refrigerator-in-Fingerprint-Resistant-Stainless-Steel-WRF555SDFZ/301711642" }],
    "maxItems": 1,
    "zipCode": "30303",
    "storeId": "121",
}

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

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

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

```

## CLI example

```bash
echo '{
  "keywords": [],
  "productUrls": [
    {
      "url": "https://www.homedepot.com/p/Whirlpool-25-cu-ft-French-Door-Refrigerator-in-Fingerprint-Resistant-Stainless-Steel-WRF555SDFZ/301711642"
    }
  ],
  "maxItems": 1,
  "zipCode": "30303",
  "storeId": "121"
}' |
apify call automation-lab/home-depot-product-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Home Depot Product Scraper",
        "description": "Extract Home Depot products, prices, ratings, specifications, images, promotions, and ZIP/store-localized fulfillment from keywords and URLs.",
        "version": "0.1",
        "x-build-id": "iCXpFnu08gCrzEVoP"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~home-depot-product-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-home-depot-product-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/automation-lab~home-depot-product-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-home-depot-product-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/automation-lab~home-depot-product-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-home-depot-product-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "keywords": {
                        "title": "🔎 Search keywords",
                        "type": "array",
                        "description": "Home Depot search terms such as cordless drill, refrigerator, or patio furniture.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "productUrls": {
                        "title": "🔗 Product or search URLs",
                        "type": "array",
                        "description": "Public homedepot.com product detail or search result URLs.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxItems": {
                        "title": "Maximum products",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Stop after this many unique products across all inputs.",
                        "default": 20
                    },
                    "zipCode": {
                        "title": "Delivery ZIP code",
                        "type": "string",
                        "description": "US ZIP code used for localized fulfillment data.",
                        "default": "30303"
                    },
                    "storeId": {
                        "title": "Home Depot store ID",
                        "type": "string",
                        "description": "Numeric Home Depot store ID used for local price, pickup, and inventory context.",
                        "default": "121"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```