# HUD Multifamily Assisted Properties Scraper (`automation-lab/hud-multifamily-assisted-properties-scraper`) Actor

Extract HUD-assisted multifamily properties, contracts, units, risk signals, locations, and management contacts from public HUD ArcGIS data.

- **URL**: https://apify.com/automation-lab/hud-multifamily-assisted-properties-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Real estate
- **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.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## HUD Multifamily Assisted Properties Scraper

Extract HUD-assisted multifamily property records from the public HUD Open Data ArcGIS FeatureServer. The actor returns normalized property, location, unit-count, subsidy, contract-expiration, risk, REAC, and management-contact fields in a clean Apify dataset.

Use it when you need a repeatable HUD assisted-housing data export for market research, affordable-housing investment screening, compliance monitoring, vendor lead generation, or internal real-estate analytics.

### What does HUD Multifamily Assisted Properties Scraper do?

This actor queries HUD's public `MULTIFAMILY_PROPERTIES_ASSISTED` ArcGIS layer and saves one dataset row per assisted multifamily property.

It supports filters for:

- 🗺️ State, city, and ZIP code
- 🏢 Property category and client group
- ✅ Active assistance and subsidized flags
- ⚠️ HUD watch-list and troubled status signals
- 📊 Minimum assisted/total unit counts
- 📅 Contract expiration date windows
- 🧾 Optional raw HUD attributes for audit workflows
- 📍 Optional ArcGIS geometry

### Who is it for?

This HUD assisted property scraper is useful for several buyer personas:

- 🏘️ Affordable-housing investors looking for assisted multifamily inventory by market
- 🧑‍💼 Property managers and vendors building management-company contact lists
- 🏛️ Govcon and compliance teams monitoring HUD risk, watch-list, and REAC signals
- 📈 Real-estate analysts comparing assisted units across counties, ZIP codes, or cities
- 🧪 Housing researchers who need a clean export from HUD Open Data without ArcGIS scripting
- 🔁 Data teams scheduling recurring HUD property refreshes into a warehouse or spreadsheet

### Why use it?

HUD's ArcGIS endpoint is public, but using it directly requires knowing ArcGIS REST query syntax, date formats, pagination, field names, and sentinel values. This actor handles those details and returns buyer-friendly field names.

Benefits:

- No login or API key required for the target data source
- HTTP/API implementation, so runs are fast and inexpensive
- Normalized booleans, dates, numbers, and nulls
- Real estate and compliance fields selected from a much wider HUD schema
- Optional `raw` object when you need the original HUD attributes
- Apify dataset export to JSON, CSV, Excel, Google Sheets, Make, Zapier, or your API client

### Data source

The actor uses HUD Open Data / ArcGIS:

- HUD Open Data page: `HUD::multifamily-assisted-properties`
- Layer: `MULTIFAMILY_PROPERTIES_ASSISTED`
- Source type: public ArcGIS FeatureServer
- Entity type: assisted multifamily properties

The actor does not scrape private user accounts, tenant data, or authenticated HUD systems.

### Data fields

Typical output fields include:

| Field | Description |
| --- | --- |
| `propertyId` | HUD property identifier |
| `propertyName` | Property name from HUD |
| `category` | HUD property category |
| `clientGroupName` | HUD client group/program label |
| `address`, `city`, `state`, `zip`, `county` | Normalized location fields |
| `latitude`, `longitude` | Coordinates from HUD fields |
| `totalUnits`, `assistedUnits`, `availableUnits` | Unit-count signals |
| `hasActiveAssistance`, `isSubsidized`, `isSection8` | Program/status flags |
| `isOnWatchList`, `troubledCode`, `riskCategory` | Risk/compliance signals |
| `reacLastInspectionScore`, `reacLastInspectionDate` | REAC inspection summary |
| `contracts` | Contract numbers, program types, units, expiration dates |
| `managementAgent`, `managementContactName`, `managementPhone`, `managementEmail` | Management contact fields when HUD provides them |
| `lastUpdated` | HUD last-update date |
| `sourceUrl`, `scrapedAt` | Source and run audit fields |

### Example output

