# Houzz Design Photo Gallery Scraper (`automation-lab/houzz-design-photo-gallery-scraper`) Actor

🖼️ Export public Houzz design photos with project context, professionals, styles, locations, material attributes, canonical links, and full-size image metadata.

- **URL**: https://apify.com/automation-lab/houzz-design-photo-gallery-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Marketing
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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

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

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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/docs.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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 Design Photo Gallery Scraper

Extract public Houzz inspiration photos into a clean dataset for design research, trend tracking, product marketing, and visual portfolio analysis.

The Actor accepts Houzz gallery URLs, filtered category URLs, individual photo URLs, or plain-language photo searches. It returns stable photo IDs, project titles, professionals, descriptions, design context, canonical URLs, full-size image URLs, and gallery provenance.

No Houzz login is required.

### What does Houzz Design Photo Gallery Scraper do?

Houzz contains millions of useful interior and exterior design photos, but its infinite galleries are hard to monitor or compare in bulk.

This Actor automates that work:

- 🖼️ collects one dataset row per public Houzz photo;
- 🏠 preserves room, style, location, and project context;
- 👷 identifies the professional attached to each photo;
- 📝 extracts descriptions and normalized design attributes;
- 🔗 returns canonical Houzz and direct CDN image URLs;
- 📊 records gallery title and total result count;
- 🔍 supports URL-based and keyword-based discovery;
- ♻️ deduplicates overlapping galleries by stable photo ID.

Use the dataset in CSV, Excel, JSON, XML, Google Sheets, databases, dashboards, or AI workflows.

### Who is it for?

#### Interior-design trend analysts

Track rooms, materials, layouts, colors, and styles across recurring searches.

#### Building-product marketers

Discover how cabinets, countertops, backsplashes, fixtures, flooring, and appliances appear in real projects.

#### Architects and design studios

Build reference sets and monitor public portfolios without manually paging through galleries.

#### Competitive-intelligence teams

Compare public project themes, locations, and visual positioning across professionals.

#### Data and AI teams

Create source-attributed image metadata for classification, search, or retrieval workflows. Users remain responsible for image rights and permitted downstream use.

### Why use this Houzz photo scraper?

Manual research is slow and difficult to reproduce. The Actor provides:

- repeatable inputs for recurring monitoring;
- bounded pagination and predictable result limits;
- stable identifiers for change detection;
- source URLs for verification and attribution;
- optional detail-page enrichment;
- typed fields instead of copied page text;
- configurable proxies for protected public pages;
- Apify scheduling, webhooks, integrations, and API access.

Unlike broad all-in-one Houzz scrapers, this Actor keeps the output focused: every row is a design photo.

### What Houzz data can you extract?

| Field | Description |
|---|---|
| `photoId` | Stable Houzz photo identifier |
| `photoUrl` | Canonical public photo page |
| `title` | Photo or project title |
| `description` | Public caption and design description |
| `professionalName` | Professional or studio credited on the photo |
| `professionalUrl` | Public Houzz professional profile |
| `galleryTitle` | Gallery/category heading used for discovery |
| `galleryUrl` | Original URL seed |
| `galleryTotal` | Total photos reported by the gallery |
| `query` | Keyword seed, when used |
| `style` | Detected style context |
| `roomType` | Kitchen, bathroom, living room, exterior, and more |
| `location` | Public project location context |
| `attributes` | Normalized descriptive material/layout fragments |
| `imageUrl` | Direct image URL, full-size when detail enrichment is on |
| `imageSrcSet` | Available gallery image variants |
| `imageAlt` | Public image alt text |
| `imageWidth`, `imageHeight` | Gallery image dimensions |
| `keywords` | Structured photo keywords from the detail page |
| `scrapedAt` | ISO 8601 capture timestamp |

Optional values are omitted when Houzz does not expose them. The Actor does not invent counts or classifications.

### How to scrape Houzz design photos

1. Open the Actor input form.
2. Paste one or more Houzz gallery/photo URLs, add search queries, or use the prefilled example.
3. Set **Maximum photos** to the number of unique records required.
4. Keep **Open photo detail pages** enabled for full image URLs and richer metadata.
5. Click **Start**.
6. Preview the dataset and export it in your preferred format.

For a cheap first run, use one gallery, 5–10 photos, one page, and gallery-only mode.

### Input

