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

Scrape Home Depot products by keyword, URL, or item ID. Returns prices, specs, ratings, reviews, store inventory, images, and breadcrumbs. Pay only $3.50 per 1000 results.

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

## Pricing

from $3.50 / 1,000 product results

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 Product Scraper

Scrape Home Depot product data at scale. This actor turns Home Depot search keywords, category pages, and product URLs into clean, structured JSON records you can pipe into a spreadsheet, a database, or your own analytics pipeline. It is built on top of the same Home Depot federation GraphQL gateway the website uses, so the data you get back is the data shoppers see, store-aware pricing, real-time inventory, ratings, reviews, specifications, and all.

Pricing is simple. You pay $3.50 per 1,000 items (about $0.0035 per result), with no Apify platform usage on top. That is roughly half the cost of the older Home Depot scrapers on the Apify Store, and you get a richer record per item.

### What you can do with this Home Depot scraper

- Track competitor pricing across thousands of SKUs in a category every morning.
- Build a Home Depot product API for an internal tool or a price-comparison site.
- Watch a single SKU for stock changes at a particular store (BOPIS, BOSS, same-day).
- Pull review text and ratings for sentiment analysis on a tool category.
- Export product specifications into a procurement catalog.
- Generate seed data for an e-commerce demo or a machine learning project.

### Inputs

The actor accepts any combination of:

- **keywords** - search terms like `drill` or `french door refrigerator`. Each keyword paginates up to your `maxItemsPerKeyword` setting (Home Depot caps any single keyword at about 576 results, so 240 is a sensible default).
- **urls** - paste any mix of Home Depot product pages (`/p/.../<itemId>`), search pages (`/s/...`), or category pages (`/b/.../N-<navParam>`). The actor classifies each URL and runs the right operation.
- **productIds** - if you already have a list of 9-digit Home Depot item IDs, drop them in directly. This is the fastest input shape.
- **storeId** + **zipCode** - drive store-aware pricing and delivery dates. Default is store `0121` (Atlanta-Cumberland) with ZIP `30033`. Change these to match the market you are tracking.
- **enrichPDP** (default on) - fetches the full product detail page for every result, so you get UPC, full specs, complete image gallery, fulfillment, and more.
- **enrichReviews** (off by default) - pulls the latest reviews for every product with photo URLs and verified-purchaser flags.

### What the output looks like

Each dataset record is a flat object with the most important fields lifted to the top level:

- Identifiers: `itemId`, `title`, `brand`, `modelNumber`, `upc`, `storeSkuNumber`
- Pricing: `price`, `originalPrice`, `dollarOff`, `percentageOff`, `promotionDescription`, `unitOfMeasure`
- Ratings and reviews: `ratingValue`, `reviewCount`
- Media: `imageUrl` plus a full `allImages` array, plus `videos` and an optional 360 viewer URL
- Taxonomy: `breadcrumbs`, `productDepartment`, `productSubType`
- Inventory: `fulfillmentOptions`, `storeInventory`, `backordered`, `anchorStoreStatus`
- SEO: `seoTitle`, `seoMetaDescription`, canonical URL

Reviews are written as separate records with `source: "review"` and the same `itemId` so you can join them back to the product.

### How it works under the hood

The actor uses the Home Depot federation GraphQL gateway (`/federation-gateway/graphql`) with the same `searchModel`, `productClientOnlyProduct`, `fulfillment`, and `reviews` operations the website calls. Home Depot is protected by Akamai Bot Manager, so a stealth headless Chromium warms a fresh cookie session against the homepage on a US residential Apify proxy before any GraphQL request goes out. Cookies refresh automatically on any Akamai block signal.

### Best practices

- Always run from US residential proxies. Datacenter IPs are blocked at the perimeter.
- Start with `maxItems: 50` for your first run to size the cost before kicking off a large crawl.
- For category sweeps, supply the category URL rather than a keyword: it is more deterministic and easier to resume.
- If you only need price and stock for known SKUs, pass `productIds` and leave `keywords` empty. This is the cheapest input mode per result.

### Legal

This actor only collects publicly available product data from Home Depot search and product pages. No account login is required, no user-credential cookies are used. Use the output in accordance with Home Depot's terms of service. You are responsible for how you store, process, and resell the data.

# Actor input Schema

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

List of search terms to run against Home Depot search (e.g. "drill", "french door refrigerator"). Each keyword paginates up to maxItemsPerKeyword.
## `urls` (type: `array`):

Direct Home Depot URLs: PDP (/p/.../<itemId>), search (/s/...), or category (/b/.../N-<navParam>). The scraper classifies each URL and routes to the right operation.
## `productIds` (type: `array`):

Bare 9-digit Home Depot item IDs. Faster than full URLs when you already have IDs.
## `storeId` (type: `string`):

4-digit Home Depot store id used for pricing and inventory. Default 0121 is Atlanta-Cumberland. Use the localStore lookup or homedepot.com/l/<store-slug>/<storeId> page to find others.
## `zipCode` (type: `string`):

ZIP used for delivery date and Express Delivery eligibility. Pair with storeId for store-aware pricing.
## `maxItems` (type: `integer`):

Hard cap across all keywords / URLs. 0 = unlimited.
## `maxItemsPerKeyword` (type: `integer`):

