# HUD Home Store Foreclosure Listings Scraper (`automation-lab/hud-home-store-foreclosure-listings-scraper`) Actor

Extract current HUD-owned foreclosure and REO listings with prices, property facts, FHA financing, bidder eligibility, bid windows, coordinates, and photos. Search by city, state, ZIP, or HUD URL. Export and schedule without a login or API key.

- **URL**: https://apify.com/automation-lab/hud-home-store-foreclosure-listings-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Real estate, Automation
- **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 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/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

Extract current **HUD Home Store foreclosure listings** without a login or API key.

Search by city, state, ZIP code, or copied HUD search URL and export clean property records for sourcing, monitoring, and analysis.

The scraper returns list prices, bid windows, bidder eligibility, FHA financing, property facts, coordinates, amenities, and images from the public [HUD Home Store](https://www.hudhomestore.gov/).

### What does HUD Home Store Foreclosure Listings Scraper do?

HUD Home Store Foreclosure Listings Scraper turns public US government-owned foreclosure and REO searches into structured data.

Use a location such as `Houston, TX`, a state code such as `TX`, or a HUD search URL.

The Actor then:

- 🔍 fetches the official anonymous search result;
- 🏠 extracts every property in the source response;
- 🧹 normalizes prices, counts, dates, and coordinates;
- 🔁 deduplicates overlapping searches by HUD case number;
- 🎯 applies your price, bedroom, bathroom, property, period, and bidder filters;
- 📦 exports the result to JSON, CSV, Excel, XML, or RSS.

Unlike browser-heavy alternatives, this Actor uses the server-rendered HUD data route and normally needs only 256 MB of memory.

No HUD account, API token, or manual CAPTCHA step is required.

### Who is it for? HUD foreclosure buyers and monitors

**Real-estate investors and wholesalers**

- Sweep states or local markets for distressed inventory.
- Filter by list price, bedroom count, and property type.
- Feed qualified deals into underwriting spreadsheets.

**Brokers and buyer agents**

- Watch new and price-reduced HUD inventory.
- Track list dates, bid-open dates, and bid deadlines.
- Separate all-bidder listings from restricted eligibility periods.

**Owner occupants and housing organizations**

- Find homes open to owner occupants.
- Identify nonprofit or government-agency eligibility.
- Check FHA financing and the HUD $100 Down program flag.

**Data and operations teams**

- Schedule repeat state searches.
- Compare case numbers between runs to detect new inventory.
- Send changed records to a database, CRM, Slack, or webhook.

### Why use this HUD Home Store scraper?

- ✅ **Current official source** — records come from public HUD Home Store searches.
- ✅ **Rich listing data** — not just addresses and prices.
- ✅ **Typed output** — prices, areas, years, and coordinates are numbers.
- ✅ **ISO dates** — source dates are normalized to `YYYY-MM-DD`.
- ✅ **Stable deduplication** — HUD case number is the unique key.
- ✅ **No browser overhead** — fast direct HTTP for ordinary runs.
- ✅ **No login or API key** — only anonymous listing search is used.
- ✅ **Apify-native automation** — API, schedules, datasets, webhooks, and integrations are included.

The Actor intentionally excludes bidding, favorites, account access, and email/share actions.

### What HUD foreclosure data can you extract?

| Category | Fields |
|---|---|
| Identity | HUD case number, street address, full location |
| Geography | city, state, ZIP, county, latitude, longitude |
| Pricing | list price |
| Property facts | beds, baths, square feet, year built, age, stories |
| Classification | property type, property status, listing period |
| Financing | FHA financing status, HUD $100 Down flag |
| Bid workflow | list date, bid-open date, bid deadline |
| Eligibility | eligible bidder summary and bidder types |
| Features | indoor amenities, outdoor amenities, parking |
| Media | thumbnail URL and gallery image URLs |
| Provenance | source search URL and scrape timestamp |

Optional fields are omitted when HUD does not publish a value for that listing.

### Pricing: How much does it cost to scrape HUD foreclosure listings?

This Actor uses **pay-per-event pricing**.

You pay a $0.005 search-run start fee and a small amount per unique listing saved.

| Apify plan | Price per listing | 100 listings plus start |
|---|---:|---:|
| Free | $0.000064738 | $0.0115 |
| Starter / Bronze | $0.000056294 | $0.0106 |
| Scale / Silver | $0.000043909 | $0.0094 |
| Business / Gold | $0.000033776 | $0.0084 |
| Platinum | $0.000022518 | $0.0073 |
| Diamond | $0.000015762 | $0.0066 |

Filtering happens before listings are saved and charged.

The Apify Free plan includes platform credits, so a small local-market search is inexpensive to evaluate.

### How to scrape HUD Home Store listings

1. Open the Actor on Apify.
2. Add one or more locations.
3. Keep `maxItems` low for your first run.
4. Add optional price, bedroom, property, or bidder filters.
5. Click **Start**.
6. Preview the dataset while the run executes.
7. Export the finished records or connect an integration.

A simple city input:

```json
{
  "locations": ["Houston, TX"],
  "maxItems": 25
}
````

A state inventory sweep:

```json
{
  "locations": ["TX"],
  "maxItems": 250,
  "maxConcurrency": 2
}
```

An owner-occupant sourcing workflow:

```json
{
  "locations": ["TX"],
  "maxPrice": 250000,
  "minBedrooms": 3,
  "eligibleBidders": ["Owner Occupant"],
  "maxItems": 100
}
```

### Input parameters

| Parameter | Type | Default | Description |
|---|---|---:|---|
| `locations` | string\[] | `[]` | `City, ST`, two-letter state code, or ZIP searches |
| `searchUrls` | URL\[] | `[]` | Copied HUD `/searchresult` URLs with `citystate` |
| `maxItems` | integer | `25` | Global unique-listing limit |
| `minPrice` | integer | — | Minimum USD list price |
| `maxPrice` | integer | — | Maximum USD list price |
| `minBedrooms` | number | — | Minimum bedroom count |
| `minBathrooms` | number | — | Minimum bathroom count |
| `propertyTypes` | string\[] | `[]` | Exact HUD property-type labels |
| `listingPeriods` | string\[] | `[]` | Exact HUD period labels, such as `Exclusive` |
| `eligibleBidders` | string\[] | `[]` | Match any exact bidder type |
| `maxConcurrency` | integer | `3` | Simultaneous HUD searches, from 1 to 10 |
| `proxyConfiguration` | object | — | Optional Apify or custom proxy configuration |

At least one non-empty `locations` or `searchUrls` value is required.

Search URLs are restricted to the official HTTPS HUD Home Store search-result path.

### HUD property filter values

HUD labels can change as inventory changes.

Common `propertyTypes` include:

- `Single Family Home`
- `Condo`

Common `listingPeriods` include:

- `Exclusive`
- `Extended`

Common `eligibleBidders` values include:

- `Investor`
- `Owner Occupant`
- `Nonprofit`
- `Government Agency`

String filters are exact but case-insensitive.

If you filter on a value that HUD omitted, that listing is excluded rather than guessed.

### Output example

```json
{
  "caseNumber": "493-806212",
  "address": "802 Seafoam Rd",
  "city": "Houston",
  "state": "TX",
  "zipCode": "77062",
  "fullLocation": "802 Seafoam Rd, Houston, TX 77062",
  "county": "Harris",
  "listPrice": 287040,
  "bedrooms": 4,
  "bathrooms": 3,
  "squareFeet": 2494,
  "yearBuilt": 1971,
  "propertyType": "Single Family Home",
  "propertyStatus": "Price Reduced",
  "listingPeriod": "Extended",
  "fhaFinancing": "IE (Insured Escrow)",
  "listDate": "2026-07-14",
  "bidOpenDate": "2026-07-16",
  "bidDeadlineDate": "2026-11-25",
  "eligibleBidders": "All Bidders",
  "bidderTypes": ["Investor", "Owner Occupant", "Nonprofit", "Government Agency"],
  "specialProgram100Down": true,
  "latitude": 29.5572,
  "longitude": -95.1306,
  "thumbnailUrl": "https://res.cloudinary.com/yardi/image/upload/.../Front_73825875.png",
  "imageUrls": ["https://res.cloudinary.com/yardi/image/upload/.../Front_73825875.png"],
  "sourceSearchUrl": "https://www.hudhomestore.gov/searchresult?citystate=Houston%2C+TX",
  "scrapedAt": "2026-07-16T00:00:00.000Z"
}
```

HUD controls inventory and can remove or update records at any time.

### Monitor new and changed HUD listings

Use an Apify schedule to run the same state or city search daily.

The stable `caseNumber` field makes change detection straightforward:

- a new case number means a newly observed listing;
- a missing case number may mean inventory was removed;
- the same case number with a new price or deadline means the listing changed.

For production monitoring, store the prior dataset in your database or compare datasets with an automation platform.

### Tips for best results

- Start with one city and `maxItems: 25`.
- Use a two-letter state code for broader coverage.
- Search overlapping locations freely; duplicates are removed.
- Use exact HUD labels in array filters.
- Keep concurrency between 1 and 3 for large scheduled sweeps.
- Omit proxy configuration unless your network needs it.
- Treat a valid empty dataset as “no current matching inventory,” not necessarily an error.
- Check run logs when every source search fails.

### Integrations and automation workflows

**HUD listings → Google Sheets**

Append affordable listings to a shared acquisitions sheet for underwriting.

**HUD listings → Slack or Discord**

Send a message when a new case number appears or a bid deadline changes.

**HUD listings → Make or Zapier**

Create a CRM lead, map task, or broker follow-up for every qualified property.

**Scheduled state monitor**

Run each morning and compare case number, list price, status, and deadline with the previous run.

**Dataset webhook → data warehouse**

Load normalized property records into BigQuery, Snowflake, PostgreSQL, or an internal deal platform.

### API usage with Node.js

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/hud-home-store-foreclosure-listings-scraper').call({
  locations: ['Houston, TX'],
  maxItems: 25,
});

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

The call waits for completion and returns the run metadata.

### Use the Apify API with Python

```python
import os
from apify_client import ApifyClient

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/hud-home-store-foreclosure-listings-scraper').call(
    run_input={'locations': ['TX'], 'maxItems': 100}
)
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

