# HomeAdvisor Cost Guide Scraper (`lulzasaur/homeadvisor-scraper`) Actor

Scrape HomeAdvisor/Angi cost guides for 200+ home improvement services. Extract cost ranges, national averages, cost factors, and descriptions for plumbing, electrical, roofing, and more.

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

## Pricing

from $5.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.

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

## HomeAdvisor Cost Guide Scraper

Scrape HomeAdvisor/Angi True Cost Guides for 200+ home improvement services. Extract national average costs, price ranges, cost factors, and descriptions across all major categories.

### Features

- Scrape cost data from 200+ service categories (plumbing, electrical, roofing, bathrooms, etc.)
- Extract average cost, typical range, and extreme range for each service
- Identify cost factors that affect pricing (labor, materials, location, etc.)
- Filter by specific category or scrape all categories at once
- JSON-LD structured data extraction for maximum accuracy
- FAQ extraction from cost guide pages
- No browser needed — fast and lightweight

### Input

| Field | Type | Default | Description |
|-------|------|---------|-------------|
| `category` | string | `""` | Filter by category slug (e.g., `plumbing`, `electrical`). Empty = all categories |
| `maxResults` | integer | `200` | Maximum cost guides to scrape (1-2000) |
| `proxyConfiguration` | object | `{}` | Proxy settings for large-scale runs |

#### Example Input