```json
{
  "startUrls": [
    {
      "url": "https://www.houzz.com/photos/contemporary-kitchen-ideas-phbr1-bp~t_709~s_2103"
    }
  ],
  "searchQueries": [],
  "maxItems": 10,
  "includeDetails": true,
  "maxPagesPerSeed": 2
}
````

#### Input fields

- `startUrls` — public `houzz.com` gallery, filtered category, search, or photo URLs.
- `searchQueries` — phrases such as `modern kitchen` or `terrazzo bathroom`.
- `maxItems` — global cap across all seeds, from 1 to 1,000.
- `includeDetails` — open each photo to enrich structured metadata.
- `maxPagesPerSeed` — pagination safety limit from 1 to 50.
- `proxyConfiguration` — Apify Proxy or custom proxy settings.

URL and query seeds can be combined. URLs outside `houzz.com` fail validation instead of being fetched.

### Output example

```json
{
  "photoId": "140538492",
  "photoUrl": "https://www.houzz.com/photos/chicago-lux-kitchen-contemporary-kitchen-chicago-phvw-vp~140538492",
  "title": "Chicago Lux Kitchen",
  "description": "Contemporary Kitchen photo - Chicago Lux, Art Deco, White Kitchen...",
  "professionalName": "BK Interior Design",
  "professionalUrl": "https://www.houzz.com/professionals/interior-designers-and-decorators/bk-interior-design-pfvwus-pf~1862825172",
  "galleryTitle": "Contemporary Kitchen Ideas",
  "galleryTotal": 742798,
  "style": "Contemporary",
  "roomType": "Kitchen",
  "location": "Chicago",
  "imageUrl": "https://st.hzcdn.com/simgs/333145760c9ea182_9-2070/home-design.jpg",
  "keywords": ["Kitchen photo", "Contemporary photo", "Kitchen design ideas"],
  "scrapedAt": "2026-07-23T00:00:00.000Z"
}
```

Exact source values change as Houzz updates its public pages.

### Gallery mode versus detail enrichment

With `includeDetails: false`, the Actor reads gallery cards only. This is faster and works well for frequent monitoring.

With `includeDetails: true`, the Actor also opens each photo page and extracts public JSON-LD metadata. This typically improves:

- image resolution;
- structured keywords;
- full descriptions;
- style, room, and location context;
- author/professional attribution.

Detail mode makes one additional page request per saved photo, so it takes longer.

### Pagination and deduplication

Houzz galleries normally expose 20 records at a time. The Actor advances through offsets until it reaches:

- `maxItems`;
- `maxPagesPerSeed`;
- an empty or short page;
- a page containing no new photo IDs.

If the same photo appears in several queries or galleries, it is saved once per run.

### Search and filter tips

Use specific nouns and materials for higher-value result sets:

- `walnut kitchen`;
- `terrazzo bathroom`;
- `coastal living room`;
- `black window exterior`;
- `brass fixture powder room`.

For precise Houzz filters, configure them on Houzz and paste the resulting gallery URL. The Actor preserves that URL as provenance.

### How much does it cost to scrape Houzz photos?

The Actor uses pay-per-event pricing:

- a small **$0.001 start fee** per run;
- a tiered fee per unique photo saved;
- the current BRONZE price is **$0.003785 per photo**.

Apify shows the exact price for your plan before each run. Detail enrichment affects compute and proxy use but does not create duplicate output charges.

For the lowest effective cost, combine related queries in one run and use gallery-only mode when full detail metadata is unnecessary.

### Scheduling a Houzz trend monitor

Use Apify Schedules to repeat a saved task daily, weekly, or monthly.

A typical workflow is:

1. save stable keyword or gallery inputs;
2. schedule the task;
3. identify photos by `photoId`;
4. compare the latest dataset with the prior export;
5. notify analysts when new projects or styles appear.

Stable IDs make append-only storage and deduplication straightforward.

### Integrations

#### Google Sheets

Send each completed dataset to a sheet for research, tagging, and review.

#### Webhooks and Slack

Trigger an automation when a monitoring run finishes, then post new-photo counts or selected records.

#### Airtable and databases

Upsert on `photoId` and preserve `scrapedAt` for freshness tracking.

#### AI classification

Pass descriptions, attributes, keywords, and source URLs to a vision or text model. Review image licensing before downloading or reproducing assets.

#### Zapier and Make

Create no-code workflows that start the Actor, wait for completion, and route records downstream.

### API usage with JavaScript

```javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/houzz-design-photo-gallery-scraper').call({
  searchQueries: ['modern kitchen', 'terrazzo bathroom'],
  maxItems: 40,
  includeDetails: true,
  maxPagesPerSeed: 3,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

### API usage with Python

```python
import os
from apify_client import ApifyClient

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/houzz-design-photo-gallery-scraper').call(run_input={
    'searchQueries': ['coastal living room'],
    'maxItems': 20,
    'includeDetails': True,
})
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

### API usage with cURL

```bash
curl -X POST \
  'https://api.apify.com/v2/acts/automation-lab~houzz-design-photo-gallery-scraper/runs?token=YOUR_APIFY_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{
    "searchQueries": ["farmhouse bathroom"],
    "maxItems": 10,
    "includeDetails": true
  }'