```json
{
  "propertyId": "800000001",
  "propertyName": "Example Assisted Apartments",
  "category": "Multifamily",
  "clientGroupName": "Section 8",
  "address": "123 Main St, Los Angeles, CA, 90001",
  "city": "Los Angeles",
  "state": "CA",
  "zip": "90001",
  "totalUnits": 120,
  "assistedUnits": 80,
  "hasActiveAssistance": true,
  "isSubsidized": true,
  "isOnWatchList": false,
  "reacLastInspectionScore": "82",
  "contracts": [
    {
      "contractNumber": "CA39XXXX001",
      "programType": "Section 8",
      "units": 80,
      "expirationDate": "2027-06-30",
      "rentToFmrRatio": 0.98
    }
  ],
  "sourceUrl": "https://hudgis-hud.opendata.arcgis.com/datasets/HUD::multifamily-assisted-properties/about",
  "scrapedAt": "2026-07-01T00:00:00.000Z"
}
````

### Input options

The input schema is designed for both small checks and bulk exports.

```json
{
  "states": ["CA"],
  "city": "Los Angeles",
  "hasActiveAssistance": true,
  "maxItems": 100
}
```

Common input fields:

- `states` — list of two-letter state codes
- `city` — exact standardized city name
- `zipCodes` — list of five-digit ZIP codes
- `propertyNameQuery` — property-name substring search
- `propertyCategories` — exact HUD category names
- `clientGroupNames` — exact HUD client group names
- `hasActiveAssistance` — filter active assistance indicator
- `isSubsidized` — filter subsidized indicator
- `isOnWatchList` — filter HUD watch-list indicator
- `isTroubled` — include or exclude non-empty troubled code values
- `minAssistedUnits` — minimum assisted units
- `minTotalUnits` — minimum total units
- `contractExpirationFrom` and `contractExpirationTo` — contract date window
- `maxItems` — maximum properties to save
- `includeGeometry` — include raw ArcGIS geometry
- `includeRaw` — include full raw HUD attributes

### How to scrape HUD assisted multifamily properties

1. Open the actor on Apify.
2. Choose a state or city for a small first run.
3. Keep `maxItems` at 100 while validating your filters.
4. Run the actor.
5. Review the dataset table and export JSON, CSV, Excel, or API results.
6. Increase `maxItems` for larger market exports.
7. Schedule the actor if you need recurring HUD data refreshes.

### How much does it cost to extract HUD assisted multifamily properties?

This actor uses pay-per-event pricing:

- A small start event per run
- A per-property event for each saved HUD property record

The actor is HTTP/API based and does not use a browser or proxy by default, so typical compute costs are low. Exact Apify billing depends on your plan tier and the current actor pricing shown on the Apify Store page.

### Tips for best results

- Start with a state or city filter before exporting nationwide data.
- Use `minAssistedUnits` to focus on larger properties.
- Use `contractExpirationFrom` and `contractExpirationTo` for renewal or preservation workflows.
- Enable `includeRaw` only when you need the original HUD attribute names; it makes each record much larger.
- Enable `includeGeometry` if you need ArcGIS point geometry in addition to latitude/longitude.
- If you get zero results, remove filters one by one to find which condition is too narrow.

### Contract expiration monitoring

Contract-expiration filters are useful for:

- Preservation opportunity lists
- Renewal monitoring
- Outreach to owners or management agents
- Market studies of expiring assisted units
- Internal alerts for properties with near-term subsidy changes

The actor checks both first and second HUD contract expiration fields when applying the date window.

### Risk and compliance monitoring

The actor includes fields such as watch-list status, troubled code, OPIIS risk category, integrated risk score category, REAC score, and REAC inspection date. These fields can help compliance teams prioritize follow-up review.

Always verify critical compliance decisions against official HUD systems and documents. This actor packages public source data; it is not legal, financial, or compliance advice.

### Integrations

You can connect results to:

- Google Sheets for lightweight market lists
- Airtable for property pipeline tracking
- Make or Zapier for no-code workflows
- Snowflake, BigQuery, or Postgres through Apify integrations
- Internal CRMs for vendor/property-manager outreach
- BI dashboards for affordable-housing market analytics

### API usage

#### Node.js

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/hud-multifamily-assisted-properties-scraper').call({
  states: ['CA'],
  city: 'Los Angeles',
  hasActiveAssistance: true,
  maxItems: 100,
});

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

#### Python

```python
from apify_client import ApifyClient
import os

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/hud-multifamily-assisted-properties-scraper').call(run_input={
    'states': ['NY'],
    'hasActiveAssistance': True,
    'maxItems': 100,
})
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items[:3])
```

#### cURL

```bash
curl "https://api.apify.com/v2/acts/automation-lab~hud-multifamily-assisted-properties-scraper/runs?token=$APIFY_TOKEN" \
  -H 'Content-Type: application/json' \
  -d '{"states":["TX"],"hasActiveAssistance":true,"maxItems":100}'
