# US Mobile Home & Manufactured Housing Park Leads Scraper (`scrapesage/mobile-home-park-leads`) Actor

Scrape US mobile home parks & manufactured housing communities from official state registries: park name, address, owner & operator name + phone + mailing address (absentee-owner signal), lots, occupancy, amenities, inspections & lead score. Filter by state, size & owner. Monitoring mode.

- **URL**: https://apify.com/scrapesage/mobile-home-park-leads.md
- **Developed by:** [Scrape Sage](https://apify.com/scrapesage) (community)
- **Categories:** Lead generation, Real estate, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $7.00 / 1,000 mobile home park lead 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.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

## US Mobile Home & Manufactured Housing Park Leads Scraper

Build the **most complete list of US mobile home parks / manufactured housing communities** — straight from **official state and county registries**, not a stale directory. Every record is a ready-to-use **B2B lead**: park name, full address, **owner & operator name, phone and mailing address**, site capacity & occupancy, amenities, utilities, inspection history — and a derived **lead score** that surfaces the best acquisition and sales targets first.

No login, no cookies, no API key — fast, reliable extraction from public government open-data portals, with an optional **monitoring mode** that returns only new or changed parks on each run.

### Why this scraper?

Generic Google-Maps and listings scrapers give you a pin and a name. Mobile home park investors, suppliers and software vendors need the **owner behind the park** — who to call, where to mail the offer, how many lots, who's absentee. This actor reads the **registries the parks are legally required to file with** and ships the richest park dataset in the category.

| Data | Maps/listing scrapers | This actor |
|---|---|---|
| Park name & full address | ✅ | ✅ |
| **Owner / operator name** | ❌ | ✅ (where the registry publishes it) |
| **Owner phone** | ❌ | ✅ NY |
| **Owner mailing address** (for offer letters) | ❌ | ✅ NY |
| **Absentee-owner detection** | ❌ | ✅ |
| Site capacity (lots) & occupancy | ❌ | ✅ |
| Amenities & utilities provided | ❌ | ✅ |
| Inspection history & violations | ❌ | ✅ NY |
| Park size category & lead score | ❌ | ✅ |
| Manufactured-housing dealers & installers | ❌ | ✅ (optional) |
| Official source, deduped & merged across registries | ❌ | ✅ |
| Monitoring mode (only new/changed) | ❌ | ✅ |

### Use cases

- **Park acquisition & syndication** — the registries publish **owner name, phone and mailing address**. Filter to **absentee owners** and **larger parks**, sort by lead score, and run your direct-mail / cold-call acquisition campaign off a clean, deduped list.
- **Supplier & service prospecting** — sell into parks: submetering & utilities, propane, laundry/vending, road & grounds maintenance, manufactured-home dealers, insurance, brokers, lenders. Filter by amenities, utilities and size.
- **Property-management & PropTech sales** — target communities by size and state for management software, rent collection, resident apps and compliance tools.
- **Market & investment research** — map the manufactured-housing universe by state, size, occupancy and ownership structure (individual vs. LLC/fund).
- **Manufactured-home dealers & installers** — pull the certified dealer, retailer, manufacturer, installer and mechanic list as its own B2B lead set.

### How to use

1. [Sign up for Apify](https://console.apify.com/sign-up) — the free plan is enough to try this actor.
2. Open the **US Mobile Home & Manufactured Housing Park Leads Scraper**, choose **What to scrape** (Parks by default), and optionally filter by state, size, owner or amenities.
3. Click **Start** and watch results stream into the dataset table.
4. **Export** as JSON, CSV, Excel, XML, or RSS — or pull results programmatically via the [Apify API](https://docs.apify.com/api/v2).

### Input

```json
{
    "outputType": "parks",
    "states": ["NY", "OR"],
    "minSiteCapacity": 50,
    "absenteeOwnerOnly": true,
    "sortBy": "leadScore",
    "maxResults": 500
}
````

- **outputType** *(default `parks`)* — `parks` (communities — the lead), `businesses` (manufactured-housing dealers/installers), or `all`.
- **states** — 2-letter codes. Sources cover **NY** (statewide, richest — owner contacts), **OR** (statewide), **TX** (Austin), **WA** (Pierce County), **LA** (Baton Rouge). Empty = all.
- **minSiteCapacity / maxSiteCapacity / parkSizeCategory** — target deal size (`small` <50, `medium` 50-149, `large` 150+).
- **absenteeOwnerOnly / entityOwnedOnly** — the highest-converting acquisition targets.
- **withOwnerPhoneOnly / withOwnerNameOnly / withAnyPhoneOnly / withGeoOnly** — contactability filters.
- **amenitiesInclude / utilitiesProvided** — require specific amenities/utilities (e.g. `["Pool","Clubhouse"]`, `["Water","Sewer"]`).
- **minOccupancyRate / hasViolationsOnly / inspectedAfter / registeredAfterYear** — value-add, compliance and freshness filters.
- **sortBy** — `leadScore`, `sizeLargest`, `occupancy`, `newest`, `name`, `state`, `source`.
- **monitorMode / monitorKey** — output only new/changed parks across runs (see below).
- **maxResults / maxResultsPerState**, **deduplicateResults**, **includeRawFields**, **socrataAppToken**, **proxyConfiguration** — see tooltips.

### Output

By default you get **one clean table of parks** — every column applies to every row. A park record (`recordType: "park"`):

```json
{
    "recordType": "park",
    "parkName": "Breckenridge Village",
    "sourceState": "NY",
    "ownerName": "Garden Homes Fund",
    "operatorName": null,
    "contactName": "Diane Adamis",
    "ownerPhone": "(518) 925-7800",
    "parkPhone": "(518) 925-7800",
    "primaryPhone": "(518) 925-7800",
    "isAbsenteeOwner": true,
    "isEntityOwned": true,
    "ownerMailingAddress": "100 Executive Blvd, Southington, CT 06489",
    "street": "1 Old Town Rd",
    "city": "Selkirk",
    "state": "NY",
    "zip": "12158",
    "county": "Albany",
    "fullAddress": "1 Old Town Rd, Selkirk, NY, 12158",
    "latitude": 42.473,
    "longitude": -73.81,
    "siteCapacity": 70,
    "sitesOccupancy": 69,
    "vacantSites": 1,
    "occupancyRate": 98.6,
    "parkSizeCategory": "medium",
    "amenities": ["Garbage/trash", "Road maintenance", "Sewer", "Water"],
    "utilitiesProvided": ["Water", "Sewer"],
    "lastInspected": "2025-02-27",
    "criticalViolations": 0,
    "registrationYear": 2025,
    "currentlyRegistered": true,
    "leadScore": 87,
    "leadSignals": ["Owner phone on record", "Owner mailing address", "Absentee / out-of-area owner", "Mid-size park (70 lots)", "Master-metered utilities"],
    "sources": ["NY Manufactured Home Park Registry", "NY Historic Manufactured Home Park Registry", "NY Mobile Home Park Inspections"],
    "scrapedAt": "2026-06-21T12:00:00.000Z"
}
```

A business record (`recordType: "business"`) carries `businessName`, `certificationType` (Certified/Limited Retailer, Manufacturer, Installer, Mechanic), `certificationNumber`, `certificationExpiration`, `city`, `state` and a lead score.

#### What to expect (field coverage)

These are **organizer-filed government records**, so a field is populated only where the agency publishes it for that park. Verified across the live sources:

| Field | Coverage |
|---|---|
| Park name, address, state, county | ✅ ~100% |
| Site capacity (lots) | ✅ NY & OR; varies elsewhere |
| Owner / operator name | ✅ NY (registry); operator on inspections |
| **Owner phone + mailing address** | ✅ NY (from the historic registry) |
| Amenities & utilities | ✅ NY |
| Inspection history & violations | ✅ NY |
| Coordinates | ✅ NY inspections, WA, LA |

A blank field means the source doesn't publish that signal for that park — not that scraping failed. Nothing is dropped, so you always get the richest record available, **merged across every registry** that lists the park.

### Automate & schedule

Run this actor on autopilot and pull results into your own stack:

- **[Apify API](https://docs.apify.com/api/v2)** — start runs, fetch datasets, and manage schedules over REST.
- **[apify-client for JavaScript](https://docs.apify.com/api/client/js/)** and **[apify-client for Python](https://docs.apify.com/api/client/python/)** — official SDKs.
- **[Schedules](https://docs.apify.com/platform/schedules)** — run it weekly/monthly with **monitoring mode** to capture newly-registered parks and owner/operator changes as fresh leads.
- **[Webhooks](https://docs.apify.com/platform/integrations/webhooks)** — trigger downstream actions (CRM import, Slack alert, mail-merge) the moment a run finishes.

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

const client = new ApifyClient({ token: 'MY_APIFY_TOKEN' });

const run = await client.actor('scrapesage/mobile-home-park-leads').call({
    states: ['NY'],
    absenteeOwnerOnly: true,
    minSiteCapacity: 50,
    sortBy: 'leadScore',
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(`Got ${items.length} mobile home parks`);
```

**Monitoring mode vs. Apify Schedules.** They're complementary, not the same thing. An [Apify Schedule](https://docs.apify.com/platform/schedules) decides *when* the actor runs; **monitorMode** decides *what it outputs* — it remembers every park it has seen in a key-value store and emits only the ones that are **new or changed** (owner, capacity, status, registration year or inspection). Schedule the run daily/weekly and turn on `monitorMode` to get a clean feed of only fresh leads.

### Integrate with any app

Connect the dataset to 5,000+ apps — no code required:

- **[Make](https://docs.apify.com/platform/integrations/make)** — multi-step automation scenarios.
- **[Zapier](https://docs.apify.com/platform/integrations/zapier)** — push new park leads straight into your CRM.
- **[Slack](https://docs.apify.com/platform/integrations/slack)** — get notified when a monitored state adds a new park.
- **[Google Drive / Sheets](https://docs.apify.com/platform/integrations/drive)** — auto-export every run to a spreadsheet.
- **[Airbyte](https://docs.apify.com/platform/integrations/airbyte)** — pipe results into your data warehouse.
- **[GitHub](https://docs.apify.com/platform/integrations/github)** — trigger runs from commits or releases.

### Use with AI assistants (MCP)

The output is clean, LLM-ready JSON. Call this actor from Claude, ChatGPT, or any agent framework through the **[Apify MCP server](https://docs.apify.com/platform/integrations/mcp)** — ask your assistant to "find every absentee-owned mobile home park in New York with 50+ lots, an owner phone and a mailing address, sorted by lead score" and let it run the scraper for you.

### More scrapers from scrapesage

Build a complete **real-estate & B2B lead-gen stack**:

- **[US Property Records Scraper](https://apify.com/scrapesage/us-property-records-scraper)** — parcels, owners & deeds — skip-trace any park's owner.
- **[US Business Formation Scraper](https://apify.com/scrapesage/us-business-formation-scraper)** — newly-registered LLCs (the entities that buy & hold parks).
- **[HUD Multifamily & Affordable Housing Scraper](https://apify.com/scrapesage/hud-multifamily-scraper)** — assisted, insured & LIHTC properties with management contacts.
- **[US Building Permits Scraper](https://apify.com/scrapesage/us-building-permits-scraper)** — construction & development activity as intent signals.
- **[Crexi Scraper](https://apify.com/scrapesage/crexi-scraper)** — commercial real-estate listings, including mobile home parks for sale.
- **[US UCC Filings Scraper](https://apify.com/scrapesage/us-ucc-filings-scraper)** — secured-loan & equipment-finance filings (financing-intent leads).
- **[SBA Loan Leads Scraper](https://apify.com/scrapesage/sba-loan-leads-scraper)** — small businesses financed under SBA 7(a) & 504.
- **[Website Contact Scraper](https://apify.com/scrapesage/website-contact-scraper)** — find emails & socials to enrich any lead list.

### Tips

- **Acquisition lists**: set `absenteeOwnerOnly: true`, `withOwnerPhoneOnly: true` (or `withOwnerNameOnly`) and `minSiteCapacity: 50`, then sort by `leadScore` to reach the highest-converting park owners first.
- **Value-add deals**: set `minOccupancyRate` low (e.g. under 80) and `utilitiesProvided: ["Water","Sewer"]` to find master-metered parks with lease-up upside.
- **Newly-registered parks**: set `registeredAfterYear` to the current year and sort by `newest`.
- **Dealers & installers**: set `outputType: "businesses"` for a clean manufactured-housing supplier list.
- **Recurring monitoring**: combine [Schedules](https://docs.apify.com/platform/schedules) with `monitorMode` to capture only parks added or changed since the last run.

### FAQ

**Where does the data come from?** From official government open-data portals: the New York [Manufactured Home Park Registry](https://data.ny.gov/) and inspection data, the [Oregon Manufactured Dwelling Parks](https://data.oregon.gov/) registry, the City of Austin mobile-home operating licenses, Pierce County (WA) and Baton Rouge (LA) open data. More states are added over time.

**Does it need an API key or login?** No. Every source is public — no key, no login, no browser. An optional Socrata app token can raise rate limits but isn't required.

**Does it include owner contact details?** Yes, where the registry publishes them. New York's registry provides owner/operator **name, phone and mailing address**, which is what makes absentee-owner detection and direct-mail acquisition possible. We never fabricate contact data — everything in the record is straight from the source.

**What is an "absentee owner"?** A park whose registered owner mailing address is in a different city or state from the park itself — historically the most receptive to acquisition offers. The actor flags these with `isAbsenteeOwner`.

**Why do some parks have more fields than others?** Each state publishes different fields. New York is the richest (owner contacts, amenities, occupancy, inspections); other states publish name, address and capacity. The actor merges every registry that lists a park into one record.

**Can I export to Google Sheets, CSV, or Excel?** Yes — one click in the dataset view, or automatically on every run via the [Google Drive integration](https://docs.apify.com/platform/integrations/drive).

**Is scraping this data legal?** This actor collects publicly available U.S. government data. You're responsible for using it in compliance with applicable laws (e.g. TCPA/CAN-SPAM for outreach) and each agency's terms.

### Need help?

Open an issue on the actor's **Issues** tab, or visit the [Apify help center](https://help.apify.com/). Feature requests — including additional states — are welcome; this actor is actively maintained.

# Actor input Schema

## `outputType` (type: `string`):

parks = mobile home / manufactured housing communities (the lead). businesses = manufactured-housing dealers, retailers, installers & mechanics (NY certified entities). all = both in one dataset (filter on the recordType field).

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

Keep only parks/businesses in these US states (2-letter codes). Sources currently cover NY (statewide, richest — owner contacts), OR (statewide), TX (Austin), WA (Pierce County), LA (Baton Rouge). Leave empty for all.

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

Keep only parks in these counties (case-insensitive, e.g. \["Albany","Suffolk"]). Optional.

## `cities` (type: `array`):

Keep only parks in these cities (case-insensitive exact match). Optional.

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

Keep only parks in these 5-digit ZIP codes. Optional.

## `nameQuery` (type: `string`):

Keep only parks/businesses whose name contains this text (case-insensitive). Optional.

## `minSiteCapacity` (type: `integer`):

Keep only parks with at least this many lots/sites — target larger acquisition deals.

## `maxSiteCapacity` (type: `integer`):

Keep only parks with at most this many lots/sites.

## `parkSizeCategory` (type: `array`):

Keep only parks of these sizes: small (<50 lots), medium (50-149), large (150+).

## `minOccupancyRate` (type: `integer`):

Keep only parks with at least this occupancy percentage (where capacity & occupancy are reported).

## `parkType` (type: `array`):

Keep only parks of these types (e.g. \["55+"], \["Family"]). Reported by some states (Oregon). Optional.

## `amenitiesInclude` (type: `array`):

Keep only parks offering ALL of these amenities (e.g. \["Pool","Clubhouse","Laundry"]). Matches against the amenities list. Optional.

## `utilitiesProvided` (type: `array`):

Keep only parks where the community provides ALL of these utilities (e.g. \["Water","Sewer"]) — submetering / value-add signal. Optional.

## `absenteeOwnerOnly` (type: `boolean`):

Keep only parks whose owner mailing address is outside the park's city/state — the highest-converting acquisition targets.

## `entityOwnedOnly` (type: `boolean`):

Keep only parks owned by a company / LLC / trust / fund (vs. an individual).

## `withOwnerNameOnly` (type: `boolean`):

Keep only parks with a named owner or operator.

## `withOwnerPhoneOnly` (type: `boolean`):

Keep only parks with an owner/operator phone number (NY).

## `withAnyPhoneOnly` (type: `boolean`):

Keep only parks with an owner or park phone number.

## `withGeoOnly` (type: `boolean`):

Keep only parks with latitude/longitude.

## `activeOnly` (type: `boolean`):

Drop parks marked closed / not currently registered. On by default.

## `hasViolationsOnly` (type: `boolean`):

Keep only parks with one or more inspection violations on record (NY).

## `inspectedAfter` (type: `string`):

Keep only parks last inspected on or after this date (NY).

## `registeredAfterYear` (type: `integer`):

Keep only parks whose latest registration / license year is at or after this year — surface newly-registered parks.

## `includeInspections` (type: `boolean`):

Fetch NY mobile home park inspections and merge operator, violations & coordinates into the park records.

## `includeOwnerEnrichment` (type: `boolean`):

Fetch the NY historic registry to enrich parks with owner/operator phone and mailing address (absentee-owner detection). Adds one extra source fetch.

## `minLeadScore` (type: `integer`):

Keep only records with a lead score at or above this value (0-100).

## `sortBy` (type: `string`):

Ordering of results before the result cap is applied.

## `maxResults` (type: `integer`):

Maximum number of records to output.

## `maxResultsPerState` (type: `integer`):

Optional per-state output cap for a balanced multi-state list.

## `monitorMode` (type: `boolean`):

Remember records across runs in a key-value store and output only parks/businesses that are new or whose owner, capacity, status, registration year or inspection changed since the last run. Great on a schedule. Independent of Apify Schedules.

## `monitorKey` (type: `string`):

Name the monitor memory so different filter setups track separately (e.g. 'ny-large-parks'). Optional.

## `deduplicateResults` (type: `boolean`):

Merge records that describe the same park across sources (registry + historic + inspection). On by default.

## `includeRawFields` (type: `boolean`):

Attach the original source row(s) under sourceFields for full transparency.

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

Optional Socrata application token to raise rate limits. Not required — all sources work keyless.

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

Proxy settings. Not required — the official open-data portals are reachable directly from Apify.

## Actor input object example

```json
{
  "outputType": "parks",
  "states": [],
  "parkSizeCategory": [],
  "absenteeOwnerOnly": false,
  "entityOwnedOnly": false,
  "withOwnerNameOnly": false,
  "withOwnerPhoneOnly": false,
  "withAnyPhoneOnly": false,
  "withGeoOnly": false,
  "activeOnly": true,
  "hasViolationsOnly": false,
  "includeInspections": true,
  "includeOwnerEnrichment": true,
  "sortBy": "leadScore",
  "maxResults": 1000,
  "monitorMode": false,
  "deduplicateResults": true,
  "includeRawFields": true,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

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

All scraped mobile home park and manufactured-housing business records in the default dataset.

# 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": [],
    "parkSizeCategory": [],
    "maxResults": 1000
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapesage/mobile-home-park-leads").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": [],
    "parkSizeCategory": [],
    "maxResults": 1000,
}

# Run the Actor and wait for it to finish
run = client.actor("scrapesage/mobile-home-park-leads").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": [],
  "parkSizeCategory": [],
  "maxResults": 1000
}' |
apify call scrapesage/mobile-home-park-leads --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=scrapesage/mobile-home-park-leads",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "US Mobile Home & Manufactured Housing Park Leads Scraper",
        "description": "Scrape US mobile home parks & manufactured housing communities from official state registries: park name, address, owner & operator name + phone + mailing address (absentee-owner signal), lots, occupancy, amenities, inspections & lead score. Filter by state, size & owner. Monitoring mode.",
        "version": "0.1",
        "x-build-id": "tPgUa6uVIr2a9ZXob"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapesage~mobile-home-park-leads/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapesage-mobile-home-park-leads",
                "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/scrapesage~mobile-home-park-leads/runs": {
            "post": {
                "operationId": "runs-sync-scrapesage-mobile-home-park-leads",
                "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/scrapesage~mobile-home-park-leads/run-sync": {
            "post": {
                "operationId": "run-sync-scrapesage-mobile-home-park-leads",
                "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": {
                    "outputType": {
                        "title": "What to scrape",
                        "enum": [
                            "parks",
                            "businesses",
                            "all"
                        ],
                        "type": "string",
                        "description": "parks = mobile home / manufactured housing communities (the lead). businesses = manufactured-housing dealers, retailers, installers & mechanics (NY certified entities). all = both in one dataset (filter on the recordType field).",
                        "default": "parks"
                    },
                    "states": {
                        "title": "States",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Keep only parks/businesses in these US states (2-letter codes). Sources currently cover NY (statewide, richest — owner contacts), OR (statewide), TX (Austin), WA (Pierce County), LA (Baton Rouge). Leave empty for all.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "counties": {
                        "title": "Counties",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Keep only parks in these counties (case-insensitive, e.g. [\"Albany\",\"Suffolk\"]). Optional.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "cities": {
                        "title": "Cities",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Keep only parks in these cities (case-insensitive exact match). Optional.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "zipCodes": {
                        "title": "ZIP codes",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Keep only parks in these 5-digit ZIP codes. Optional.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "nameQuery": {
                        "title": "Name contains",
                        "type": "string",
                        "description": "Keep only parks/businesses whose name contains this text (case-insensitive). Optional."
                    },
                    "minSiteCapacity": {
                        "title": "Min site capacity (lots)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Keep only parks with at least this many lots/sites — target larger acquisition deals."
                    },
                    "maxSiteCapacity": {
                        "title": "Max site capacity (lots)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Keep only parks with at most this many lots/sites."
                    },
                    "parkSizeCategory": {
                        "title": "Park size category",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Keep only parks of these sizes: small (<50 lots), medium (50-149), large (150+).",
                        "items": {
                            "type": "string"
                        }
                    },
                    "minOccupancyRate": {
                        "title": "Min occupancy rate (%)",
                        "minimum": 0,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Keep only parks with at least this occupancy percentage (where capacity & occupancy are reported)."
                    },
                    "parkType": {
                        "title": "Park type",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Keep only parks of these types (e.g. [\"55+\"], [\"Family\"]). Reported by some states (Oregon). Optional.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "amenitiesInclude": {
                        "title": "Required amenities",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Keep only parks offering ALL of these amenities (e.g. [\"Pool\",\"Clubhouse\",\"Laundry\"]). Matches against the amenities list. Optional.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "utilitiesProvided": {
                        "title": "Utilities provided",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Keep only parks where the community provides ALL of these utilities (e.g. [\"Water\",\"Sewer\"]) — submetering / value-add signal. Optional.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "absenteeOwnerOnly": {
                        "title": "Absentee owners only",
                        "type": "boolean",
                        "description": "Keep only parks whose owner mailing address is outside the park's city/state — the highest-converting acquisition targets.",
                        "default": false
                    },
                    "entityOwnedOnly": {
                        "title": "Entity-owned only",
                        "type": "boolean",
                        "description": "Keep only parks owned by a company / LLC / trust / fund (vs. an individual).",
                        "default": false
                    },
                    "withOwnerNameOnly": {
                        "title": "Has owner/operator name",
                        "type": "boolean",
                        "description": "Keep only parks with a named owner or operator.",
                        "default": false
                    },
                    "withOwnerPhoneOnly": {
                        "title": "Has owner phone",
                        "type": "boolean",
                        "description": "Keep only parks with an owner/operator phone number (NY).",
                        "default": false
                    },
                    "withAnyPhoneOnly": {
                        "title": "Has any phone",
                        "type": "boolean",
                        "description": "Keep only parks with an owner or park phone number.",
                        "default": false
                    },
                    "withGeoOnly": {
                        "title": "Has coordinates",
                        "type": "boolean",
                        "description": "Keep only parks with latitude/longitude.",
                        "default": false
                    },
                    "activeOnly": {
                        "title": "Active / currently registered only",
                        "type": "boolean",
                        "description": "Drop parks marked closed / not currently registered. On by default.",
                        "default": true
                    },
                    "hasViolationsOnly": {
                        "title": "Has inspection violations only",
                        "type": "boolean",
                        "description": "Keep only parks with one or more inspection violations on record (NY).",
                        "default": false
                    },
                    "inspectedAfter": {
                        "title": "Inspected after (YYYY-MM-DD)",
                        "type": "string",
                        "description": "Keep only parks last inspected on or after this date (NY)."
                    },
                    "registeredAfterYear": {
                        "title": "Registered in or after year",
                        "type": "integer",
                        "description": "Keep only parks whose latest registration / license year is at or after this year — surface newly-registered parks."
                    },
                    "includeInspections": {
                        "title": "Include NY inspection data",
                        "type": "boolean",
                        "description": "Fetch NY mobile home park inspections and merge operator, violations & coordinates into the park records.",
                        "default": true
                    },
                    "includeOwnerEnrichment": {
                        "title": "Include owner-contact enrichment",
                        "type": "boolean",
                        "description": "Fetch the NY historic registry to enrich parks with owner/operator phone and mailing address (absentee-owner detection). Adds one extra source fetch.",
                        "default": true
                    },
                    "minLeadScore": {
                        "title": "Minimum lead score",
                        "minimum": 0,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Keep only records with a lead score at or above this value (0-100)."
                    },
                    "sortBy": {
                        "title": "Sort by",
                        "enum": [
                            "leadScore",
                            "sizeLargest",
                            "occupancy",
                            "newest",
                            "name",
                            "state",
                            "source"
                        ],
                        "type": "string",
                        "description": "Ordering of results before the result cap is applied.",
                        "default": "leadScore"
                    },
                    "maxResults": {
                        "title": "Max results",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Maximum number of records to output."
                    },
                    "maxResultsPerState": {
                        "title": "Max results per state",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Optional per-state output cap for a balanced multi-state list."
                    },
                    "monitorMode": {
                        "title": "Monitor mode (only new/changed)",
                        "type": "boolean",
                        "description": "Remember records across runs in a key-value store and output only parks/businesses that are new or whose owner, capacity, status, registration year or inspection changed since the last run. Great on a schedule. Independent of Apify Schedules.",
                        "default": false
                    },
                    "monitorKey": {
                        "title": "Monitor key",
                        "type": "string",
                        "description": "Name the monitor memory so different filter setups track separately (e.g. 'ny-large-parks'). Optional."
                    },
                    "deduplicateResults": {
                        "title": "Deduplicate & merge",
                        "type": "boolean",
                        "description": "Merge records that describe the same park across sources (registry + historic + inspection). On by default.",
                        "default": true
                    },
                    "includeRawFields": {
                        "title": "Include raw source fields",
                        "type": "boolean",
                        "description": "Attach the original source row(s) under sourceFields for full transparency.",
                        "default": true
                    },
                    "socrataAppToken": {
                        "title": "Socrata app token (optional)",
                        "type": "string",
                        "description": "Optional Socrata application token to raise rate limits. Not required — all sources work keyless."
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Proxy settings. Not required — the official open-data portals are reachable directly from Apify.",
                        "default": {
                            "useApifyProxy": 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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
