# Houzz Pro Scraper – Contractor & Designer Leads with Emails (`malikgen/houzz-pro-scraper`) Actor

Turn Houzz into a ready-to-use B2B lead list. Pick a category, type a city, and export contractors, architects, interior designers and remodelers with phone, address, rating, reviews, Best-of-Houzz badges and services — plus the verified email addresses no other Houzz scraper provides.

- **URL**: https://apify.com/malikgen/houzz-pro-scraper.md
- **Developed by:** [Malik Mazhar Ali](https://apify.com/malikgen) (community)
- **Categories:** Lead generation, Business, Real estate
- **Stats:** 3 total users, 2 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

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

## 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

## Houzz Pro Scraper — Contractor, Designer & Architect Leads (with Emails) 🏠

Turn the [Houzz](https://www.houzz.com) professional directory into a clean, structured **B2B lead list**: general contractors, architects, interior designers, kitchen & bath remodelers, home builders, landscape architects and more — with **names, phones, addresses, ratings, reviews, “Best of Houzz” badges, services, social links, and email addresses**.

> **What makes this scraper different:** Houzz hides email addresses behind its internal messenger, so other Houzz scrapers can’t give you emails. This Actor **visits each pro’s own website and extracts verified contact emails** — the single most valuable field for outreach. No other Houzz scraper on the market does this.

### Highlights

- 📧 **Verified emails — the only Houzz scraper that has them.** We crawl each pro’s own website (Houzz hides emails behind its messenger).
- 🏙️ **Search by plain city** — just type “Austin, TX”. No cryptic Houzz URLs.
- 🧰 **10 categories** — general contractors, architects, interior designers, kitchen & bath, home builders, remodelers, landscape architects, closet designers and more.
- ⭐ **Rich profiles** — rating, review count, Best-of-Houzz badges, services, hire count, address, GPS, social links, description.
- 🔌 **Pipeline-ready** — stable null-safe schema, ISO dates, one-call API, n8n/Make webhook, CSV/JSON/Excel export.
- 💸 **Fair pricing** — $3/1k for directory data (same as others), pay the email premium only when an email is actually found.

---

### Table of contents
- [Quick start](#quick-start)
- [Two modes](#two-modes)
- [Input reference](#input-reference)
- [Output: what you get](#output-what-you-get)
- [Full output example](#full-output-example)
- [Field reference](#field-reference)
- [Run it with the API](#run-it-with-the-api)
- [Use it with n8n / Make](#use-it-with-n8n--make)
- [Pricing](#pricing)
- [Tips, limits & FAQ](#tips-limits--faq)

---

### Quick start

1. Open the Actor and leave **What do you want to scrape?** on **“Search a city”**.
2. Pick a **Category** (e.g. *General Contractors*).
3. Type a **City** — e.g. `Austin, TX`.
4. Set **How many results** (e.g. `50`) and click **Start**.

You’ll get a table of pros with name, phone, address, coordinates, website, and social links. Want full detail (reviews, badges, hire count, **emails**)? Copy the `url` values from your search and run **Full profiles** mode on them.

---

### Two modes

| | **Search a city** (`mode: search`) | **Full profiles** (`mode: pro`) |
|---|---|---|
| Input | Category + City | List of pro profile URLs (`proUrls`) |
| Proxy | **None needed** | **Residential, US** (default — datacenter IPs are blocked) |
| Speed | Very fast | Fast |
| Returns | Identity, phone, address, coords, website, socials | **Everything**: rating, review count, **reviews**, **badges**, **services**, hire count, description, **emails**, socials |
| Best for | Building a lead list for a city | Enriching/qualifying specific pros |

\* In search mode some fields (rating, reviews, badges) are only on the full profile; run *Full profiles* mode on the URLs you collect to fill them in.

**Recommended workflow:** Search a city → take the `url` column → run Full profiles on those URLs with **Find email addresses** on. You now have a complete, email-enriched lead list.

---

### Input reference

| Field | Key | Applies to | Description |
|---|---|---|---|
| What do you want to scrape? | `mode` | both | `search` (default) or `pro`. |
| Category | `proCategory` | search | Dropdown — General Contractors, Architects, Interior Designers, Kitchen & Bath Remodelers, Kitchen Remodelers, Home Remodelers, Home Builders, Design-Build Firms, Landscape Architects, Closet Designers. |
| City | `location` | search | Plain text: `Austin, TX`, `Los Angeles, CA`, `Brooklyn, NY`. Leave blank for nationwide (US). |
| How many results | `maxResults` | both | 1–1000. Default 50. |
| Profile URLs | `proUrls` | pro | Houzz profile URLs (contain `pfvwus`), e.g. `https://www.houzz.com/professionals/general-contractors/chapter-pfvwus-pf~666806768`. |
| Include reviews | `includeReviews` | pro | Default `true`. |
| Only reviews after | `reviewsSince` | pro | ISO date, e.g. `2026-01-01`, for incremental runs. |
| Find email addresses | `enrichEmail` | both | Default `true`. Crawls each pro’s website for emails. |
| Webhook URL | `webhookUrl` | both | POST results to n8n/Make/any endpoint when the run finishes. |
| Advanced: direct URLs | `searchUrls` | search | Paste any Houzz listing URL to scrape as-is (overrides Category + City). |
| Proxy | `proxyConfiguration` | both | Residential US by default (required for `pro`). |

#### Example input — Search a city
```json
{
  "mode": "search",
  "proCategory": "general-contractor",
  "location": "Austin, TX",
  "maxResults": 50,
  "enrichEmail": true
}
````

#### Example input — Full profiles

```json
{
  "mode": "pro",
  "proUrls": [
    "https://www.houzz.com/professionals/general-contractors/chapter-pfvwus-pf~666806768",
    "https://www.houzz.com/professionals/design-build-firms/knockout-renovation-pfvwus-pf~1636076815"
  ],
  "includeReviews": true,
  "enrichEmail": true,
  "proxyConfiguration": { "useApifyProxy": true, "apifyProxyGroups": ["RESIDENTIAL"], "countryCode": "US" }
}
```

***

### Output: what you get

One JSON object per professional. **Every field is always present** — when Houzz doesn’t provide a value you get `null` (or `[]`), so your n8n/Zapier/spreadsheet mappings never break. Dates are emitted in ISO‑8601 UTC.

A trimmed example record:

```json
{
  "name": "Chapter",
  "phone": "(212) 680-4628",
  "email": "itstime@hellochapter.com",
  "website": "https://www.hellochapter.com",
  "address": "345 7th Ave 9th floor, New York, NY, 10001, United States",
  "coordinates": { "lat": 40.7484, "lng": -73.9967 },
  "rating": 4.8,
  "reviewsCount": 26,
  "badges": ["Best of Houzz 2023", "Best of Houzz 2022", "Recommended on Houzz"],
  "services": ["Bathroom Remodeling", "General Contracting", "Home Additions"],
  "hireCount": 61,
  "socialLinks": { "facebook": "https://www.facebook.com/hellochapter", "instagram": "https://www.instagram.com/chapter.renovations/" },
  "url": "https://www.houzz.com/professionals/general-contractors/chapter-pfvwus-pf~666806768"
}
```

A complete record (all fields) is in [`docs/example-output-pro.json`](docs/example-output-pro.json); a search-mode record is in [`docs/example-output-search.json`](docs/example-output-search.json).

***

### Full output example

See [`docs/example-output-pro.json`](docs/example-output-pro.json) for a real, complete pro-mode record including the full `addressComponents`, `areaServed`, `reviews`, `badges`, `coverImage` and `description`.

***

### Field reference

| Field | Type | Notes |
|---|---|---|
| `proId` | string | Houzz professional ID (the `pf~` number). |
| `slug` | string | URL slug. |
| `name` / `businessName` | string | Business name. |
| `url` | string | Canonical Houzz profile URL. |
| `sourceUrl` | string | The page actually scraped. |
| `category` / `categories` | string / array | Category (pro mode may be `null`; search sets it). |
| `phone` | string | Primary phone. |
| `email` | string | **Best** email (prefers role addresses: info@, contact@…). `null` if none found. |
| `emails` | array | All verified emails found on the pro’s website. |
| `website` | string | The pro’s own website. |
| `socialLinks` | object | `facebook, instagram, twitter, linkedin, youtube, pinterest, tiktok` (each `null` if absent). |
| `address` | string | Formatted single-line address. |
| `addressComponents` | object | `streetLine1, city, state, postalCode, country, countryCode`. |
| `coordinates` | object | `{ lat, lng }`. |
| `areaServed` | array | Cities/areas the pro serves. |
| `rating` | number | Average rating (e.g. 4.8). |
| `reviewsCount` | number | Total reviews on Houzz. |
| `ratingDistribution` | object | `{1..5}` star counts (often `null` — lazy-loaded by Houzz). |
| `badges` | array | Awards, e.g. `Best of Houzz 2024`, `Recommended on Houzz`. |
| `yearsInBusiness` | number | `null` when not published. |
| `hireCount` | number | Completed projects on Houzz. |
| `verifiedLicense` | boolean | `null` when not published. |
| `services` | array | Service/specialty list. |
| `projects` | array | Portfolio items (when available). |
| `reviews` | array | `{ rating, comment, author, date, dateFormatted, reply }`. See review-coverage note below. |
| `coverImage` / `galleryImages` | object / array | Image URLs. |
| `description` | string | Business “about” text. |
| `extractionPath` | string | `ld+json+hz-ctx` (full), `ld+json`, `hz-ctx`, or `dom`. |
| `partial` | boolean | `true` if only partial data was available. |
| `scraperVersion` | string | Scraper version. |
| `scrapedAt` | string | ISO‑8601 UTC timestamp. |
| `city` / `state` | string | Flattened from `addressComponents` for easy CSV/leads view. |

***

### Run it with the API

Replace `<YOUR_TOKEN>` with your Apify API token. The Actor ID is `malikgen~houzz-pro-scraper`.

**Run and get results in one call** (synchronous — best for small/medium runs):

```bash
curl -X POST "https://api.apify.com/v2/acts/malikgen~houzz-pro-scraper/run-sync-get-dataset-items?token=<YOUR_TOKEN>" \
  -H "Content-Type: application/json" \
  -d '{
    "mode": "search",
    "proCategory": "general-contractor",
    "location": "Austin, TX",
    "maxResults": 50,
    "enrichEmail": true
  }'
```

The response body is the JSON array of records — ready to use.

**Start a run asynchronously**, then fetch the dataset later:

```bash
## 1) start
curl -X POST "https://api.apify.com/v2/acts/malikgen~houzz-pro-scraper/runs?token=<YOUR_TOKEN>" \
  -H "Content-Type: application/json" \
  -d '{ "mode": "search", "proCategory": "architect", "location": "Miami, FL", "maxResults": 100 }'
## -> note the "defaultDatasetId" in the response

## 2) fetch results (JSON; add &format=csv for CSV, &format=xlsx for Excel)
curl "https://api.apify.com/v2/datasets/<DATASET_ID>/items?token=<YOUR_TOKEN>"
```

***

### Use it with n8n / Make

**Option A — Apify node (recommended).** In n8n add the **Apify** node → *Run Actor* → Actor `malikgen/houzz-pro-scraper` → paste the JSON input → connect *Get Dataset Items* to receive each record as an item.

**Option B — HTTP Request node.** POST to the `run-sync-get-dataset-items` URL above; the node receives the records array directly. Works great in Make.com too (HTTP module).

**Option C — Push to your own webhook.** Set `webhookUrl` in the input to your n8n **Webhook** node URL. When the run finishes, the Actor POSTs `{ mode, recordCount, records, scraperVersion }` to it — fully hands-off pipelines.

```json
{
  "mode": "search",
  "proCategory": "kitchen-and-bath-remodelers",
  "location": "Chicago, IL",
  "maxResults": 200,
  "enrichEmail": true,
  "webhookUrl": "https://your-n8n.example.com/webhook/houzz-leads"
}
```

***

### Pricing

**Pay only for what you use — value-tiered:**

| Charge | Price (Bronze) | When |
|---|---|---|
| Base record | **$3 / 1,000** ($0.003) | every professional returned |
| Email enrichment | **+$7 / 1,000** ($0.007) | **only when a verified email is found** |

- **Directory data** (name, phone, address, rating, reviews, badges, services, socials): **~$3/1k — same as other Houzz scrapers, with richer data and no per-run fee.**
- **A full, outreach-ready lead with a verified email: ~$10/1k** (≈$7/1k on Gold+ tiers).

You never pay the email premium unless we actually deliver an email — and emails are something **no other Houzz scraper provides**. A home-services lead bought elsewhere commonly costs **$50–$500 each**; here a complete, email-enriched lead is about **one cent**.

> Turn email enrichment off (`enrichEmail: false`) to pay base price only.

***

### Tips, limits & FAQ

- **Get emails:** keep **Find email addresses** on and use **Full profiles** mode (search-mode listings often don’t expose a website). Emails come from the pro’s own site, so a pro with no website returns `email: null`.
- **Review coverage:** Houzz loads its full review list lazily (via a background request), so each record currently includes the **rating, total review count, and the featured review**. Full review history is on the roadmap.
- **City not found?** Use `City, ST` (e.g. `Austin, TX`). Bare city names usually work; a known suburb works as its own city (e.g. `Santa Monica, CA`). For anything unusual, paste a Houzz listing URL into **Advanced: direct URLs**.
- **Why residential proxy for Full profiles?** Houzz returns HTTP 500 to datacenter IPs on profile pages. The Actor defaults the proxy to Residential US so it just works.
- **Stable schema:** every field is always present (`null`/`[]` when empty) so downstream automations never break when a value is missing.
- **Compliance:** scrapes only publicly available business listing information for legitimate B2B lead-generation and market research.

***

#### Changelog

- **0.0.1** — Initial release. Search-by-city + full-profile modes, email enrichment, badges, services, reviews (rating + featured), residential proxy for profiles, n8n webhook, null-safe schema.

# Actor input Schema

## `mode` (type: `string`):

**Search** discovers contractors/designers in a city from Houzz listing pages — fast and no proxy needed. **Full profiles** scrapes individual professional pages for the complete record (rating, reviews, badges, services, hire count) and requires a residential proxy.

## `proCategory` (type: `string`):

The type of professional to find. (Search mode only.)

## `location` (type: `string`):

Just type a city, e.g. **Austin, TX** — or **Los Angeles, CA**, **Brooklyn, NY**, **Miami, FL**. A neighborhood/area that Houzz knows also works (e.g. **Santa Monica, CA**). Leave blank to search the entire United States.

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

Maximum records to return. Search mode paginates until this limit; pro mode caps how many profile URLs are processed.

## `proUrls` (type: `array`):

Paste full Houzz professional profile URLs (the ones containing `pfvwus`). Example: `https://www.houzz.com/professionals/general-contractors/chapter-pfvwus-pf~666806768`. Tip: run a Search first, copy the `url` values, then feed them here for the full profile + reviews + emails.

## `includeReviews` (type: `boolean`):

Include the customer review(s) on each profile (rating, comment, ISO date, owner reply). Pro mode only.

## `reviewsSince` (type: `string`):

Optional ISO date (e.g. `2026-01-01`). Keeps only reviews on/after this date — set it to your last run date for incremental pipelines. Pro mode only.

## `enrichEmail` (type: `boolean`):

🌟 Our differentiator. Houzz hides emails behind its own messenger, so no other scraper returns them. When a pro lists a website, we fetch their site (home + /contact + /about) and extract verified emails into `email` (best) and `emails[]` (all). No competitor offers this.

## `webhookUrl` (type: `string`):

Optional n8n / Make / any HTTP endpoint. When the run finishes, results are POSTed here as JSON — great for automated pipelines.

## `searchUrls` (type: `array`):

Power users only. Paste any Houzz listing URL to scrape it as-is (overrides Category + City). Example: `https://www.houzz.com/professionals/general-contractor/c/Seattle--WA`.

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

Required for **Full profiles** mode (datacenter IPs get HTTP 500 on profile pages) — keep Residential, US. Search mode needs no proxy. Email enrichment uses your datacenter/no proxy for website fetches.

## Actor input object example

```json
{
  "mode": "search",
  "proCategory": "general-contractor",
  "location": "Austin, TX",
  "maxResults": 50,
  "proUrls": [
    "https://www.houzz.com/professionals/general-contractors/chapter-pfvwus-pf~666806768"
  ],
  "includeReviews": true,
  "enrichEmail": true,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "countryCode": "US"
  }
}
```

# Actor output Schema

## `overview` (type: `string`):

Key identity, contact, and reputation fields per pro

## `leads` (type: `string`):

Name, phone, email, website, location — ideal CSV export for outreach

## `reviews_flat` (type: `string`):

One row per review — export as CSV for sentiment analysis

# 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 = {
    "location": "Austin, TX",
    "maxResults": 50,
    "proUrls": [
        "https://www.houzz.com/professionals/general-contractors/chapter-pfvwus-pf~666806768"
    ],
    "enrichEmail": true,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "countryCode": "US"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("malikgen/houzz-pro-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 = {
    "location": "Austin, TX",
    "maxResults": 50,
    "proUrls": ["https://www.houzz.com/professionals/general-contractors/chapter-pfvwus-pf~666806768"],
    "enrichEmail": True,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "countryCode": "US",
    },
}

# Run the Actor and wait for it to finish
run = client.actor("malikgen/houzz-pro-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 '{
  "location": "Austin, TX",
  "maxResults": 50,
  "proUrls": [
    "https://www.houzz.com/professionals/general-contractors/chapter-pfvwus-pf~666806768"
  ],
  "enrichEmail": true,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "countryCode": "US"
  }
}' |
apify call malikgen/houzz-pro-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Houzz Pro Scraper – Contractor & Designer Leads with Emails",
        "description": "Turn Houzz into a ready-to-use B2B lead list. Pick a category, type a city, and export contractors, architects, interior designers and remodelers with phone, address, rating, reviews, Best-of-Houzz badges and services — plus the verified email addresses no other Houzz scraper provides.",
        "version": "0.0",
        "x-build-id": "YM2CAmAp5sktnaWBs"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/malikgen~houzz-pro-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-malikgen-houzz-pro-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/malikgen~houzz-pro-scraper/runs": {
            "post": {
                "operationId": "runs-sync-malikgen-houzz-pro-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/malikgen~houzz-pro-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-malikgen-houzz-pro-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": {
                    "mode": {
                        "title": "What do you want to scrape?",
                        "enum": [
                            "search",
                            "pro"
                        ],
                        "type": "string",
                        "description": "**Search** discovers contractors/designers in a city from Houzz listing pages — fast and no proxy needed. **Full profiles** scrapes individual professional pages for the complete record (rating, reviews, badges, services, hire count) and requires a residential proxy.",
                        "default": "search"
                    },
                    "proCategory": {
                        "title": "Category",
                        "enum": [
                            "general-contractor",
                            "architect",
                            "interior-designer",
                            "kitchen-and-bath-remodelers",
                            "kitchen-remodelers",
                            "home-remodeling",
                            "home-builders",
                            "design-build-firms",
                            "landscape-architect",
                            "custom-closet-designers"
                        ],
                        "type": "string",
                        "description": "The type of professional to find. (Search mode only.)",
                        "default": "general-contractor"
                    },
                    "location": {
                        "title": "City",
                        "type": "string",
                        "description": "Just type a city, e.g. **Austin, TX** — or **Los Angeles, CA**, **Brooklyn, NY**, **Miami, FL**. A neighborhood/area that Houzz knows also works (e.g. **Santa Monica, CA**). Leave blank to search the entire United States."
                    },
                    "maxResults": {
                        "title": "How many results?",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Maximum records to return. Search mode paginates until this limit; pro mode caps how many profile URLs are processed.",
                        "default": 50
                    },
                    "proUrls": {
                        "title": "Profile URLs",
                        "type": "array",
                        "description": "Paste full Houzz professional profile URLs (the ones containing `pfvwus`). Example: `https://www.houzz.com/professionals/general-contractors/chapter-pfvwus-pf~666806768`. Tip: run a Search first, copy the `url` values, then feed them here for the full profile + reviews + emails.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "includeReviews": {
                        "title": "Include reviews",
                        "type": "boolean",
                        "description": "Include the customer review(s) on each profile (rating, comment, ISO date, owner reply). Pro mode only.",
                        "default": true
                    },
                    "reviewsSince": {
                        "title": "Only reviews after (date)",
                        "type": "string",
                        "description": "Optional ISO date (e.g. `2026-01-01`). Keeps only reviews on/after this date — set it to your last run date for incremental pipelines. Pro mode only."
                    },
                    "enrichEmail": {
                        "title": "Find email addresses",
                        "type": "boolean",
                        "description": "🌟 Our differentiator. Houzz hides emails behind its own messenger, so no other scraper returns them. When a pro lists a website, we fetch their site (home + /contact + /about) and extract verified emails into `email` (best) and `emails[]` (all). No competitor offers this.",
                        "default": true
                    },
                    "webhookUrl": {
                        "title": "Webhook URL (optional)",
                        "type": "string",
                        "description": "Optional n8n / Make / any HTTP endpoint. When the run finishes, results are POSTed here as JSON — great for automated pipelines."
                    },
                    "searchUrls": {
                        "title": "Advanced: direct Houzz listing URLs",
                        "type": "array",
                        "description": "Power users only. Paste any Houzz listing URL to scrape it as-is (overrides Category + City). Example: `https://www.houzz.com/professionals/general-contractor/c/Seattle--WA`.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "proxyConfiguration": {
                        "title": "Proxy",
                        "type": "object",
                        "description": "Required for **Full profiles** mode (datacenter IPs get HTTP 500 on profile pages) — keep Residential, US. Search mode needs no proxy. Email enrichment uses your datacenter/no proxy for website fetches.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ],
                            "countryCode": "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