Use asynchronous client methods when integrating into an async service.

### Use the Apify API with cURL

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~hud-home-store-foreclosure-listings-scraper/runs?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"locations":["Houston, TX"],"maxItems":25}'
```

Read the run's `defaultDatasetId`, then download its items through the Dataset API.

### Use with AI agents via MCP

HUD Home Store Foreclosure Listings Scraper is available to AI assistants through the [Model Context Protocol](https://docs.apify.com/platform/integrations/mcp).

For Claude Code:

```bash
claude mcp add --transport http apify "https://mcp.apify.com?tools=automation-lab/hud-home-store-foreclosure-listings-scraper"
```

For Claude Desktop, Cursor, or VS Code:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=automation-lab/hud-home-store-foreclosure-listings-scraper"
    }
  }
}
```

Your client will request Apify authentication when first connected.

Try asking specific example prompts such as:

- “Use `automation-lab/hud-home-store-foreclosure-listings-scraper` to find current HUD homes in Houston under $250,000.”
- “Find three-bedroom Texas HUD listings open to owner occupants and sort them by bid deadline.”
- “Create a daily monitor for new HUD case numbers and price reductions in my target state.”

### Reliability and error handling

Each source request has three bounded attempts with incremental backoff.

A normal source response with no inventory produces zero records successfully.

