# Ace Hardware Scraper (`parseforge/ace-hardware-scraper`) Actor

Scrape product listings from AceHardware.com. Extract prices, brands, specifications, inventory status, store availability, and fulfillment options. Filter by category or brand. Fast parallel page fetching with 100 items per page. Export as CSV or JSON.

- **URL**: https://apify.com/parseforge/ace-hardware-scraper.md
- **Developed by:** [ParseForge](https://apify.com/parseforge) (community)
- **Categories:** E-commerce, Automation, Developer tools
- **Stats:** 2 total users, 2 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $4.00 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

![ParseForge Banner](https://github.com/ParseForge/apify-assets/blob/ad35ccc13ddd068b9d6cba33f323962e39aed5b2/banner.jpg?raw=true)

## 🏠 Ace Hardware Scraper

Collect product data from Ace Hardware category pages without any code. Extract prices, specifications, inventory status, and store availability directly from acehardware.com. Whether you're comparing products across competitors, tracking inventory levels, or downloading hardware data as CSV, this tool works at scale.

> The Ace Hardware Scraper collects up to 30+ product data fields per item, with automatic handling of pagination and filters.

### ✨ What Does It Do

- 🖼️ **Product Images** - Collect main images and full image galleries for product catalogs and comparison tools
- 💰 **Price Data** - Track current prices, MSRP, and sale status
- 📊 **Inventory Status** - Check stock availability and whether products are purchasable
- 🏪 **Fulfillment Options** - Discover in-store pickup, delivery, and other fulfillment capabilities
- 📦 **Specifications** - Get detailed product specifications, dimensions, weight, and technical attributes
- 🔗 **Product Links** - Collect direct URLs and product codes to integrate with your systems

### 🔧 Input

- **Start URL** - The URL of an Ace Hardware category page to scrape (e.g., https://www.acehardware.com/departments/hardware/nuts-and-bolts/carriage-bolts). If provided, overrides the Category Path field.
- **Max Items** - How many products to collect. Free users are limited to 10 items, paid users can request up to 1,000,000 items.
- **Include Product Details** - Fetch full product information from individual detail pages for complete specifications and descriptions. Takes longer but returns more comprehensive data.
- **Category Path** - The category path on Ace Hardware (e.g., hardware/nuts-and-bolts/carriage-bolts). Used only if Start URL is not provided.
- **Brand Filter** - Filter results to a specific brand name, like Hillman or Stanley.
- **Max Concurrency** - Number of parallel requests to make. Lower this if you hit rate limits.
- **Request Delay** - Milliseconds to pause between requests. Ace Hardware's robots.txt recommends at least 5 seconds between requests.

Example input:
```json
{
  "startUrl": "https://www.acehardware.com/departments/hardware/nuts-and-bolts/carriage-bolts",
  "maxItems": 50,
  "includeDetails": false,
  "brand": "Hillman",
  "maxConcurrency": 3,
  "requestDelayMs": 1000
}
````

### 📊 Output

Each product includes up to 30+ data fields. Download as JSON, CSV, or Excel.

| 🖼️ Image URL | 📝 Product Code (SKU) | 🏷️ Product Name |
|---|---|---|
| 💰 Current Price | 💵 MSRP | 📉 Catalog List Price |
| 🎯 On Sale | 📊 Has Price Range | 👤 Brand |
| 🔢 UPC | 🏭 Mfg Part Number | 📋 Description |
| 📝 Short Description | 🏪 Category | 🔗 All Categories |
| 📦 Product Type | ✅ In Stock | 🛒 Purchasable |
| 🏪 In-Store Pickup Available | 🚚 Delivery Available | 📊 Fulfillment Types |
| 📏 Package Height | 📐 Package Width | 📏 Package Length |
| ⚖️ Package Weight | 🔧 Specifications | 🖼️ All Product Images |
| 📅 Scraped At | ⚠️ Error Messages | |

### 💎 Why Choose the Ace Hardware Scraper?

| Feature | Our Actor |
|---|---|
| No-code collection from category pages | ✔️ |
| Extracts 30+ product fields per item | ✔️ |
| Sale status and price change tracking | ✔️ |
| Inventory and stock status | ✔️ |
| In-store pickup and delivery info | ✔️ |
| Product specifications and dimensions | ✔️ |
| Multiple images per product | ✔️ |
| Brand filtering built-in | ✔️ |
| Handles pagination automatically | ✔️ |
| Free tier up to 100 results, paid tier up to 1M | ✔️ |
| Respects robots.txt with built-in delays | ✔️ |
| Export to JSON, CSV, Excel | ✔️ |

### 📋 How to Use

No technical skills required. Follow these steps:

1. **Sign Up**: [Create a free account with $5 credit](https://console.apify.com/sign-up?fpr=vmoqkp)
2. **Find the Tool**: Search for "Ace Hardware Scraper" in the Apify Store and configure your input
3. **Run It**: Click "Start" and watch your results appear

That's it. Export your data in CSV, Excel, or JSON format.

### 🎯 Business Use Cases

- 📊 **Retail Price Analyst** - monitor competitor prices across categories to adjust markups before seasonal sales
- 💼 **Inventory Manager** - track stock availability to identify fast-moving products and plan reorders
- 📣 **Marketing Team** - collect product names, images, and descriptions to bulk-import into campaigns

### ❓ FAQ

**🔍 How does it work?**
The scraper requests Ace Hardware category pages and extracts product JSON data that's already embedded in the HTML. No browser automation is needed, making it fast and reliable.

**📊 How accurate is the data?**
Data comes directly from Ace Hardware's product feeds. Prices, availability, and specifications are current as of when the scraper runs. We recommend re-running regularly to keep data fresh.

**📅 Can I schedule this to run automatically?**
Yes. You can set up scheduled runs in Apify or integrate with tools like Zapier and Make to trigger scrapes on a schedule.

**⚖️ Is it legal to scrape Ace Hardware?**
The scraper collects publicly available product data from category pages. You are responsible for ensuring your use complies with Ace Hardware's Terms of Service and local laws. Always respect robots.txt and rate limits.

**🛡️ Will Ace Hardware block me?**
Ace Hardware's robots.txt permits responsible scraping with delays. The actor respects these guidelines. If you still encounter blocks, consider using residential proxies for large-scale runs.

**⚡ How long does a run take?**
A typical run collecting 50 products takes 1 to 2 minutes depending on your concurrency and delay settings. Larger runs scale with the number of items, usually at 1 to 2 seconds per product with default settings.

**⚠️ Are there any limits?**
Free users can collect up to 100 results per run. Paid users can collect up to 1,000,000 results per run.

### 🔗 Integrate Ace Hardware Scraper with any app

- [Make](https://docs.apify.com/platform/integrations/make) - Automate workflows
- [Zapier](https://docs.apify.com/platform/integrations/zapier) - Connect 5000+ apps
- [GitHub](https://docs.apify.com/platform/integrations/github) - Version control integration
- [Slack](https://docs.apify.com/platform/integrations/slack) - Get notifications
- [Airbyte](https://docs.apify.com/platform/integrations/airbyte) - Data pipelines
- [Google Drive](https://docs.apify.com/platform/integrations/drive) - Export to spreadsheets

### 💡 More ParseForge Actors

- [Mac App Store Scraper](https://apify.com/parseforge/mac-app-store-scraper) - Collect app listings and reviews
- [The Restaurant Warehouse Equipment Scraper](https://apify.com/parseforge/the-restaurant-warehouse-equipment-scraper) - Extract restaurant supply data
- [ITI NYC Scraper](https://apify.com/parseforge/iti-nyc-scraper) - Scrape NYC school program listings
- [Indexmundi Scraper](https://apify.com/parseforge/indexmundi-scraper) - Extract global market and economic data
- [Gamenation Scraper](https://apify.com/parseforge/gamenation-scraper) - Collect video game information and details

Browse our complete collection of [data extraction tools](https://apify.com/parseforge) for more.

### 🚀 Ready to Start?

[Create a free account with $5 credit](https://console.apify.com/sign-up?fpr=vmoqkp) and collect your first 100 results for free. No coding, no setup.

### 🆘 Need Help?

- Check the FAQ section above for common questions
- Visit the [Apify support page](https://docs.apify.com) for documentation and tutorials
- Contact us to request a new scraper, propose a custom project, or report an issue at [Tally contact form](https://tally.so/r/BzdKgA)

### ⚠️ Disclaimer

> This Actor is an independent tool and is not affiliated with, endorsed by, or sponsored by Ace Hardware or any of its subsidiaries. All trademarks mentioned are the property of their respective owners.

# Actor input Schema

## `startUrl` (type: `string`):

URL of a category page to scrape (e.g. https://www.acehardware.com/departments/hardware/nuts-and-bolts/carriage-bolts). If provided, the category field below is ignored.

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

Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000.

## `includeDetails` (type: `boolean`):

Fetch individual product detail pages for full specifications and descriptions. Slower but more complete.

## `category` (type: `string`):

Category URL path to scrape (e.g. 'hardware/nuts-and-bolts/carriage-bolts'). Used when Start URL is not provided.

## `brand` (type: `string`):

Filter products by brand name (e.g. 'Hillman'). Optional.

## `maxConcurrency` (type: `integer`):

Maximum number of parallel requests. Lower this if you get rate-limited.

## `requestDelayMs` (type: `integer`):

Milliseconds to wait between requests. Ace Hardware robots.txt recommends 5s delay.

## Actor input object example

```json
{
  "startUrl": "https://www.acehardware.com/departments/hardware/nuts-and-bolts/carriage-bolts",
  "maxItems": 10,
  "includeDetails": false,
  "maxConcurrency": 3,
  "requestDelayMs": 1000
}
```

# Actor output Schema

## `results` (type: `string`):

Dataset with all scraped items

# 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 = {
    "startUrl": "https://www.acehardware.com/departments/hardware/nuts-and-bolts/carriage-bolts",
    "maxItems": 10,
    "includeDetails": false
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/ace-hardware-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 = {
    "startUrl": "https://www.acehardware.com/departments/hardware/nuts-and-bolts/carriage-bolts",
    "maxItems": 10,
    "includeDetails": False,
}

# Run the Actor and wait for it to finish
run = client.actor("parseforge/ace-hardware-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 '{
  "startUrl": "https://www.acehardware.com/departments/hardware/nuts-and-bolts/carriage-bolts",
  "maxItems": 10,
  "includeDetails": false
}' |
apify call parseforge/ace-hardware-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Ace Hardware Scraper",
        "description": "Scrape product listings from AceHardware.com. Extract prices, brands, specifications, inventory status, store availability, and fulfillment options. Filter by category or brand. Fast parallel page fetching with 100 items per page. Export as CSV or JSON.",
        "version": "1.0",
        "x-build-id": "z8QwlI2KBxl0yHUBK"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~ace-hardware-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-ace-hardware-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/parseforge~ace-hardware-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-ace-hardware-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/parseforge~ace-hardware-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-ace-hardware-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": {
                    "startUrl": {
                        "title": "Start URL",
                        "type": "string",
                        "description": "URL of a category page to scrape (e.g. https://www.acehardware.com/departments/hardware/nuts-and-bolts/carriage-bolts). If provided, the category field below is ignored."
                    },
                    "maxItems": {
                        "title": "Max Items",
                        "minimum": 1,
                        "maximum": 1000000,
                        "type": "integer",
                        "description": "Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000."
                    },
                    "includeDetails": {
                        "title": "Include Product Details",
                        "type": "boolean",
                        "description": "Fetch individual product detail pages for full specifications and descriptions. Slower but more complete.",
                        "default": false
                    },
                    "category": {
                        "title": "Category Path",
                        "type": "string",
                        "description": "Category URL path to scrape (e.g. 'hardware/nuts-and-bolts/carriage-bolts'). Used when Start URL is not provided."
                    },
                    "brand": {
                        "title": "Brand Filter",
                        "type": "string",
                        "description": "Filter products by brand name (e.g. 'Hillman'). Optional."
                    },
                    "maxConcurrency": {
                        "title": "Max Concurrency",
                        "minimum": 1,
                        "maximum": 10,
                        "type": "integer",
                        "description": "Maximum number of parallel requests. Lower this if you get rate-limited.",
                        "default": 3
                    },
                    "requestDelayMs": {
                        "title": "Request Delay (ms)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Milliseconds to wait between requests. Ace Hardware robots.txt recommends 5s delay.",
                        "default": 1000
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