```json
{
    "category": "plumbing",
    "maxResults": 50
}
````

#### Available Categories

**Home Spaces:** attics, basements, bathrooms, bedrooms, decks-and-porches, garages, home-offices, home-theaters, kitchens, laundry-rooms, living-rooms, outbuildings, patios-and-walkways, roofing, sunrooms, lawn-and-garden

**Home Features:** appliances, cabinets, countertops, doors-and-windows, electrical, fencing, flooring, foundations, gutters, heating-and-cooling, insulation, landscape, painting, plumbing, siding, stairs-and-railings, swimming-pools-hot-tubs-and-saunas, walls-and-ceilings

**Home Professionals:** architects-and-engineers, designers-and-decorators

**Home Solutions:** additions-and-remodels, cleaning-services, disability-accommodation, disaster-recovery, energy-efficiency, environmental-safety, safety-and-security, storage-and-organization

### Output

Each result contains:

| Field | Type | Description |
|-------|------|-------------|
| `serviceName` | string | Name of the home improvement service |
| `category` | string | Category name (e.g., "Plumbing") |
| `categorySlug` | string | URL-friendly category slug |
| `averageCost` | number | National average cost in USD |
| `lowCost` | number | Low end of the full cost range |
| `highCost` | number | High end of the full cost range |
| `typicalRangeLow` | number | Low end of the typical/normal range |
| `typicalRangeHigh` | number | High end of the typical/normal range |
| `costFactors` | string\[] | Factors that affect the cost |
| `description` | string | Service description from meta or page content |
| `faqs` | object\[] | FAQ questions and answers if available |
| `url` | string | Source URL of the cost guide |
| `scrapedAt` | string | ISO timestamp of when the data was scraped |

#### Example Output

```json
{
    "serviceName": "Water Heater Replacement",
    "category": "Plumbing",
    "categorySlug": "plumbing",
    "averageCost": 1337,
    "lowCost": 350,
    "highCost": 12000,
    "typicalRangeLow": 882,
    "typicalRangeHigh": 1815,
    "costFactors": ["Type", "Size", "Fuel Type", "Energy Efficiency", "Brand", "Location"],
    "description": "Professional water heater replacement cost service including materials and labor.",
    "faqs": [
        {
            "question": "How much does it cost to replace a 40-gallon water heater?",
            "answer": "Replacing a 40-gallon water heater costs $800 to $1,600 on average..."
        }
    ],
    "url": "https://www.homeadvisor.com/cost/plumbing/install-a-water-heater/",
    "scrapedAt": "2026-04-25T10:30:00.000Z"
}
```

### Use Cases

- **Home Improvement Budgeting**: Get accurate cost estimates before starting a project
- **Contractor Pricing Analysis**: Compare your rates against national averages
- **Real Estate Investment**: Estimate renovation costs for property flips
- **Insurance Adjusting**: Reference typical repair costs for claims
- **Market Research**: Analyze home improvement pricing trends across categories
- **Content Creation**: Source accurate cost data for home improvement articles

### How It Works

1. Discovers all cost guide URLs by crawling HomeAdvisor category pages
2. Fetches each individual cost guide page using lightweight HTTP requests
3. Extracts structured cost data from JSON-LD Schema.org markup
4. Parses additional cost ranges, factors, and descriptions from page content
5. Outputs clean, normalized results to the Apify dataset

### Tips

- Start with a single category to test (e.g., `"category": "plumbing"`)
- Use `maxResults: 5` for quick testing runs
- Enable proxy for large-scale runs (200+ guides)
- The scraper automatically deduplicates guide URLs across categories

***

### Run on Apify

This scraper runs on the [Apify platform](https://apify.com/?fpr=lulzasaur) — a full-stack web scraping and automation cloud. Sign up for a free account to get started with 30-day trial of all features.

[Try Apify free ->](https://apify.com/?fpr=lulzasaur)

### Related Scrapers

More marketplace scrapers and data tools by [lulzasaur](https://apify.com/lulzasaur):

- [Thumbtack Scraper](https://apify.com/lulzasaur/thumbtack-scraper) — Local service professionals
- [Contractor License Verifier](https://apify.com/lulzasaur/contractor-license-scraper) — Multi-state license verification
- [Houzz Scraper](https://apify.com/lulzasaur/houzz-scraper) — Home improvement professionals
- [Care.com Scraper](https://apify.com/lulzasaur/care-scraper) — Home care service providers
- [OfferUp Scraper](https://apify.com/lulzasaur/offerup-scraper) — Local marketplace listings
- [Redfin Scraper](https://apify.com/lulzasaur/redfin-scraper) — Real estate listings and prices

# Actor input Schema

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

Filter by category slug (e.g., 'plumbing', 'electrical', 'roofing', 'bathrooms'). Leave empty to scrape all categories.

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

Maximum number of cost guides to scrape. Each guide is one result.

## `proxyConfiguration` (type: `object`):

Proxy settings. Recommended for large-scale runs to avoid rate limiting.

## Actor input object example

```json
{
  "category": "",
  "maxResults": 200,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# 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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("lulzasaur/homeadvisor-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 = {}

# Run the Actor and wait for it to finish
run = client.actor("lulzasaur/homeadvisor-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 '{}' |
apify call lulzasaur/homeadvisor-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "HomeAdvisor Cost Guide Scraper",
        "description": "Scrape HomeAdvisor/Angi cost guides for 200+ home improvement services. Extract cost ranges, national averages, cost factors, and descriptions for plumbing, electrical, roofing, and more.",
        "version": "1.0",
        "x-build-id": "IYkeXdGMLuF02IMjr"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/lulzasaur~homeadvisor-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-lulzasaur-homeadvisor-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/lulzasaur~homeadvisor-scraper/runs": {
            "post": {
                "operationId": "runs-sync-lulzasaur-homeadvisor-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/lulzasaur~homeadvisor-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-lulzasaur-homeadvisor-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": {
                    "category": {
                        "title": "Category Filter",
                        "type": "string",
                        "description": "Filter by category slug (e.g., 'plumbing', 'electrical', 'roofing', 'bathrooms'). Leave empty to scrape all categories.",
                        "default": ""
                    },
                    "maxResults": {
                        "title": "Max Results",
                        "minimum": 1,
                        "maximum": 2000,
                        "type": "integer",
                        "description": "Maximum number of cost guides to scrape. Each guide is one result.",
                        "default": 200
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Proxy settings. Recommended for large-scale runs to avoid rate limiting.",
                        "default": {
                            "useApifyProxy": false
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