A response missing HUD's expected embedded data is treated as extraction failure.

If every requested search fails, the run exits non-zero instead of silently reporting success.

If one search fails but another succeeds, the run preserves useful results and logs the failed URL.

### Limitations

- Inventory is limited to what HUD Home Store publishes publicly.
- Some city or ZIP searches legitimately have no active properties.
- HUD may omit optional fields for individual homes.
- Filters use current source labels and do not infer missing values.
- The Actor does not open property detail pages or submit bids.
- Bidding eligibility should always be confirmed with HUD and a qualified broker.
- Search behavior can change when HUD updates its website.

### Legality: Is it legal to scrape HUD Home Store?

This Actor extracts publicly accessible government property-listing data without logging in or bypassing access controls.

Scraping public information is generally lawful in many jurisdictions, but your use of the data may be subject to website terms, fair-housing rules, privacy law, and other obligations.

Use reasonable run frequency, collect only data needed for a legitimate purpose, and do not use housing data for unlawful discrimination.

You are responsible for complying with applicable law and HUD requirements.

### FAQ

**How fast is the HUD foreclosure scraper?**

A city search usually completes in seconds because the Actor reads server-rendered data without launching a browser. Multiple locations run with conservative parallelism.

**How much does one run cost?**

The run starts at $0.005 plus the tier-specific fee for each unique listing saved. A Bronze run saving 100 listings costs about $0.0106.