```

Never commit an Apify API token to source control.

### Use with Apify MCP and AI agents

Connect the Actor to Claude Code or another MCP client through:

`https://mcp.apify.com?tools=automation-lab/houzz-design-photo-gallery-scraper`

Example Claude Code command:

```bash
claude mcp add --transport http apify \
  'https://mcp.apify.com?tools=automation-lab/houzz-design-photo-gallery-scraper'
```

#### Claude Desktop, Cursor, and VS Code setup

Use the same `mcpServers` JSON block in **Claude Desktop**, **Cursor**, or **VS Code**. Add it to that client's MCP settings, then restart or reload the client.

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=automation-lab/houzz-design-photo-gallery-scraper"
    }
  }
}
```

Example prompts:

- “Extract 20 modern kitchen photos from Houzz and group the design attributes.”
- “Monitor this Houzz gallery and summarize newly observed photo IDs.”
- “Build a table of professionals and locations from these design-photo URLs.”

### Reliability and proxies

Houzz rate-limits ordinary datacenter traffic. The Actor therefore uses a proven Apify Proxy group by default and keeps browser concurrency conservative.

It also:

- reuses one browser session per run;
- blocks third-party analytics, fonts, and media downloads;
- retries transient navigation failures with backoff;
- fails the run if every route produces zero records;
- lets advanced users provide another proxy configuration.

If a custom datacenter proxy returns 429, switch to an Apify residential proxy with United States geography.

### Performance guidance

Runtime depends mainly on detail enrichment.

- Gallery-only: one browser page can yield up to 20 records.
- Detail mode: one extra navigation is required per record.
- Multiple seeds run sequentially to reduce blocking.

Start small, inspect output quality, and then increase `maxItems`. For large historical collections, split runs by room, style, or material query.

### Data quality and limitations

Public page content can vary by country, session, experiment, or source record.

Keep these limitations in mind:

- optional fields may be absent;
- gallery totals change over time;
- descriptions are publisher-provided and not standardized;
- inferred attributes are normalized text fragments, not guaranteed product taxonomy;
- some photo pages may no longer exist;
- the Actor does not extract private ideabooks or logged-in content;
- save/question counts are not emitted unless Houzz exposes a stable value;
- image availability and resolution remain controlled by Houzz.

Use source URLs to verify important decisions.

### Is scraping Houzz legal?

This Actor accesses public, no-login pages. Scraping legality depends on jurisdiction, purpose, contractual obligations, and downstream use.

Users should:

- follow applicable law and Houzz terms;
- collect only data they have a lawful reason to process;
- avoid republishing copyrighted images without permission;
- respect privacy and intellectual-property rights;
- use conservative frequency and result limits;
- honor valid deletion or correction requirements.

The Actor is a technical tool, not legal advice.

### Troubleshooting

#### The run returns HTTP 429 or a block page

Keep the default proxy configuration or select an Apify residential proxy in the input. Avoid high-frequency parallel runs against the same gallery.

#### The run succeeds but a field is missing

Many Houzz fields are optional. Enable **Open photo detail pages** for structured descriptions, keywords, and full-size image URLs.

#### My gallery URL is rejected

Only public `houzz.com` URLs are accepted. Remove tracking redirects and use the final Houzz gallery or photo URL.

#### I received fewer records than `maxItems`

The selected gallery may be finite, may contain duplicates across seeds, or may expose fewer new records within `maxPagesPerSeed`. Increase the page limit only when the source visibly contains more results.

#### A detail page disappeared

Houzz publishers can remove public photos. Re-run gallery-only mode or omit unavailable records from downstream processing.

### Frequently asked questions

#### Does this Actor require a Houzz account?

No. Version 1 is strictly public and no-login.

#### Can I scrape one individual photo URL?

Yes. Paste a canonical URL containing `-phvw-vp~<photoId>` into `startUrls`.

#### Can I mix URLs and keyword searches?

Yes. The global `maxItems` cap applies across all seeds.

#### Does it download image files?

No. It returns direct public image URLs and metadata. Your workflow can decide whether downloading is lawful and necessary.

#### Can it extract professionals?

It returns the professional credited on each photo as context. It is not a professional lead-directory scraper.

#### Can I remove duplicate photos across scheduled runs?

Use `photoId` as the stable key in your database or automation.

#### Why is browser automation necessary?

Houzz currently rate-limits plain datacenter requests, while browser sessions through an appropriate proxy receive the useful public gallery content.

### Related Automation Lab scrapers

Combine this Actor with other public-data workflows from Automation Lab:

- [Google Maps Scraper](https://apify.com/automation-lab/google-maps-scraper) for local business and place context.
- [Pinterest Scraper](https://apify.com/automation-lab/pinterest-scraper) for broader visual trend research.
- [Instagram Scraper](https://apify.com/automation-lab/instagram-scraper) for public social portfolio monitoring.

Choose a lead-directory actor when your primary goal is business contact data rather than photo and design intelligence.

### Support

For reproducible support, include:

- the run URL;
- a redacted copy of the input;
- the Houzz source URL;
- expected versus observed output;
- whether detail enrichment and a custom proxy were enabled.

Do not include passwords, private tokens, or personal information in an issue.

# Actor input Schema

## `startUrls` (type: `array`):

Public houzz.com photo gallery, search, category, or individual photo URLs. URL seeds are combined with keyword seeds.

## `searchQueries` (type: `array`):

One Houzz Photos keyword search per line, such as modern kitchen, terrazzo bathroom, or coastal living room.

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

Maximum unique photo records saved across all URL and query seeds.

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

Enrich each gallery card with full-size image URL, structured description, keywords, style, room, and location. Disable for faster gallery-only monitoring.

## `maxPagesPerSeed` (type: `integer`):

Safety limit for pagination. Each Houzz gallery page normally contains 20 photos.

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

Houzz rate-limits datacenter traffic. The default uses an Apify Proxy group proven to reach public galleries; choose residential proxy when customizing.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.houzz.com/photos/contemporary-kitchen-ideas-phbr1-bp~t_709~s_2103"
    }
  ],
  "searchQueries": [],
  "maxItems": 10,
  "includeDetails": true,
  "maxPagesPerSeed": 2,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "BUYPROXIES94952"
    ],
    "apifyProxyCountry": "US"
  }
}
```

