# Probate & Foreclosure Leads Scraper — US County Records (`memo23/probate-foreclosure-leads-scraper`) Actor

Collect US distressed-property leads from government open-data portals — probate, foreclosure, sheriff sale, tax lien, tax sale. Unified schema with case numbers, addresses, parcel IDs, parties, sale dates & amounts. Filter by state, county, date, equity. No proxies. JSON/CSV out.

- **URL**: https://apify.com/memo23/probate-foreclosure-leads-scraper.md
- **Developed by:** [Muhamed Didovic](https://apify.com/memo23) (community)
- **Categories:** Real estate, AI, Agents
- **Stats:** 3 total users, 2 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.00 / 1,000 distressed-property records

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## Probate & Foreclosure Leads Scraper — US County Records

Aggregate **US distressed-property events** — probate filings, foreclosures, sheriff sales, tax liens, and tax sales — from official government open-data portals into **one unified, normalized leads schema**. Case numbers, property addresses, parcel/APN identifiers, party names, filing & sale dates, and dollar amounts, ready for direct-mail, skip-tracing, and CRM pipelines.

![How it works](https://raw.githubusercontent.com/muhamed-didovic/muhamed-didovic.github.io/main/assets/how-it-works-probate-foreclosure.png)

---

### Why this actor

- **Five event types, one schema.** `probate`, `foreclosure`, `sheriff_sale`, `tax_lien`, `tax_sale` — every record lands in the same canonical shape regardless of which county published it, so your downstream pipeline is written once.
- **Curated + discovered sources.** A hand-verified registry of county/city datasets (Prince George's County foreclosures, NYC tax-lien sale lists, Cook County tax sales, New Orleans sheriff sales, Baton Rouge adjudicated property, NY State tax warrants, and more) is paged first; optional live discovery then sweeps the whole open-data network for newly published datasets.
- **Noise-filtered.** Government catalogs are messy — a "probate" search returns *probation* statistics, a "tax sale" search returns *sales-tax* revenue tables. A two-gate classifier (keyword + column-shape validation) kills aggregate statistics and off-topic datasets so you only pay for real per-property records.
- **Official data, zero fragility.** Pure JSON APIs from government portals — no browser, no proxies, no anti-bot arms race. Runs are fast, cheap, and stable.
- **Raw row preserved.** Every canonical record carries the original source row under `raw`, so nothing the county published is ever lost in normalization.
- **Clean input schema.** No forced "tell us your use case" fields — set your filters and run.

### Use cases

- **Real-estate investors** — pull distressed-property leads by state/county for direct-mail and cold-call campaigns.
- **Wholesalers** — find motivated sellers (tax-delinquent, pre-foreclosure, estate situations) before they hit the MLS.
- **Title companies & attorneys** — monitor new foreclosure filings, sheriff sales, and tax-lien lists in specific counties.
- **Probate researchers & heir-finders** — track probate case records and missing-heir registries.
- **PropTech / analytics teams** — build distress-scoring models on a unified, geocoded national event feed.

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `eventTypes` | array | all five | Any of `probate`, `foreclosure`, `sheriff_sale`, `tax_lien`, `tax_sale` |
| `states` | array | all | Two-letter state codes, e.g. `["MD", "IL", "NY"]` |
| `counties` | array | all | County names, case-insensitive, e.g. `["Cook", "Orleans"]` |
| `dateFrom` / `dateTo` | string | — | Keep events whose sale date (or filing date) falls in this range (`YYYY-MM-DD`) |
| `minEstimatedEquity` | integer | 0 | Keep records where `estimatedValue − mortgageBalance ≥` this value (needs both figures in source data) |
| `onlyOwnerOccupied` | boolean | false | Drop records without a verified owner-occupied / homestead flag |
| `maxItems` | integer | 100 | Total record budget across all sources |
| `maxItemsPerDataset` | integer | 0 (off) | Cap per source dataset so one big county doesn't eat the whole budget |
| `liveDiscovery` | boolean | true | Sweep the open-data network for datasets beyond the curated registry |
| `socrataAppToken` | string | — | Optional free app token for higher API rate limits on large pulls |
| `maxConcurrency` | integer | 6 | Parallel dataset fetches |

#### Example input

```json
{
    "eventTypes": ["foreclosure", "tax_lien"],
    "states": ["MD", "NY", "VA"],
    "dateFrom": "2025-01-01",
    "maxItems": 1000,
    "maxItemsPerDataset": 200
}
````

### Output schema

One row per distressed-property event:

```json
{
    "eventType": "foreclosure",
    "state": "MD",
    "county": "Prince George's",
    "caseNumber": null,
    "filingDate": "2009-09-10",
    "saleDate": null,
    "parties": {
        "decedent": null,
        "executor": null,
        "attorney": null,
        "plaintiff": null,
        "defendant": null,
        "owner": null
    },
    "property": {
        "address": "8825 East Grove RD",
        "city": "Upper Marlboro",
        "zip": "20774",
        "parcelId": "06-0606582",
        "propertyType": null,
        "latitude": 38.84915,
        "longitude": -76.85252
    },
    "financial": {
        "estimatedValue": null,
        "mortgageBalance": null,
        "lienAmount": null,
        "taxesDue": null,
        "openingBid": null,
        "winningBid": null
    },
    "estimatedEquity": null,
    "ownerOccupied": null,
    "status": null,
    "source": {
        "domain": "data.princegeorgescountymd.gov",
        "datasetId": "cni6-nr5g",
        "datasetName": "County Foreclosures",
        "datasetUrl": "https://data.princegeorgescountymd.gov/resource/cni6-nr5g"
    },
    "raw": { "taxaccountnumber": "06-0606582", "street_address": "8825 East Grove RD", "...": "..." }
}
```

A tax-warrant example with case + party + status populated:

```json
{
    "eventType": "tax_lien",
    "state": "NY",
    "county": "STEUBEN",
    "caseNumber": "E-042193055-W001-1",
    "filingDate": "2024-09-18",
    "parties": { "owner": "ROLAND L ROBINSON" },
    "property": { "address": "5799 CLARK RD", "city": "ALFRED STATION" },
    "status": "Closed",
    "source": { "domain": "data.ny.gov", "datasetId": "v7ua-z23v", "datasetName": "New York State Tax Warrants" }
}
```

#### Key output fields

| Field | Meaning |
|---|---|
| `eventType` | One of the five distressed-property event classes |
| `state` / `county` | Jurisdiction tags derived from the publishing portal + per-row county columns |
| `caseNumber` | Court case / docket / warrant / recording number where the source provides one |
| `filingDate` / `saleDate` | Normalized to `YYYY-MM-DD` from whatever format the county publishes |
| `parties.*` | Decedent, executor, attorney, plaintiff, defendant, owner — populated per event type |
| `property.*` | Address, city, zip, parcel/APN (incl. composed NYC borough-block-lot), type, lat/lng |
| `financial.*` | Assessed/estimated value, mortgage balance, lien amount, taxes due, opening/winning bid |
| `estimatedEquity` | `estimatedValue − mortgageBalance` when both figures exist in the source |
| `source.*` | Exactly which government dataset the record came from — full auditability |
| `raw` | The unmodified source row |

### How it works

1. **Registry load** — a curated, hand-verified list of county/city distressed-property datasets is loaded first (each one probed and quality-checked before inclusion).
2. **Live discovery** (optional) — cross-portal catalog queries sweep the whole US open-data network for additional probate/foreclosure/sheriff-sale/tax-lien/tax-sale datasets.
3. **Classification** — a two-gate filter (positive/negative keyword patterns + column-shape validation) rejects probation statistics, sales-tax tables, budget reports, and aggregate counts.
4. **Paging** — each surviving dataset is paged through its official JSON API with a global sliding-window concurrency cap.
5. **Normalization** — heterogeneous county field names (`parcel_number` / `apn` / `pin` / `folio` / `taxaccountnumber`…) are mapped onto the canonical schema; the raw row is preserved; jurisdiction tags, ISO dates, and equity estimates are derived; your filters are applied; one row per event is pushed.

### What makes this different

- **Aggregate junk is filtered out.** Several "foreclosure" datasets on government portals are monthly per-county *counts*, not per-property records. Those never reach your dataset (and you're never charged for them).
- **Verified seed registry, not just blind discovery** — baseline coverage doesn't depend on catalog-search luck.
- **Composed parcel IDs** — NYC borough-block-lot columns become a single usable `parcelId`.
- **Honest tri-state owner-occupancy** — `true` / `false` / `null` (unknown), never a fake `false` for "Unavailable".

### Notes & limitations

- **Coverage follows open data.** Only jurisdictions that publish these records on open-data portals are included — coverage is strongest for foreclosures, tax liens, and tax sales in counties like Prince George's (MD), Cook (IL), NYC, New Orleans, Norfolk/Richmond (VA), East Baton Rouge (LA), Howard (MD), Riverside & Sonoma (CA), plus state-level NY tax warrants.
- **Probate is the thinnest type.** Most *current* probate dockets live on court-system websites, not open-data portals; the probate datasets that do exist here are limited (e.g. Santa Clara County probate case records, Ramsey County missing-heirs). If you need deep probate coverage for a specific county, contact me — see Support below.
- **`estimatedEquity` needs both figures.** Many counties publish neither an assessed value nor a mortgage balance; a non-zero `minEstimatedEquity` filter will legitimately shrink results.
- **Some sources are archival** (e.g. Cook County recorder foreclosures 2011–2015). Use `dateFrom` to keep only fresh events.

### FAQ

**Do I need proxies or a login?**
No. Everything comes from official public JSON APIs. For very large pulls (10k+ records), add a free `socrataAppToken` to raise the rate limit.

**Why is a field `null` on some rows?**
Each county publishes a different subset of fields. The normalizer maps whatever exists; missing source fields stay `null` rather than being fabricated. Check `raw` to see exactly what the county provided.

**Can I get records for a county that isn't covered?**
If that county publishes to an open-data portal, live discovery will usually pick it up. If it doesn't, I can build a dedicated county scraper — see Support.

**How fresh is the data?**
As fresh as the county keeps it. Several sources update daily (Norfolk delinquent taxes, NY tax warrants); others update on the county's tax-sale calendar. `source.datasetUrl` lets you verify update cadence.

**Is this legal to use?**
The actor reads public government open-data APIs published explicitly for reuse. Your obligations around outreach (e.g. do-not-call, CAN-SPAM, state-specific solicitation rules for pre-foreclosure homeowners) are your own — see the Disclaimer.

### Support

- **Bugs / feature requests** — open an issue on the actor's Issues tab
- **Custom exports, new counties, or tailored fields** — drop a note via the Apify Store contact form
- **Other actors** — see my Apify Store profile for the rest of the catalog (290+ production scrapers)

### Additional services

Need skip-tracing, owner contact enrichment, or a custom county/court source wired in? Contact me through the Apify Store profile — custom builds are my day job.

### ⚠️ Disclaimer

This Actor is an independent tool and is **not affiliated with, endorsed by, or sponsored by** any government agency, county, or open-data platform vendor. All trademarks mentioned are the property of their respective owners.

The Actor accesses only **publicly available government open-data APIs** published for public reuse — no login bypass, no authenticated endpoints, no CAPTCHA solving.

Users are responsible for:

- Complying with each portal's terms of use and the applicable open-data licenses
- Following all laws governing outreach to distressed-property owners (including state pre-foreclosure solicitation statutes, TCPA/do-not-call, and CAN-SPAM)
- Handling personal data in the records (owner names, addresses) in line with applicable data-protection laws
- Independently verifying records against official court/county sources before acting on them — open-data feeds can lag or contain errors

### SEO Keywords

probate leads scraper, foreclosure leads scraper, pre-foreclosure list, sheriff sale list, tax lien leads, tax sale properties, tax delinquent property list, distressed property leads, motivated seller leads, county records scraper, government open data scraper, probate real estate leads, foreclosure data API, tax lien sale list NYC, cook county tax sale, adjudicated property, real estate investor leads, wholesaling leads, skip tracing input list, off-market property leads

# Actor input Schema

## `eventTypes` (type: `array`):

Distressed-property event types to collect. Leave empty to collect all five.

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

Restrict results to these US states. Leave empty for all states with available open data.

## `counties` (type: `array`):

Restrict to specific counties by name (e.g. `Cook`, `King`, `Orleans`). Case-insensitive, matched against both the portal's jurisdiction and per-row county columns. Leave empty for all.

## `dateFrom` (type: `string`):

Keep events whose sale date (or filing date when no sale date exists) is on/after this date. Leave empty to disable.

## `dateTo` (type: `string`):

Keep events whose sale date (or filing date when no sale date exists) is on/before this date. Leave empty to disable.

## `minEstimatedEquity` (type: `integer`):

Only include records where `estimatedValue - mortgageBalance` is at least this value. Requires both figures in the source data, so non-zero values reduce coverage. 0 disables the filter.

## `onlyOwnerOccupied` (type: `boolean`):

Drop records where owner-occupancy cannot be verified from the source data (owner-occupied / homestead flags).

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

Maximum number of distressed-property records to return across all source datasets.

## `maxItemsPerDataset` (type: `integer`):

Cap per single source dataset so one large county doesn't consume the whole `maxItems` budget. 0 = no cap.

## `liveDiscovery` (type: `boolean`):

In addition to the curated registry of verified county datasets, run live discovery queries across the whole open-data network to pick up newly published datasets. Slightly slower start, wider coverage.

## `socrataAppToken` (type: `string`):

Optional free app token that raises the open-data API rate limits — recommended for large pulls (10k+ records). Get one at evergreen.data.socrata.com/signup.

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

How many source datasets are paged in parallel.

## Actor input object example

```json
{
  "eventTypes": [],
  "states": [],
  "counties": [],
  "minEstimatedEquity": 0,
  "onlyOwnerOccupied": false,
  "maxItems": 100,
  "maxItemsPerDataset": 0,
  "liveDiscovery": true,
  "maxConcurrency": 6
}
```

# 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 = {
    "eventTypes": [],
    "states": [],
    "counties": [],
    "dateFrom": "",
    "dateTo": "",
    "minEstimatedEquity": 0,
    "maxItems": 100,
    "maxItemsPerDataset": 0
};

// Run the Actor and wait for it to finish
const run = await client.actor("memo23/probate-foreclosure-leads-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 = {
    "eventTypes": [],
    "states": [],
    "counties": [],
    "dateFrom": "",
    "dateTo": "",
    "minEstimatedEquity": 0,
    "maxItems": 100,
    "maxItemsPerDataset": 0,
}

# Run the Actor and wait for it to finish
run = client.actor("memo23/probate-foreclosure-leads-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 '{
  "eventTypes": [],
  "states": [],
  "counties": [],
  "dateFrom": "",
  "dateTo": "",
  "minEstimatedEquity": 0,
  "maxItems": 100,
  "maxItemsPerDataset": 0
}' |
apify call memo23/probate-foreclosure-leads-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Probate & Foreclosure Leads Scraper — US County Records",
        "description": "Collect US distressed-property leads from government open-data portals — probate, foreclosure, sheriff sale, tax lien, tax sale. Unified schema with case numbers, addresses, parcel IDs, parties, sale dates & amounts. Filter by state, county, date, equity. No proxies. JSON/CSV out.",
        "version": "0.0",
        "x-build-id": "j0DV2r3ohcVtq3sK0"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/memo23~probate-foreclosure-leads-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-memo23-probate-foreclosure-leads-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/memo23~probate-foreclosure-leads-scraper/runs": {
            "post": {
                "operationId": "runs-sync-memo23-probate-foreclosure-leads-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/memo23~probate-foreclosure-leads-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-memo23-probate-foreclosure-leads-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": {
                    "eventTypes": {
                        "title": "Event types",
                        "type": "array",
                        "description": "Distressed-property event types to collect. Leave empty to collect all five.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "probate",
                                "foreclosure",
                                "sheriff_sale",
                                "tax_lien",
                                "tax_sale"
                            ],
                            "enumTitles": [
                                "Probate",
                                "Foreclosure",
                                "Sheriff Sale",
                                "Tax Lien",
                                "Tax Sale"
                            ]
                        }
                    },
                    "states": {
                        "title": "States",
                        "type": "array",
                        "description": "Restrict results to these US states. Leave empty for all states with available open data.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "AL",
                                "AK",
                                "AZ",
                                "AR",
                                "CA",
                                "CO",
                                "CT",
                                "DE",
                                "DC",
                                "FL",
                                "GA",
                                "HI",
                                "ID",
                                "IL",
                                "IN",
                                "IA",
                                "KS",
                                "KY",
                                "LA",
                                "ME",
                                "MD",
                                "MA",
                                "MI",
                                "MN",
                                "MS",
                                "MO",
                                "MT",
                                "NE",
                                "NV",
                                "NH",
                                "NJ",
                                "NM",
                                "NY",
                                "NC",
                                "ND",
                                "OH",
                                "OK",
                                "OR",
                                "PA",
                                "RI",
                                "SC",
                                "SD",
                                "TN",
                                "TX",
                                "UT",
                                "VT",
                                "VA",
                                "WA",
                                "WV",
                                "WI",
                                "WY"
                            ],
                            "enumTitles": [
                                "Alabama",
                                "Alaska",
                                "Arizona",
                                "Arkansas",
                                "California",
                                "Colorado",
                                "Connecticut",
                                "Delaware",
                                "District of Columbia",
                                "Florida",
                                "Georgia",
                                "Hawaii",
                                "Idaho",
                                "Illinois",
                                "Indiana",
                                "Iowa",
                                "Kansas",
                                "Kentucky",
                                "Louisiana",
                                "Maine",
                                "Maryland",
                                "Massachusetts",
                                "Michigan",
                                "Minnesota",
                                "Mississippi",
                                "Missouri",
                                "Montana",
                                "Nebraska",
                                "Nevada",
                                "New Hampshire",
                                "New Jersey",
                                "New Mexico",
                                "New York",
                                "North Carolina",
                                "North Dakota",
                                "Ohio",
                                "Oklahoma",
                                "Oregon",
                                "Pennsylvania",
                                "Rhode Island",
                                "South Carolina",
                                "South Dakota",
                                "Tennessee",
                                "Texas",
                                "Utah",
                                "Vermont",
                                "Virginia",
                                "Washington",
                                "West Virginia",
                                "Wisconsin",
                                "Wyoming"
                            ]
                        }
                    },
                    "counties": {
                        "title": "Counties",
                        "type": "array",
                        "description": "Restrict to specific counties by name (e.g. `Cook`, `King`, `Orleans`). Case-insensitive, matched against both the portal's jurisdiction and per-row county columns. Leave empty for all.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "dateFrom": {
                        "title": "Date from (YYYY-MM-DD)",
                        "type": "string",
                        "description": "Keep events whose sale date (or filing date when no sale date exists) is on/after this date. Leave empty to disable."
                    },
                    "dateTo": {
                        "title": "Date to (YYYY-MM-DD)",
                        "type": "string",
                        "description": "Keep events whose sale date (or filing date when no sale date exists) is on/before this date. Leave empty to disable."
                    },
                    "minEstimatedEquity": {
                        "title": "Min estimated equity (USD)",
                        "type": "integer",
                        "description": "Only include records where `estimatedValue - mortgageBalance` is at least this value. Requires both figures in the source data, so non-zero values reduce coverage. 0 disables the filter.",
                        "default": 0
                    },
                    "onlyOwnerOccupied": {
                        "title": "Only owner-occupied",
                        "type": "boolean",
                        "description": "Drop records where owner-occupancy cannot be verified from the source data (owner-occupied / homestead flags).",
                        "default": false
                    },
                    "maxItems": {
                        "title": "Max items",
                        "type": "integer",
                        "description": "Maximum number of distressed-property records to return across all source datasets.",
                        "default": 100
                    },
                    "maxItemsPerDataset": {
                        "title": "Max items per source dataset",
                        "type": "integer",
                        "description": "Cap per single source dataset so one large county doesn't consume the whole `maxItems` budget. 0 = no cap.",
                        "default": 0
                    },
                    "liveDiscovery": {
                        "title": "Live cross-portal discovery",
                        "type": "boolean",
                        "description": "In addition to the curated registry of verified county datasets, run live discovery queries across the whole open-data network to pick up newly published datasets. Slightly slower start, wider coverage.",
                        "default": true
                    },
                    "socrataAppToken": {
                        "title": "Socrata app token (optional)",
                        "type": "string",
                        "description": "Optional free app token that raises the open-data API rate limits — recommended for large pulls (10k+ records). Get one at evergreen.data.socrata.com/signup."
                    },
                    "maxConcurrency": {
                        "title": "Max concurrent dataset fetches",
                        "minimum": 1,
                        "maximum": 20,
                        "type": "integer",
                        "description": "How many source datasets are paged in parallel.",
                        "default": 6
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