```

### MCP integration

Use this actor from MCP-compatible tools through Apify MCP.

Claude Code CLI example:

```bash
claude mcp add apify-hud-properties --transport http --url "https://mcp.apify.com/?tools=automation-lab/hud-multifamily-assisted-properties-scraper"
```

Claude Desktop example:

```json
{
  "mcpServers": {
    "apify": {
      "command": "npx",
      "args": [
        "-y",
        "@apify/actors-mcp-server",
        "--actors",
        "automation-lab/hud-multifamily-assisted-properties-scraper"
      ],
      "env": {
        "APIFY_TOKEN": "your-apify-token"
      }
    }
  }
}
```

MCP URL pattern:

```text
https://mcp.apify.com/?tools=automation-lab/hud-multifamily-assisted-properties-scraper
```

Example prompts:

- "Extract HUD assisted multifamily properties in Los Angeles with active assistance."
- "Find Texas HUD assisted properties with at least 150 total units."
- "Export properties with contracts expiring before the end of 2027."

### Legality and responsible use

This actor accesses public HUD Open Data through a public ArcGIS REST endpoint. Use the data responsibly and comply with applicable laws, HUD terms, privacy rules, fair-housing rules, and your organization's compliance policies.

Do not use contact fields for spam, harassment, or discriminatory targeting.

### Limitations

- HUD can change field definitions, update cadence, or ArcGIS service behavior.
- Some management contact fields are blank for some records.
- `includeRaw` exposes many source fields and may require downstream schema handling.
- Contract fields are summarized from source columns; they are not a separate contract-history dataset.
- The actor returns records available in the public layer at run time.

### Troubleshooting

#### Why did my run return zero properties?

Your filters may be too narrow. Remove optional filters such as city, ZIP, category, or contract dates and try a state-only run first.

#### Why are some fields null?

HUD uses nullable and sentinel values in the source data. The actor converts empty strings, `N/A`, and `-4` style sentinel values to `null` so downstream exports are easier to use.

#### Why is the raw output so wide?

`includeRaw` adds the full HUD attributes object, which has hundreds of fields. Disable it for normal exports.

### Related scrapers

Other Automation Labs actors may be useful for adjacent real-estate and public-record workflows:

- https://apify.com/automation-lab/google-maps-lead-finder
- https://apify.com/automation-lab/zillow-scraper
- https://apify.com/automation-lab/realtor-scraper

### FAQ

#### Can I scrape all HUD assisted multifamily properties nationwide?

Yes. Leave geography filters empty and raise `maxItems`. For first tests, use a smaller `maxItems` value to confirm the output shape.

#### Does this require a proxy?

No. The source is a public ArcGIS FeatureServer and the actor is HTTP/API based.

#### Does this include tenant-level data?

No. The actor outputs property-level public HUD fields, not tenant records.

#### Can I schedule recurring exports?

Yes. Use Apify schedules to run the actor daily, weekly, or monthly and export the dataset to your preferred integration.

#### Can I get the original HUD fields?

Yes. Set `includeRaw` to `true` to include the full raw attributes object for each property.

### Changelog

- Initial version: public HUD ArcGIS extraction with geography, program, risk, unit-count, and contract-expiration filters.

# Actor input Schema

## `states` (type: `array`):

Two-letter state codes to include. Leave empty for nationwide results.

## `city` (type: `string`):

Optional city filter, matched against HUD's standardized city field.

## `zipCodes` (type: `array`):

Optional five-digit ZIP codes to include.

## `propertyNameQuery` (type: `string`):

Case-insensitive substring filter for HUD property names.

## `propertyCategories` (type: `array`):

Optional exact HUD property category names to include.

## `clientGroupNames` (type: `array`):

Optional exact HUD client group names/program labels to include.

## `hasActiveAssistance` (type: `boolean`):

Filter by HUD HAS\_ACTIVE\_ASSISTANCE\_IND. Leave unset to include all.

## `isSubsidized` (type: `boolean`):

Filter by HUD IS\_SUBSIDIZED\_IND. Leave unset to include all.

## `isOnWatchList` (type: `boolean`):

Filter by HUD IS\_ON\_WATCH\_LIST\_IND. Leave unset to include all.

## `isTroubled` (type: `boolean`):

True returns properties with a non-empty troubled code; false returns properties without one.

## `minAssistedUnits` (type: `integer`):

Only include properties with at least this many assisted units.

## `minTotalUnits` (type: `integer`):

Only include properties with at least this many total units.

## `contractExpirationFrom` (type: `string`):

Include properties whose first or second contract expiration date is on/after this date (YYYY-MM-DD).

## `contractExpirationTo` (type: `string`):

Include properties whose first or second contract expiration date is on/before this date (YYYY-MM-DD).

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

Maximum HUD property records to save. Increase for bulk exports after testing filters.

## `includeGeometry` (type: `boolean`):

Adds raw ArcGIS geometry to each dataset item when available.

## `includeRaw` (type: `boolean`):

Adds the full raw ArcGIS attributes object for audit/debug workflows. This makes output much wider.

## Actor input object example

```json
{
  "states": [
    "CA"
  ],
  "city": "Los Angeles",
  "hasActiveAssistance": true,
  "maxItems": 20,
  "includeGeometry": false,
  "includeRaw": false
}
```

# 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 = {
    "states": [
        "CA"
    ],
    "city": "Los Angeles",
    "hasActiveAssistance": true,
    "maxItems": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/hud-multifamily-assisted-properties-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 = {
    "states": ["CA"],
    "city": "Los Angeles",
    "hasActiveAssistance": True,
    "maxItems": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/hud-multifamily-assisted-properties-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 '{
  "states": [
    "CA"
  ],
  "city": "Los Angeles",
  "hasActiveAssistance": true,
  "maxItems": 20
}' |
apify call automation-lab/hud-multifamily-assisted-properties-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "HUD Multifamily Assisted Properties Scraper",
        "description": "Extract HUD-assisted multifamily properties, contracts, units, risk signals, locations, and management contacts from public HUD ArcGIS data.",
        "version": "0.1",
        "x-build-id": "HbORJnWFTItFlwsUm"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~hud-multifamily-assisted-properties-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-hud-multifamily-assisted-properties-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-multifamily-assisted-properties-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-hud-multifamily-assisted-properties-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-multifamily-assisted-properties-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-hud-multifamily-assisted-properties-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": {
                    "states": {
                        "title": "States",
                        "type": "array",
                        "description": "Two-letter state codes to include. Leave empty for nationwide results.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "city": {
                        "title": "City",
                        "type": "string",
                        "description": "Optional city filter, matched against HUD's standardized city field."
                    },
                    "zipCodes": {
                        "title": "ZIP codes",
                        "type": "array",
                        "description": "Optional five-digit ZIP codes to include.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "propertyNameQuery": {
                        "title": "Property name contains",
                        "type": "string",
                        "description": "Case-insensitive substring filter for HUD property names."
                    },
                    "propertyCategories": {
                        "title": "Property categories",
                        "type": "array",
                        "description": "Optional exact HUD property category names to include.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "clientGroupNames": {
                        "title": "Client group names",
                        "type": "array",
                        "description": "Optional exact HUD client group names/program labels to include.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "hasActiveAssistance": {
                        "title": "Has active assistance",
                        "type": "boolean",
                        "description": "Filter by HUD HAS_ACTIVE_ASSISTANCE_IND. Leave unset to include all."
                    },
                    "isSubsidized": {
                        "title": "Is subsidized",
                        "type": "boolean",
                        "description": "Filter by HUD IS_SUBSIDIZED_IND. Leave unset to include all."
                    },
                    "isOnWatchList": {
                        "title": "On HUD watch list",
                        "type": "boolean",
                        "description": "Filter by HUD IS_ON_WATCH_LIST_IND. Leave unset to include all."
                    },
                    "isTroubled": {
                        "title": "Troubled status",
                        "type": "boolean",
                        "description": "True returns properties with a non-empty troubled code; false returns properties without one."
                    },
                    "minAssistedUnits": {
                        "title": "Minimum assisted units",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only include properties with at least this many assisted units."
                    },
                    "minTotalUnits": {
                        "title": "Minimum total units",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only include properties with at least this many total units."
                    },
                    "contractExpirationFrom": {
                        "title": "Expiration from",
                        "type": "string",
                        "description": "Include properties whose first or second contract expiration date is on/after this date (YYYY-MM-DD)."
                    },
                    "contractExpirationTo": {
                        "title": "Expiration to",
                        "type": "string",
                        "description": "Include properties whose first or second contract expiration date is on/before this date (YYYY-MM-DD)."
                    },
                    "maxItems": {
                        "title": "Maximum properties",
                        "minimum": 1,
                        "maximum": 50000,
                        "type": "integer",
                        "description": "Maximum HUD property records to save. Increase for bulk exports after testing filters.",
                        "default": 100
                    },
                    "includeGeometry": {
                        "title": "Include ArcGIS geometry",
                        "type": "boolean",
                        "description": "Adds raw ArcGIS geometry to each dataset item when available.",
                        "default": false
                    },
                    "includeRaw": {
                        "title": "Include raw HUD attributes",
                        "type": "boolean",
                        "description": "Adds the full raw ArcGIS attributes object for audit/debug workflows. This makes output much wider.",
                        "default": false
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