Home Depot caps search depth at 576 (24 pages of 24). Lower this to control cost.
## `enrichPDP` (type: `boolean`):

When true (default), the scraper fetches productClientOnlyProduct for every itemId returned by search, giving you UPC, specs, dimensions, full image gallery, and richer fulfillment. Disable for a leaner search-only dataset.
## `enrichReviews` (type: `boolean`):

When true, fetches the most recent reviews (with photos) per product and writes them as separate dataset items (source=review).
## `reviewsPerProduct` (type: `integer`):

Max reviews to scrape per product when enrichReviews is on (max 30 per page).
## `sortBy` (type: `string`):

How to order search results.
## `proxyConfiguration` (type: `object`):

Residential US proxy required. Datacenter IPs are blocked by Akamai.

## Actor input object example

```json
{
  "keywords": [
    "drill"
  ],
  "urls": [],
  "productIds": [],
  "storeId": "0121",
  "zipCode": "30033",
  "maxItems": 0,
  "maxItemsPerKeyword": 240,
  "enrichPDP": true,
  "enrichReviews": false,
  "reviewsPerProduct": 10,
  "sortBy": "BEST_MATCH",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  }
}
````

# Actor output Schema

## `items` (type: `string`):

All product and review records extracted in the latest run.

## `itemsCsv` (type: `string`):

All items in CSV format.

## `itemsJson` (type: `string`):

All items in JSON format.

## `consoleRun` (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": [
        "drill"
    ],
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "apifyProxyCountry": "US"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("cirkit/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": ["drill"],
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "US",
    },
}

# Run the Actor and wait for it to finish
run = client.actor("cirkit/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": [
    "drill"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  }
}' |
apify call cirkit/home-depot-product-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Home Depot Product Scraper",
        "description": "Scrape Home Depot products by keyword, URL, or item ID. Returns prices, specs, ratings, reviews, store inventory, images, and breadcrumbs. Pay only $3.50 per 1000 results.",
        "version": "0.1",
        "x-build-id": "bC1FYTw9s7pzDPcNb"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/cirkit~home-depot-product-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-cirkit-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/cirkit~home-depot-product-scraper/runs": {
            "post": {
                "operationId": "runs-sync-cirkit-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/cirkit~home-depot-product-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-cirkit-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": "List of search terms to run against Home Depot search (e.g. \"drill\", \"french door refrigerator\"). Each keyword paginates up to maxItemsPerKeyword.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "urls": {
                        "title": "Product, search, or category URLs",
                        "type": "array",
                        "description": "Direct Home Depot URLs: PDP (/p/.../<itemId>), search (/s/...), or category (/b/.../N-<navParam>). The scraper classifies each URL and routes to the right operation.",
                        "default": [],
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "productIds": {
                        "title": "Product (item) IDs",
                        "type": "array",
                        "description": "Bare 9-digit Home Depot item IDs. Faster than full URLs when you already have IDs.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "storeId": {
                        "title": "Home Depot Store ID",
                        "type": "string",
                        "description": "4-digit Home Depot store id used for pricing and inventory. Default 0121 is Atlanta-Cumberland. Use the localStore lookup or homedepot.com/l/<store-slug>/<storeId> page to find others.",
                        "default": "0121"
                    },
                    "zipCode": {
                        "title": "Delivery ZIP code",
                        "type": "string",
                        "description": "ZIP used for delivery date and Express Delivery eligibility. Pair with storeId for store-aware pricing.",
                        "default": "30033"
                    },
                    "maxItems": {
                        "title": "Max total items",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Hard cap across all keywords / URLs. 0 = unlimited.",
                        "default": 0
                    },
                    "maxItemsPerKeyword": {
                        "title": "Max items per keyword/category",
                        "minimum": 24,
                        "maximum": 576,
                        "type": "integer",
                        "description": "Home Depot caps search depth at 576 (24 pages of 24). Lower this to control cost.",
                        "default": 240
                    },
                    "enrichPDP": {
                        "title": "Enrich each result with the full product detail page (PDP)",
                        "type": "boolean",
                        "description": "When true (default), the scraper fetches productClientOnlyProduct for every itemId returned by search, giving you UPC, specs, dimensions, full image gallery, and richer fulfillment. Disable for a leaner search-only dataset.",
                        "default": true
                    },
                    "enrichReviews": {
                        "title": "Include reviews",
                        "type": "boolean",
                        "description": "When true, fetches the most recent reviews (with photos) per product and writes them as separate dataset items (source=review).",
                        "default": false
                    },
                    "reviewsPerProduct": {
                        "title": "Reviews per product",
                        "minimum": 1,
                        "maximum": 30,
                        "type": "integer",
                        "description": "Max reviews to scrape per product when enrichReviews is on (max 30 per page).",
                        "default": 10
                    },
                    "sortBy": {
                        "title": "Search sort order",
                        "enum": [
                            "BEST_MATCH",
                            "TOP_SELLERS",
                            "PRICE",
                            "TOP_RATED",
                            "NEWEST"
                        ],
                        "type": "string",
                        "description": "How to order search results.",
                        "default": "BEST_MATCH"
                    },
                    "proxyConfiguration": {
                        "title": "Proxy",
                        "type": "object",
                        "description": "Residential US proxy required. Datacenter IPs are blocked by Akamai.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ],
                            "apifyProxyCountry": "US"
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