**Does HUD provide an official public API key?**

No key is needed for this workflow. The Actor reads the same public listing data served by HUD Home Store's anonymous search page.

**Why did my location return no results?**

HUD may have no current inventory matching that city or ZIP. Try a two-letter state search and remove filters to distinguish no inventory from an overly narrow query.

**Why is an optional field missing?**

HUD does not publish every attribute for every property. Missing values are omitted rather than replaced with inaccurate guesses.

**Can this Actor place a bid?**

No. It supports research and monitoring only. Bid submission, login, favorites, and email/share features are deliberately out of scope.

**Can I use a copied HUD URL?**

Yes. Add an official HTTPS `/searchresult` URL containing the `citystate` query parameter to `searchUrls`.

### Related real-estate scrapers

Build a broader property-data workflow with other Automation Labs Actors:

- [Auction.com Foreclosure Listings Scraper](https://apify.com/automation-lab/auction-com-foreclosure-listings-scraper) — private auction and REO inventory.
- [Zillow Scraper](https://apify.com/automation-lab/zillow-scraper) — residential listing and property data.
- [Realtor.com Scraper](https://apify.com/automation-lab/realtor-com-scraper) — residential search records.
- [Redfin Scraper](https://apify.com/automation-lab/redfin-scraper) — market and listing research.
- [Google Maps Scraper](https://apify.com/automation-lab/google-maps-scraper) — local broker and service-provider discovery.

Use HUD Home Store Foreclosure Listings Scraper when you specifically need official HUD-owned inventory and bidder-window data.

### Support

For a reproducible support request, include:

- the Actor run URL;
- the exact input used;
- the location or HUD search URL;
- the expected case number, if known;
- whether the source page currently shows that property.

Do not include passwords, private account cookies, or bid information.

# Actor input Schema

## `locations` (type: `array`):

Enter US locations as City, ST, a two-letter state code, or ZIP code. State searches are best for complete scheduled inventory sweeps.

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

Paste public https://www.hudhomestore.gov/searchresult URLs containing the citystate parameter.

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

Stop after saving this many unique listings across all searches.

## `minPrice` (type: `integer`):

Keep listings at or above this USD list price.

## `maxPrice` (type: `integer`):

Keep listings at or below this USD list price.

## `minBedrooms` (type: `number`):

Keep listings with at least this many bedrooms. Missing values fail closed.

## `minBathrooms` (type: `number`):

Keep listings with at least this many bathrooms. Decimal values such as 2.1 are supported.

## `propertyTypes` (type: `array`):

Exact HUD property types, for example Single Family Home or Condo.

## `listingPeriods` (type: `array`):

Exact HUD listing periods, for example Exclusive or Extended.

## `eligibleBidders` (type: `array`):

Keep listings open to any selected bidder type, such as Investor, Owner Occupant, Nonprofit, or Government Agency.

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

Number of HUD searches fetched at once. Keep this conservative for the public government site.

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

Optional Apify proxy or custom proxy configuration. Direct HTTP is used when omitted.

## Actor input object example

```json
{
  "locations": [
    "Houston, TX"
  ],
  "maxItems": 10,
  "maxConcurrency": 3
}
```

# Actor output Schema

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

No description

# 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 = {
    "locations": [
        "Houston, TX"
    ],
    "maxItems": 10,
    "maxConcurrency": 3
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/hud-home-store-foreclosure-listings-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 = {
    "locations": ["Houston, TX"],
    "maxItems": 10,
    "maxConcurrency": 3,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/hud-home-store-foreclosure-listings-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 '{
  "locations": [
    "Houston, TX"
  ],
  "maxItems": 10,
  "maxConcurrency": 3
}' |
apify call automation-lab/hud-home-store-foreclosure-listings-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=automation-lab/hud-home-store-foreclosure-listings-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "HUD Home Store Foreclosure Listings Scraper",
        "description": "Extract current HUD-owned foreclosure and REO listings with prices, property facts, FHA financing, bidder eligibility, bid windows, coordinates, and photos. Search by city, state, ZIP, or HUD URL. Export and schedule without a login or API key.",
        "version": "0.1",
        "x-build-id": "QwK0u9bKQBoJRTd2z"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~hud-home-store-foreclosure-listings-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-hud-home-store-foreclosure-listings-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~hud-home-store-foreclosure-listings-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-hud-home-store-foreclosure-listings-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~hud-home-store-foreclosure-listings-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-hud-home-store-foreclosure-listings-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": {
                    "locations": {
                        "title": "📍 Locations",
                        "type": "array",
                        "description": "Enter US locations as City, ST, a two-letter state code, or ZIP code. State searches are best for complete scheduled inventory sweeps.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "searchUrls": {
                        "title": "HUD Home Store search URLs",
                        "type": "array",
                        "description": "Paste public https://www.hudhomestore.gov/searchresult URLs containing the citystate parameter.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxItems": {
                        "title": "Maximum listings",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Stop after saving this many unique listings across all searches.",
                        "default": 25
                    },
                    "minPrice": {
                        "title": "Minimum list price",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Keep listings at or above this USD list price."
                    },
                    "maxPrice": {
                        "title": "Maximum list price",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Keep listings at or below this USD list price."
                    },
                    "minBedrooms": {
                        "title": "Minimum bedrooms",
                        "minimum": 0,
                        "type": "number",
                        "description": "Keep listings with at least this many bedrooms. Missing values fail closed."
                    },
                    "minBathrooms": {
                        "title": "Minimum bathrooms",
                        "minimum": 0,
                        "type": "number",
                        "description": "Keep listings with at least this many bathrooms. Decimal values such as 2.1 are supported."
                    },
                    "propertyTypes": {
                        "title": "Property types",
                        "type": "array",
                        "description": "Exact HUD property types, for example Single Family Home or Condo.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "listingPeriods": {
                        "title": "Listing periods",
                        "type": "array",
                        "description": "Exact HUD listing periods, for example Exclusive or Extended.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "eligibleBidders": {
                        "title": "Eligible bidder types",
                        "type": "array",
                        "description": "Keep listings open to any selected bidder type, such as Investor, Owner Occupant, Nonprofit, or Government Agency.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxConcurrency": {
                        "title": "Maximum concurrency",
                        "minimum": 1,
                        "maximum": 10,
                        "type": "integer",
                        "description": "Number of HUD searches fetched at once. Keep this conservative for the public government site.",
                        "default": 3
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Optional Apify proxy or custom proxy configuration. Direct HTTP is used when omitted."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```