# Houzz Scraper | Photos, Products, Pros & Ideas (`datascraperes/houzz-content-scraper`) Actor

Extract public Houzz photos, products and reviews, professional profiles, projects, discussions and idea galleries. Paste Houzz URLs or IDs and export structured results to JSON, CSV or Excel. No login required.

- **URL**: https://apify.com/datascraperes/houzz-content-scraper.md
- **Developed by:** [DataScraperES](https://apify.com/datascraperes) (community)
- **Stats:** 3 total users, 2 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.75 / 1,000 houzz public 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/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

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

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

Collect public Houzz photos, products with reviews, professional profiles, projects, design discussions and idea galleries in one structured Dataset. Paste a Houzz category URL or specific Houzz URLs and IDs; the Actor **returns normalized, deduplicated records with stable identifiers and source links**. No Houzz account, login or browser is required.

### What this Actor does

The Actor collects public Houzz photo categories and individual photos, products, professional profiles, projects, discussions and idea galleries.

One run can mix several target types. Each delivered item is one public entity: a photo, a photo comment, a professional profile, a project, a product, a product review summary, a product review, a discussion, a discussion answer, an idea gallery item or a gallery comment. Items carry a `recordType` field so you can filter or split the Dataset by entity.

Links point back to the public Houzz page whenever the source exposes one. Missing optional values remain `null` or empty instead of being guessed. The Actor never signs in, never uses account cookies and never returns private messages or contact details.

### Use cases

- Build a photo library for a room, style or renovation category with titles, images and source links.
- Research product catalogs with review summaries, ratings, brands and published prices.
- Collect public professional profiles and their published project portfolios for market research.
- Track public design discussions and answers around a renovation topic.
- Export idea galleries with the products and photos they contain.

### How to use

1. Open the Actor in Apify Console.
2. Paste a Houzz photo category URL in **Houzz URLs**, or add specific photo, professional, product, discussion or gallery targets.
3. Click **Start** and open the Dataset when the run finishes.

The prefilled example collects a small sample from the Houzz kitchen photo category. Reduce **Maximum results** for a quick test, or replace the example category with your own targets. API requests process only the targets you supply.

### Input

Start with `houzzUrls` and `maxItems`; no IDs are needed for supported page URLs. You can mix supported houzz.com category, photo, professional, product, discussion and numeric ideabook URLs. Professional `/pro/username` URLs are also accepted. Other hosts, search pages and URLs with ID query parameters are not supported in this field; use the typed fields for IDs.

Every target field is optional, but at least one target must be supplied. Categories accept a Houzz photo category URL (the Actor reads the numeric topic ID from `bp~t_…`) or a bare topic ID such as `709`. Photo, professional, product and discussion fields accept either a Houzz URL or a numeric ID. The advanced idea gallery field accepts numeric gallery IDs. Category URLs select the category only; additional style or location filters are not applied.

`maxPhotosPerTopic`, `maxProjectsPerProfessional` and `maxItems` are hard caps. `maxItems` applies across the whole run, including related projects, reviews, answers and comments. Categories run first, then photos, professional IDs, professional usernames, products, discussions and galleries; earlier targets can use the entire limit. Duplicate entities are delivered once, even when they appear in several targets.

`includeProfessionalProjects` is enabled by default and returns each professional's public project list. When professional projects are enabled, `includeProjectDetails` fetches the full project record instead of the compact list row. `includeProductReviews` and `includeAnswers` are enabled by default. `includeComments` is disabled by default because it adds public photo and gallery comments to the Dataset.

This is the complete input contract with neutral valid values:

```json
{
  "houzzUrls": [],
  "photoTopics": [
    "https://www.houzz.com/photos/kitchen-ideas-and-designs-phbr0-bp~t_709",
    "712"
  ],
  "photoIds": [
    "https://www.houzz.com/photos/kitchen-remodel-soltis-phvw-vp~160172880"
  ],
  "professionalIds": [
    "https://www.houzz.com/professionals/kitchen-and-bath-remodelers/usi-design-and-remodeling-pfvwus-pf~1006722033"
  ],
  "professionalUsernames": [
    "designit"
  ],
  "productIds": [
    "https://www.houzz.com/products/uttermost-niva-prvw-vr~200622379"
  ],
  "questionIds": [
    "https://www.houzz.com/discussions/small-open-plan-layout-advice-6621384"
  ],
  "galleryIds": [
    "77863297"
  ],
  "includeProfessionalProjects": true,
  "includeProjectDetails": false,
  "includeProductReviews": true,
  "includeAnswers": true,
  "includeComments": false,
  "maxPhotosPerTopic": 40,
  "maxProjectsPerProfessional": 20,
  "maxItems": 300
}
```

A smaller verified input used for the example below:

```json
{
  "houzzUrls": [
    "https://www.houzz.com/photos/kitchen-remodel-soltis-phvw-vp~160172880",
    "https://www.houzz.com/photos/94972480"
  ],
  "maxItems": 2
}
```

### Output

Results are stored in the default Dataset. One item represents one public entity. Every item contains `recordType`, `id` and `scrapedAt`; the remaining fields depend on the record type and stay empty when the source does not publish them. `url` links to the public Houzz page.

The run summary in the key-value store reports delivered counts, per-target status, failed targets and whether the run completed, stopped at the result cap, reached its time budget or could not collect anything. A run that collects nothing is never reported as completed.

This is a complete Dataset item from a real successful run with the small input above:

```json
{
  "recordType": "photo",
  "id": "160172880",
  "url": "https://www.houzz.com/photos/kitchen-remodel-soltis-transitional-kitchen-phoenix-phvw-vp~160172880",
  "title": "Kitchen Remodel (Soltis)",
  "imageUrl": "https://st.hzcdn.com/simgs/af21f6910ed5221f_9-1544/home-design.jpg",
  "imageWidth": 660,
  "imageHeight": 990,
  "imageUrls": [],
  "description": null,
  "ownerId": "22988755",
  "ownerUserName": "teammariano",
  "ownerName": null,
  "professionalId": null,
  "proType": null,
  "numReviews": null,
  "reviewRating": null,
  "city": null,
  "state": null,
  "country": null,
  "brand": null,
  "price": null,
  "priceText": null,
  "currency": null,
  "reviewCount": null,
  "averageRating": null,
  "ratingDistribution": [],
  "aspectSummaries": [],
  "created": null,
  "modified": null,
  "likes": 1680,
  "numberOfAnswers": null,
  "commentCount": 6,
  "parentId": null,
  "parentType": null,
  "sourceTopicId": null,
  "categoryId": 1005,
  "topicId": null,
  "projectId": "6211731",
  "projectName": "Kitchen Remodel",
  "objectType": null,
  "objectId": null,
  "galleryId": null,
  "tags": [],
  "scrapedAt": "2026-10-26T08:05:31.678+00:00"
}
```

Records can be exported as JSON, CSV or Excel from the Dataset.

### Pricing

One `result` event is charged per unique record delivered to the Dataset. Apify applies your plan's price automatically:

| Apify plan | Price per result | Equivalent per 1,000 results |
|---|---:|---:|
| Free | $0.001 | $1.00 |
| Bronze | $0.0009 | $0.90 |
| Silver | $0.0008 | $0.80 |
| Gold | $0.00075 | $0.75 |
| Platinum | $0.00075 | $0.75 |
| Diamond | $0.00075 | $0.75 |

Photos, profiles, projects, products, reviews, discussions, answers and gallery items are separate records when delivered. Runs that deliver no items produce no result charges. If a spending limit is reached, the run stops, keeps delivered rows and reports a spending-limit outcome in the run summary. Check the **Pricing** tab for the current price before starting a paid run.

### Related Actors

| Actor | Best for |
|---|---|
| [Realtor.com US Property Listings Scraper](https://apify.com/datascraperes/realtor-property-search) | Compare home listings and property details for renovation research. |
| [Zillow Search Scraper | Filtered Search URLs](https://apify.com/datascraperes/zillow-search-url-scraper) | Collect filtered US property search results alongside Houzz project research. |
| [Google Maps Business Scraper | $1 per 1,000](https://apify.com/datascraperes/actor-google-maps) | Look up local contractor and design business profiles outside Houzz. |

### Limits and data quality

Coverage is limited to public Houzz content. Titles, prices, ratings, review counts, project counts and availability change on the source and can differ between runs. The Actor reports what the source returns at collection time and does not verify or recalculate ratings and prices.

Some entity types require an identifier. Houzz does not publish a public listing endpoint for every content type, so products, discussions and idea galleries are collected from the URLs or IDs you supply. Photo categories are browsed automatically.

Browsing stops at the configured category, project and global caps. The global cap includes results saved earlier in the same resumed run. A spending limit can also stop collection before the requested number of results is reached. If a page repeats while more results are expected, the run summary reports that collection is incomplete. Optional enrichment failures keep the base record and remain eligible for another attempt when the run resumes.

The Actor respects source availability. If Houzz temporarily restricts access, already delivered rows remain in the Dataset and the run is marked partial or stopped rather than completed. Missing public values remain empty; the Actor does not infer them.

### Frequently asked questions

#### Do I need a Houzz account?

No. The Actor only reads public content and does not sign in.

#### Why do I need a gallery ID instead of a gallery URL?

Houzz gallery URLs do not consistently expose the numeric gallery ID. Paste the ID when you have it; photo, professional, product and discussion fields accept URLs.

#### Why are some fields empty?

Houzz does not publish every field for every entity. A photo may have no room topic, a product may have no current price, and a professional profile may not expose a public description. Empty values are preserved as `null` rather than guessed.

#### Why are there fewer results than requested?

The cap is a maximum, not a guarantee. Categories can contain fewer items, duplicates are removed, and optional targets can fail. Check the run summary for per-target status.

#### Can I mix target types in one run?

Yes. All supplied targets are processed in a deterministic order and deduplicated across the run.

### Responsible use

Use the collected data lawfully and respect Houzz's terms, applicable privacy rules and your own obligations. The Actor returns public content only. Do not use it to contact people who have not invited contact, and do not treat public profile information as consent for unsolicited marketing.

### Support

Open an issue in the Actor's **Issues** tab with your run ID, a reproducible input and the target that failed. Remove any personal or secret values before sharing.

[Python, JavaScript and CSV integration examples on GitHub](https://github.com/datacrawler-edu/houzz-scraper-python)

# Actor input Schema

## `houzzUrls` (type: `array`):

Paste supported houzz.com photo category, photo, professional, product, discussion or numeric ideabook URLs. Different types can be mixed. Category URLs select the category only, not extra style or location filters. For IDs or usernames, use Advanced: IDs and usernames.

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

Total delivered records across all targets, including related projects, reviews, answers and comments. Categories are processed first; the run stops when this limit is reached.

## `includeProfessionalProjects` (type: `boolean`):

Return the public project list for every professional target.

## `includeProjectDetails` (type: `boolean`):

Fetch the full public project record, including description, year started and photo IDs, for every project found. Only applies when Include professional projects is enabled.

## `includeProductReviews` (type: `boolean`):

Return the public review summary and latest reviews for every product target.

## `includeAnswers` (type: `boolean`):

Return the public answers for every discussion target.

## `includeComments` (type: `boolean`):

Return public comments for photo targets and idea gallery targets.

## `maxPhotosPerTopic` (type: `integer`):

Maximum number of distinct photos collected from each photo category.

## `maxProjectsPerProfessional` (type: `integer`):

Maximum number of public projects returned for each professional target.

## `photoTopics` (type: `array`):

Houzz photo category URLs or numeric topic IDs. Copy a category URL from Houzz, for example https://www.houzz.com/photos/kitchen-ideas-and-designs-phbr0-bp~t_709, or enter the topic ID 709. The Actor reads the ID from the URL and browses that category.

## `photoIds` (type: `array`):

Specific Houzz photos to collect. Paste photo URLs or numeric photo IDs. A URL such as https://www.houzz.com/photos/example-phvw-vp~160172880 resolves to photo ID 160172880.

## `professionalIds` (type: `array`):

Houzz professional profile URLs or numeric user IDs. A URL such as https://www.houzz.com/professionals/kitchen-and-bath-remodelers/example-pfvwus-pf~1006662065 resolves to professional ID 1006662065.

## `professionalUsernames` (type: `array`):

Houzz profile usernames such as designit. Use this when a profile URL does not expose a numeric professional ID.

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

Houzz product URLs or numeric product IDs. A URL such as https://www.houzz.com/products/example-prvw-vr~200622379 resolves to product ID 200622379.

## `questionIds` (type: `array`):

Houzz discussion URLs or numeric question IDs. A URL such as https://www.houzz.com/discussions/layout-advice-6621384 resolves to discussion ID 6621384.

## `galleryIds` (type: `array`):

Numeric Houzz idea gallery IDs. The Actor returns the gallery items and, optionally, its public comments.

## Actor input object example

```json
{
  "houzzUrls": [
    "https://www.houzz.com/photos/kitchen-ideas-and-designs-phbr0-bp~t_709"
  ],
  "maxItems": 10,
  "includeProfessionalProjects": true,
  "includeProjectDetails": false,
  "includeProductReviews": true,
  "includeAnswers": true,
  "includeComments": false,
  "maxPhotosPerTopic": 5,
  "maxProjectsPerProfessional": 5,
  "photoTopics": [],
  "photoIds": [],
  "professionalIds": [],
  "professionalUsernames": [],
  "productIds": [],
  "questionIds": [],
  "galleryIds": []
}
```

# Actor output Schema

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

The default dataset. Each item is one delivered public Houzz entity and one billable result event.

## `summary` (type: `string`):

Delivered counts, per-target status, transport metrics and billing mode.

# 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 = {
    "houzzUrls": [
        "https://www.houzz.com/photos/kitchen-ideas-and-designs-phbr0-bp~t_709"
    ],
    "maxItems": 10,
    "includeProfessionalProjects": true,
    "includeProjectDetails": false,
    "includeProductReviews": true,
    "includeAnswers": true,
    "includeComments": false,
    "maxPhotosPerTopic": 5,
    "maxProjectsPerProfessional": 5,
    "photoTopics": [],
    "photoIds": [],
    "professionalIds": [],
    "professionalUsernames": [],
    "productIds": [],
    "questionIds": [],
    "galleryIds": []
};

// Run the Actor and wait for it to finish
const run = await client.actor("datascraperes/houzz-content-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 = {
    "houzzUrls": ["https://www.houzz.com/photos/kitchen-ideas-and-designs-phbr0-bp~t_709"],
    "maxItems": 10,
    "includeProfessionalProjects": True,
    "includeProjectDetails": False,
    "includeProductReviews": True,
    "includeAnswers": True,
    "includeComments": False,
    "maxPhotosPerTopic": 5,
    "maxProjectsPerProfessional": 5,
    "photoTopics": [],
    "photoIds": [],
    "professionalIds": [],
    "professionalUsernames": [],
    "productIds": [],
    "questionIds": [],
    "galleryIds": [],
}

# Run the Actor and wait for it to finish
run = client.actor("datascraperes/houzz-content-scraper").call(run_input=run_input)

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

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

```

## CLI example

```bash
echo '{
  "houzzUrls": [
    "https://www.houzz.com/photos/kitchen-ideas-and-designs-phbr0-bp~t_709"
  ],
  "maxItems": 10,
  "includeProfessionalProjects": true,
  "includeProjectDetails": false,
  "includeProductReviews": true,
  "includeAnswers": true,
  "includeComments": false,
  "maxPhotosPerTopic": 5,
  "maxProjectsPerProfessional": 5,
  "photoTopics": [],
  "photoIds": [],
  "professionalIds": [],
  "professionalUsernames": [],
  "productIds": [],
  "questionIds": [],
  "galleryIds": []
}' |
apify call datascraperes/houzz-content-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,datascraperes/houzz-content-scraper"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/ah6m44GxSBijKS0Vs/builds/ArnfEnr7fsyWdDvWu/openapi.json