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

Export individual Home Depot reviews with ratings, full text, reviewers, trust signals, helpful votes, media, merchant responses, and product summaries. Run by URL or Internet item ID; export JSON, CSV, or Excel.

- **URL**: https://apify.com/automation-lab/home-depot-product-reviews-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** E-commerce
- **Stats:** 3 total users, 2 monthly users, 90.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 web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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

Export individual public **Home Depot product reviews** into structured JSON, CSV, Excel, XML, or RSS records.

Home Depot Product Reviews Scraper accepts product pages, paginated review pages, and Internet item IDs.
It returns review text, ratings, dates, reviewer details, verification and promotion signals, helpful votes, media, merchant responses, and product rating summaries.

No Home Depot login or private API key is required.
Start with one product and 10 reviews, inspect the dataset, then scale the same input through the Apify Console, API, schedules, webhooks, or MCP.

### What does Home Depot Product Reviews Scraper do?

This Actor turns public US [Home Depot](https://www.homedepot.com/) customer feedback into one clean row per review.

It can:

- ⭐ accept product URLs, review URLs, or Internet item IDs;
- 📝 extract full review titles and bodies;
- 📊 include review and product-level ratings;
- ✅ identify verified-purchase and recommendation signals when Home Depot provides them;
- 🎁 expose incentive or promotional-review badges;
- 🔗 retain syndication source and source-page provenance;
- 👍 collect positive and negative helpful-vote counts;
- 📷 return review photo and video URLs;
- 📅 filter out reviews older than an inclusive date;
- 🔁 paginate with duplicate removal and bounded retries.

Unlike a product-catalog scraper, this Actor emits **individual customer-review records**, not one product row with only an aggregate review count.

### Who is it for? Home Depot review data users

**Brands and manufacturers**

- Track recurring feedback about defects, installation, packaging, fit, or durability.
- Compare sentiment across product models and releases.
- Route new negative reviews into product-quality workflows.

**Retail and ecommerce analysts**

- Benchmark ratings, recommendation rates, and review volume.
- Build competitor-review datasets for category analysis.
- Join Home Depot feedback with catalog, price, and inventory data.

**Customer experience and reputation teams**

- Monitor new reviews on scheduled runs.
- Prioritize verified or highly helpful reviews.
- Detect responses, syndicated content, and incentive disclosures.

**Data engineers and AI teams**

- Feed typed review text into sentiment, topic, summarization, or RAG pipelines.
- Export through the API without maintaining browser infrastructure.
- Trigger downstream jobs through webhooks, Make, Zapier, or custom code.

### Why use this Home Depot review extractor?

- **Review-level output** — every dataset row represents one customer review.
- **Flexible targeting** — paste familiar product URLs or compact Internet item IDs.
- **Export-ready fields** — booleans and numbers are normalized instead of buried in a nested page payload.
- **Product context included** — model, SKU, brand, title, and aggregate metrics travel with each review.
- **Bounded runs** — control both the global review limit and pages requested per product.
- **Reliable deduplication** — repeated review IDs are saved once across pages and inputs.
- **No account credentials** — only anonymous public Home Depot US pages are accessed.
- **Apify-native automation** — datasets, schedules, API access, webhooks, monitoring, and integrations are built in.

### What Home Depot review data can you extract?

| Category | Fields |
|---|---|
| Review identity | `reviewId`, `productId`, `page`, `sourceUrl` |
| Product | `productTitle`, `brand`, `modelNumber`, `storeSku`, `productUrl` |
| Aggregate summary | `averageRating`, `totalReviews`, `recommendationPercent`, star counts |
| Review content | `rating`, `reviewDate`, `reviewTitle`, `reviewText` |
| Reviewer | `reviewerNickname`, `reviewerLocation` |
| Trust signals | `recommended`, `verifiedPurchase`, `incentivized`, `syndicated` |
| Engagement | `positiveHelpfulVotes`, `negativeHelpfulVotes` |
| Media | `photoUrls`, `videoUrls` |
| Secondary scores | quality, value, ease of use, installation, appearance, efficiency, features |
| Merchant activity | `merchantResponse`, `merchantResponseDate` |
| Provenance | `requestedUrl`, `scrapedAt` |

Optional fields are omitted when Home Depot does not provide them for a particular review.
The required review text, rating, date, product ID, page, and provenance remain consistent.

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

This Actor uses **pay-per-event pricing**.
You pay a small run-start fee plus a fee for each review saved to the dataset.
All browser, residential proxy, storage, and platform infrastructure is included.

| Event | Free | Starter | Scale | Business |
|---|---:|---:|---:|---:|
| Run started | $0.04 | $0.04 | $0.04 | $0.04 |
| Review extracted | $0.0078254 | $0.0068047 | $0.0053077 | $0.0040828 |

Higher Apify plans receive additional volume discounts.
For example, 100 reviews on the Free tier currently cost about **$0.75**, including the start event.
The Free plan's included platform credits are enough for useful evaluation runs.

Prices are shown before any user-configured maximum-total-charge guard.
The Actor stops at your `maxReviews` limit, so the primary output charge is predictable.

### How to scrape Home Depot product reviews

1. Open Home Depot Product Reviews Scraper on Apify.
2. Paste one or more public Home Depot product or review URLs.
3. Alternatively, add Internet item IDs such as `301711642`.
4. Set **Maximum reviews** to the number of unique records you need.
5. Keep **Maximum pages per product** at `1` for a cheap first run.
6. Optionally enter an earliest date using `YYYY-MM-DD`.
7. Click **Start**.
8. Preview the dataset and export JSON, CSV, Excel, XML, or RSS.
9. Save the configuration as a task when you want scheduled monitoring.

A minimal input is:

```json
{
  "productIds": ["301711642"],
  "maxReviews": 10,
  "maxPagesPerProduct": 1
}
````

A product URL works too:

```json
{
  "startUrls": [
    { "url": "https://www.homedepot.com/p/Whirlpool-25-cu-ft-French-Door-Refrigerator-in-Fingerprint-Resistant-Stainless-Steel-WRF555SDFZ/301711642" }
  ],
  "maxReviews": 30,
  "maxPagesPerProduct": 2
}
```

### Input parameters

| Parameter | Type | Default | Description |
|---|---|---:|---|
| `startUrls` | array | sample review URL | Home Depot US product or paginated review URLs |
| `productIds` | string array | none | Internet item IDs, usually 8-10 digits |
| `maxReviews` | integer | `10` | Global maximum unique reviews saved |
| `maxPagesPerProduct` | integer | `1` | Maximum review pages requested per product |
| `minDate` | string | none | Inclusive earliest review date in `YYYY-MM-DD` format |

You can combine URLs and item IDs.
When the same Internet item ID occurs more than once, the Actor processes it once.

Only `https://www.homedepot.com` product and product-review paths are accepted.
Other hosts and unrelated Home Depot paths fail closed for safety.

### Output example

```json
{
  "reviewId": "123456789",
  "productId": "301711642",
  "productUrl": "https://www.homedepot.com/p/Whirlpool-25-cu-ft-French-Door-Refrigerator-in-Fingerprint-Resistant-Stainless-Steel-WRF555SDFZ/301711642",
  "productTitle": "25 cu. ft. French Door Refrigerator in Fingerprint-Resistant Stainless Steel",
  "brand": "Whirlpool",
  "modelNumber": "WRF555SDFZ",
  "storeSku": "1002451638",
  "averageRating": 4.4,
  "totalReviews": 8105,
  "recommendationPercent": 87,
  "rating": 5,
  "reviewDate": "2025-04-18T00:00:00.000Z",
  "reviewTitle": "Great refrigerator",
  "reviewText": "The storage layout works well for our family.",
  "reviewerNickname": "HomeOwner",
  "recommended": true,
  "verifiedPurchase": true,
  "incentivized": false,
  "positiveHelpfulVotes": 7,
  "sourceUrl": "https://www.homedepot.com/p/reviews/-/301711642/1",
  "page": 1,
  "scrapedAt": "2026-07-16T00:00:00.000Z"
}
```

The example illustrates field shape rather than a guaranteed current review.
Live records reflect what Home Depot publicly returns when the run executes.

### Filter reviews by date

Set `minDate` when downstream analysis only needs recent records:

```json
{
  "productIds": ["301711642", "312613758"],
  "maxReviews": 100,
  "maxPagesPerProduct": 4,
  "minDate": "2025-01-01"
}
```

The Actor keeps reviews dated on or after the supplied day.
Home Depot's default ordering can mix dates, so the Actor evaluates each extracted row instead of assuming that one old review means all later pages are old.

A date filter can legitimately produce no rows for a product.
If no supplied product yields any matching review, the run fails clearly rather than silently reporting success with an empty dataset.

### Tips for reliable review exports

- Start with one product, 10 reviews, and one page.
- Increase `maxPagesPerProduct` only when you need deeper history.
- Prefer canonical Home Depot US product URLs copied from the browser address bar.
- Use Internet item IDs for compact recurring task inputs.
- Schedule monitoring tasks at a conservative cadence; reviews change less often than prices.
- Keep `maxReviews` aligned with the volume your downstream system can process.
- Inspect run logs when a product has been removed, redirected, or has no public reviews.
- Use `minDate` for rolling sentiment datasets, not as a replacement for pagination limits.

### Automate Home Depot review monitoring

Save a tested input as an Apify task, then add a daily or weekly schedule.
Each run creates a new dataset that can feed a warehouse, sheet, alert, or model.

Useful monitoring patterns include:

- new low-star reviews for owned products;
- changes in average rating or recommendation percentage;
- verified-purchase feedback mentioning defects;
- merchant responses that need follow-up;
- newly syndicated or incentivized review content;
- helpful-vote growth on recurring complaints.

For incremental pipelines, use `minDate` and deduplicate on `reviewId` in your destination.

### Home Depot review integrations

**Home Depot reviews → Google Sheets**

Export scheduled datasets to a sheet for product managers to tag themes and owners.

**Home Depot reviews → Slack or Discord**

Use a webhook or Make scenario to alert when a new review has one or two stars.

**Home Depot reviews → BigQuery or Snowflake**

Join review text and rating summaries with product catalog, pricing, or returns data.

**Home Depot reviews → sentiment model**

Send `reviewText`, `rating`, and product identifiers into an NLP classification pipeline.

**Home Depot reviews → Zapier or Make**

Create tickets for verified negative reviews or append selected fields to a CRM record.

### API usage with Node.js

```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-reviews-scraper').call({
  productIds: ['301711642'],
  maxReviews: 10,
  maxPagesPerProduct: 1,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

Use a task instead of a direct Actor call when you want a stable saved configuration.

### Use the Apify API with Python

```python
import os
from apify_client import ApifyClient

client = ApifyClient(os.environ["APIFY_TOKEN"])
run = client.actor("automation-lab/home-depot-product-reviews-scraper").call(
    run_input={
        "productIds": ["301711642"],
        "maxReviews": 10,
        "maxPagesPerProduct": 1,
    }
)
items = client.dataset(run["defaultDatasetId"]).list_items().items
print(items)
```

The returned dataset can be loaded directly into pandas or another analysis tool.

### Run with cURL

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~home-depot-product-reviews-scraper/runs?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "productIds": ["301711642"],
    "maxReviews": 10,
    "maxPagesPerProduct": 1
  }'
```

Poll the returned run ID or use `run-sync-get-dataset-items` for short synchronous workflows.
Do not put production API tokens in public source code.

### Use with AI agents via MCP

Home Depot Product Reviews Scraper is available to AI assistants through Apify's hosted [Model Context Protocol](https://docs.apify.com/platform/integrations/mcp).

For Claude Code:

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

For Claude Desktop, Cursor, or VS Code, add:

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

Example prompts:

- "Use automation-lab/home-depot-product-reviews-scraper to export 50 reviews for Internet item ID 301711642."
- "Collect Home Depot reviews since 2025-01-01 and summarize recurring installation complaints."
- "Compare verified review themes for these three Home Depot product URLs and return the dataset IDs."

OAuth prompts authenticate your Apify account on first use.

### Legality: is it legal to scrape Home Depot reviews?

Scraping publicly available information is generally lawful in many jurisdictions, but the rules depend on your location and use case.

Use this Actor responsibly:

- collect only public data you have a legitimate reason to process;
- avoid attempts to identify or profile private individuals;
- respect applicable privacy, copyright, database, and consumer-protection laws;
- retain only the fields and history your workflow needs;
- review Home Depot's terms and your legal obligations;
- do not use review data for harassment, discrimination, or deceptive practices.

This documentation is informational and not legal advice.
Consult qualified counsel for regulated or high-risk uses.

### Limitations

- The Actor supports public US `homedepot.com` product and review pages.
- Home Depot can change its page structure or anti-automation controls.
- Removed products, malformed IDs, or products without reviews may return no records.
- Optional review fields are absent when the reviewer or source did not provide them.
- The Actor does not log in, post reviews, vote, access orders, or read private customer data.
- `maxPagesPerProduct` is a safety bound, not a guarantee that every page exists.
- Home Depot's default review order determines which records appear first.
- Review media URLs can expire or be transformed by the source CDN.

Bounded session rotation handles transient blocks, but a fully blocked source eventually fails clearly.

### Troubleshooting

**Why did the run return no reviews?**

Check that the input is a public US Home Depot product or review URL and that the product currently has reviews.
If `minDate` is set, confirm the date is not newer than every available review.
Try the same product with a small limit and no date filter.

**Why are some fields missing?**

Home Depot does not provide every trust signal, secondary rating, media item, or location on every review.
Missing optional fields are omitted rather than filled with misleading values.

**Why did Home Depot block a page?**

The Actor retries with a fresh isolated session a bounded number of times.
Persistent target-side blocking is reported in the run log and never converted into empty successful output.

### FAQ: frequently asked questions

**How fast is the Home Depot reviews scraper?**

A one-product, one-page run normally completes in a few minutes or less.
Runtime grows with products, pages, transient retries, and the number of reviews requested.

**Can I scrape all reviews for a product?**

Set a sufficiently high `maxReviews` and `maxPagesPerProduct`.
For very large histories, start with a smaller run to validate cost and ordering, then increase the limits.

**Is this an official Home Depot API?**

No.
It is an independent extractor for anonymous public review pages and does not require a private Home Depot API key.

**Does the Actor include aggregate ratings?**

Yes.
When Home Depot returns them, each review row includes product average rating, total review count, recommendation percentage, and the star histogram.

**Can I monitor several products in one run?**

Yes.
Combine URLs and Internet item IDs; `maxReviews` applies globally across the deduplicated product list.

**Does it download review images?**

It exports public photo and video URLs.
It does not download binary media files into the dataset.

### Other ecommerce and review scrapers

Pair this Actor with other Automation Labs tools:

- [Home Depot Product Scraper](https://apify.com/automation-lab/home-depot-product-scraper) for catalog, pricing, specification, and fulfillment records.
- [Walmart Reviews Scraper](https://apify.com/automation-lab/walmart-reviews-scraper) for Walmart customer feedback.
- [Amazon Reviews Scraper](https://apify.com/automation-lab/amazon-reviews-scraper) for Amazon product review exports.
- [Lowe's Product Reviews Scraper](https://apify.com/automation-lab/lowes-product-reviews-scraper) for home-improvement competitor feedback.
- [Ace Hardware Product Reviews Scraper](https://apify.com/automation-lab/ace-hardware-product-reviews-scraper) for hardware retail review monitoring.
- [Best Buy Reviews Scraper](https://apify.com/automation-lab/best-buy-reviews-scraper) for electronics customer feedback.
- [PetSmart Product Reviews Scraper](https://apify.com/automation-lab/petsmart-product-reviews-scraper) for pet retail reviews.

Use stable IDs such as `productId` and `reviewId` when joining datasets across repeated runs.

# Actor input Schema

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

Add Home Depot product URLs such as /p/.../301711642 or review URLs such as /p/reviews/.../301711642/1.

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

Enter Home Depot Internet item IDs, for example 301711642. IDs already present in URLs are deduplicated.

## `maxReviews` (type: `integer`):

Stop after this many unique review records across all products.

## `maxPagesPerProduct` (type: `integer`):

Limit how many review pages are requested for each product. Each page normally contains multiple reviews.

## `minDate` (type: `string`):

Keep reviews on or after this date. Use YYYY-MM-DD, for example 2025-01-01. Leave empty for all dates.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.homedepot.com/p/reviews/Whirlpool-25-cu-ft-French-Door-Refrigerator-in-Fingerprint-Resistant-Stainless-Steel-WRF555SDFZ/301711642/1"
    }
  ],
  "maxReviews": 10,
  "maxPagesPerProduct": 1
}
```

# 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 = {
    "startUrls": [
        {
            "url": "https://www.homedepot.com/p/reviews/Whirlpool-25-cu-ft-French-Door-Refrigerator-in-Fingerprint-Resistant-Stainless-Steel-WRF555SDFZ/301711642/1"
        }
    ],
    "maxReviews": 10,
    "maxPagesPerProduct": 1
};

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

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

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

```

## Python example

```python
from apify_client import ApifyClient

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

# Prepare the Actor input
run_input = {
    "startUrls": [{ "url": "https://www.homedepot.com/p/reviews/Whirlpool-25-cu-ft-French-Door-Refrigerator-in-Fingerprint-Resistant-Stainless-Steel-WRF555SDFZ/301711642/1" }],
    "maxReviews": 10,
    "maxPagesPerProduct": 1,
}

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

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

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

```

## CLI example

```bash
echo '{
  "startUrls": [
    {
      "url": "https://www.homedepot.com/p/reviews/Whirlpool-25-cu-ft-French-Door-Refrigerator-in-Fingerprint-Resistant-Stainless-Steel-WRF555SDFZ/301711642/1"
    }
  ],
  "maxReviews": 10,
  "maxPagesPerProduct": 1
}' |
apify call automation-lab/home-depot-product-reviews-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-reviews-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Home Depot Product Reviews Scraper",
        "description": "Export individual Home Depot reviews with ratings, full text, reviewers, trust signals, helpful votes, media, merchant responses, and product summaries. Run by URL or Internet item ID; export JSON, CSV, or Excel.",
        "version": "0.1",
        "x-build-id": "chiROqmyx0oknURJH"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~home-depot-product-reviews-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-home-depot-product-reviews-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-reviews-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-home-depot-product-reviews-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-reviews-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-home-depot-product-reviews-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "startUrls": {
                        "title": "Product or review URLs",
                        "type": "array",
                        "description": "Add Home Depot product URLs such as /p/.../301711642 or review URLs such as /p/reviews/.../301711642/1.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "productIds": {
                        "title": "Internet item IDs",
                        "type": "array",
                        "description": "Enter Home Depot Internet item IDs, for example 301711642. IDs already present in URLs are deduplicated.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxReviews": {
                        "title": "Maximum reviews",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Stop after this many unique review records across all products.",
                        "default": 10
                    },
                    "maxPagesPerProduct": {
                        "title": "Maximum pages per product",
                        "minimum": 1,
                        "maximum": 200,
                        "type": "integer",
                        "description": "Limit how many review pages are requested for each product. Each page normally contains multiple reviews.",
                        "default": 1
                    },
                    "minDate": {
                        "title": "Earliest review date",
                        "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
                        "type": "string",
                        "description": "Keep reviews on or after this date. Use YYYY-MM-DD, for example 2025-01-01. Leave empty for all dates."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```