# Actor output Schema

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

Open the typed dataset view with photo IDs, projects, professionals, design context, image URLs, and gallery provenance.

# 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 = {
    "startUrls": [
        {
            "url": "https://www.houzz.com/photos/contemporary-kitchen-ideas-phbr1-bp~t_709~s_2103"
        }
    ],
    "searchQueries": [],
    "maxItems": 10,
    "includeDetails": true,
    "maxPagesPerSeed": 2,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "BUYPROXIES94952"
        ],
        "apifyProxyCountry": "US"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/houzz-design-photo-gallery-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 = {
    "startUrls": [{ "url": "https://www.houzz.com/photos/contemporary-kitchen-ideas-phbr1-bp~t_709~s_2103" }],
    "searchQueries": [],
    "maxItems": 10,
    "includeDetails": True,
    "maxPagesPerSeed": 2,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["BUYPROXIES94952"],
        "apifyProxyCountry": "US",
    },
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/houzz-design-photo-gallery-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 '{
  "startUrls": [
    {
      "url": "https://www.houzz.com/photos/contemporary-kitchen-ideas-phbr1-bp~t_709~s_2103"
    }
  ],
  "searchQueries": [],
  "maxItems": 10,
  "includeDetails": true,
  "maxPagesPerSeed": 2,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "BUYPROXIES94952"
    ],
    "apifyProxyCountry": "US"
  }
}' |
apify call automation-lab/houzz-design-photo-gallery-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Houzz Design Photo Gallery Scraper",
        "description": "🖼️ Export public Houzz design photos with project context, professionals, styles, locations, material attributes, canonical links, and full-size image metadata.",
        "version": "0.1",
        "x-build-id": "IKr5ic0AfMK8mw4ol"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~houzz-design-photo-gallery-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-houzz-design-photo-gallery-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/automation-lab~houzz-design-photo-gallery-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-houzz-design-photo-gallery-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/automation-lab~houzz-design-photo-gallery-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-houzz-design-photo-gallery-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": {
                    "startUrls": {
                        "title": "🏠 Houzz gallery or photo URLs",
                        "type": "array",
                        "description": "Public houzz.com photo gallery, search, category, or individual photo URLs. URL seeds are combined with keyword seeds.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "searchQueries": {
                        "title": "Design search queries",
                        "type": "array",
                        "description": "One Houzz Photos keyword search per line, such as modern kitchen, terrazzo bathroom, or coastal living room.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxItems": {
                        "title": "Maximum photos",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Maximum unique photo records saved across all URL and query seeds.",
                        "default": 10
                    },
                    "includeDetails": {
                        "title": "Open photo detail pages",
                        "type": "boolean",
                        "description": "Enrich each gallery card with full-size image URL, structured description, keywords, style, room, and location. Disable for faster gallery-only monitoring.",
                        "default": true
                    },
                    "maxPagesPerSeed": {
                        "title": "Maximum gallery pages per seed",
                        "minimum": 1,
                        "maximum": 50,
                        "type": "integer",
                        "description": "Safety limit for pagination. Each Houzz gallery page normally contains 20 photos.",
                        "default": 5
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Houzz rate-limits datacenter traffic. The default uses an Apify Proxy group proven to reach public galleries; choose residential proxy when customizing.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "BUYPROXIES94952"
                            ],
                            "apifyProxyCountry": "US"
                        }
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```