# Propwire Scraper - Property Leads, Owners & Equity Data (`abotapi/propwire-property-leads-scraper`) Actor

Scrape Propwire.com: 157M+ US MLS & off-market properties with owner names, mailing addresses, equity, foreclosure and auction details, mortgages, transfers, owner portfolios, tax and full MLS records. Filter by lead type, property type, value, year built, sale date and MLS status.

- **URL**: https://apify.com/abotapi/propwire-property-leads-scraper.md
- **Developed by:** [Abot API](https://apify.com/abotapi) (community)
- **Stats:** 1 total users, 0 monthly users, 93.3% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.00 / 1,000 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.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## 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.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Propwire Scraper: Property Leads, Owners & Equity Data

Propwire Scraper turns Propwire into a lead-generation API for US real estate. Look up one address or APN, paste Propwire links, or sweep whole states with lead-type filters (absentee owners, pre-foreclosures, high equity, auctions, tired landlords and more, 41 flags in total). Every record carries the search-card fields (address, value, equity, beds/baths, size, MLS snapshot), and when Full property records is on, also the owner names and mailing address, ownership length, owner portfolio, foreclosure and auction details, mortgage and transfer history, tax assessments, parcel/zoning data and the full MLS record when one exists. Export the dataset to JSON, CSV or Excel, or read it straight through the API.

### Why This Scraper?

- **Three ways to find properties.** Address or APN lookup, pasted Propwire links (search or property pages), or a state/city/ZIP/county sweep with lead-type filters. No need to build search URLs by hand.
- **41 built-in lead-type flags.** Absentee owners, pre-foreclosures, high/low/negative equity, free and clear, auctions, bank-owned (REOs), vacant homes and lots, out-of-state owners, tired landlords, cash buyers, tax liens, tax dodgers, bankruptcies, divorces, pre-probates, zombie properties and more.
- **Full ownership and financial detail on demand.** Owner names and mailing address, ownership length, owner portfolio (properties owned, portfolio value and equity), foreclosure and auction details, current mortgages, mortgage and transfer history, tax assessments and exemptions, parcel/zoning and building specifications.
- **Nothing dropped.** The complete source payload for every record rides in `raw`, plus a stable Propwire link in `propwireUrl`, so no nested owner, portfolio or MLS object is ever whitelisted away.
- **Built for lead monitoring.** Recurring updates returns only new, updated and reappeared records on repeated runs of the same search, and Continue a previous run finishes one interrupted collection without re-billing rows it already returned.
- **Cost and size stay in your control.** Max records is the single limit that stops a run, and Max pages per search is a separate runaway guard on any one search walk.
- **A refused run fails loudly** instead of returning an empty dataset that looks like a successful scrape.

### Use Cases

- **Real estate wholesalers and investors:** build daily lead lists of absentee owners, pre-foreclosures and high-equity properties in a target market.
- **Landlord and portfolio outreach:** identify tired landlords, cash flow rentals and multi-property owners for acquisition or partnership outreach.
- **Skip tracing and direct mail:** pull owner names and mailing addresses for a filtered set of leads.
- **Foreclosure and auction deal sourcing:** track pre-foreclosure, auction and bank-owned flags with dates, trustee, lender and notice detail.
- **Market and appraisal research:** gather comparable sales, equity and tax-assessment data across a ZIP, city or county.
- **Recurring lead monitoring:** schedule the actor to return only the new or changed leads in a market, for daily or weekly outreach.

### Data You Get

> Sample shape: values are illustrative placeholders, not from a live record.

| Field | Example |
| --- | --- |
| `recordType` | `"property"` |
| `id` | `12345678` |
| `propwireUrl` | Propwire link to the property |
| `address` / `city` / `state` / `zip` | `"100 Main St"` / `"Anytown"` / `"FL"` / `"32000"` |
| `propertyType` | `"SFR"` (also `"CONDO"`, `"LAND"`, `"COMMERCIAL"`, more) |
| `bedrooms` / `bathrooms` | `3` / `2` |
| `buildingAreaSf` / `lotSizeSf` | `1650` / `6500` |
| `yearBuilt` | `1998` |
| `estimatedValue` / `estimatedEquity` / `estimatedEquityPercentage` | `344800` / `182400` / `53` |
| `lastSoldDate` / `lastSoldPrice` | `"2021-06-17"` / `250000` |
| `daysOnMarket` | `42` |
| `mlsListPrice` / `mlsStatus` | `325000` / `"ACTIVE"` |
| `leadTypes` | `["ABSENTEE_OWNER", "HIGH_EQUITY"]` |
| `ownerNames` / `ownerTypes` | `["SAMPLE JANE"]` / `["INDIVIDUAL"]` (when enabled) |
| `ownerOccupied` / `ownershipYears` | `false` / `5` (when enabled) |
| `ownerMailingAddress` | `"PO Box 1000, Sample Town, NJ 07000"` (when enabled) |
| `portfolioPropertiesOwned` / `portfolioValue` | `4` / `1240000` (when enabled) |
| `foreclosureActive` / `auctionDate` | `true` / `"2026-12-02"` (when enabled) |
| `apn` / `zoning` | `"12-34-56-78-90"` / `"R1"` (when enabled) |
| `taxAssessedValue` | `270000` (when enabled) |
| `imageUrl` / `photoCount` | cover photo URL / `28` |
| `detailFetched` | `true` when the full record was read for this row |
| `sourceType` | `"search"`, `"searchUrl"`, `"address"` or `"url"` |
| `changeType` | `"NEW"`, `"UPDATED"`, `"UNCHANGED"`, `"REAPPEARED"` or `"EXPIRED"` (Recurring updates only) |
| `raw` | the complete verbatim source payload: full owner, portfolio, foreclosure, mortgage, transfer, tax, parcel and MLS objects |

### How to Use

1. Fill in one of the three sections: **addresses or APNs**, **links**, or the **search filters** (states, cities/ZIPs/counties, lead types, property types, value, year built and more). Whichever you fill in wins, in that order.
2. Leave **Full property records** on (default) for owner, foreclosure, mortgage and tax detail, or turn it off for search-card fields only.
3. Set **Max records** and **Max pages per search** to control run size and cost, then click **Start**.
4. Export the dataset as JSON, CSV or Excel, or read it through the API.

**Address lookup (one full record per address):**

```json
{
  "addresses": ["1600 Example Ave, Orlando, FL 32801"],
  "addressMatchMode": "first",
  "fetchDetails": true
}
```

**Links mode (a pasted property link, or a search link walked forward):**

```json
{
  "startUrls": [
    "https://propwire.com/realestate/100-Sample-St-Anytown-FL/87654321/property-details"
  ],
  "fetchDetails": true
}
```

**Search filters, statewide pre-foreclosure sweep under $500k:**

```json
{
  "searchStates": ["FL"],
  "searchLeadTypes": ["preforeclosure", "high_equity"],
  "searchPropertyTypes": ["SFR", "CONDO"],
  "searchEstimatedValueMin": 100000,
  "searchEstimatedValueMax": 500000,
  "fetchDetails": true,
  "maxItems": 100
}
```

**Recurring updates, daily lead monitoring, only what changed:**

```json
{
  "searchStates": ["FL"],
  "searchLeadTypes": ["preforeclosure"],
  "incrementalMode": true,
  "stateKey": "daily-fl-leads",
  "maxItems": 0
}
```

#### Run it from your code

Python:

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")
run = client.actor("abotapi/propwire-property-leads-scraper").call(
    run_input={"searchStates": ["FL"], "searchLeadTypes": ["preforeclosure"], "maxItems": 50}
)
for record in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(record["address"], record["estimatedValue"])
```

JavaScript:

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

const client = new ApifyClient({ token: '<YOUR_APIFY_TOKEN>' });
const run = await client.actor('abotapi/propwire-property-leads-scraper').call({
  searchStates: ['FL'],
  searchLeadTypes: ['preforeclosure'],
  maxItems: 50,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
```

Or connect it to Make, Zapier, n8n, Google Sheets or webhooks from the **Integrations** tab.

#### Record depth and caps

**Full property records** (`fetchDetails`, on by default) reads each property's full record and is billed once per property as a separate charge on top of the per-record price; a refused detail read keeps the search-card record and is never charged for that read. **Max records** is the single limit that stops a run (`0` = unlimited). **Max pages per search** is a separate runaway guard on any one search walk (`0` = as deep as the source serves). Propwire itself serves only the first 10,000 rows of any one search, and at most 10 states per search; narrow the states, locations or filters to go deeper. The run log warns when a search hits that limit.

#### Resume and recurring updates

- **Continue a previous run** (`resumeFromRunId`): paste the run or dataset id of an earlier run of this actor to continue it. Records that run already returned are skipped, so an interrupted large collection can finish without paying for the same rows twice.
- **Recurring updates** (`incrementalMode`): for running the same setup again and again (daily or weekly lead monitoring) over the same scope. Each record is classified `NEW`, `UPDATED` (with `changedFields`, price and equity moves count as updates), `UNCHANGED` (suppressed and not billed unless `emitUnchanged` is on), `REAPPEARED`, or `EXPIRED` (only with `emitExpired` on, and never after a run that was capped, continued, or lost a source). A search larger than Propwire's 10,000-row limit is never read to its end, and properties beyond that limit can then be reported as `EXPIRED`, so keep each monitored search under 10,000 results before turning on `emitExpired`. `stateKey` names or shares one monitoring campaign's memory. With Recurring updates off, output is exactly as before.

### Input Parameters

| Parameter | Type | Default | Description |
| --- | --- | --- | --- |
| `addresses` | array | (none) | Street addresses or APNs, one per line. Each is resolved through Propwire's own lookup and returns that property's full record. Takes priority over links and search filters. |
| `addressMatchMode` | string | `first` | When a lookup returns several parcel matches for one address (for example condos), `first` takes the top suggestion, `all` returns every match. |
| `startUrls` | array | (none, prefilled with a sample link) | Propwire search links or property links. A search link is walked forward page by page; a property link returns that one record. Takes priority over search filters. |
| `searchStates` | array | `["FL"]` | US state codes to sweep state-wide. Used only when addresses and links are empty. At most 10 per search. |
| `searchLocations` | array | (none) | Cities, ZIP codes or counties to narrow the states above, resolved through Propwire's own location lookup. Usable on its own too. |
| `searchLeadTypes` | array | (none) | Only return properties carrying these lead-type flags. Values marked premium on the site may require a Propwire account and can come back empty. |
| `searchPropertyTypes` | array | (none) | Restrict the sweep to these property types. |
| `searchEstimatedValueMin` | integer | (none) | Only return properties estimated to be worth at least this much. |
| `searchEstimatedValueMax` | integer | (none) | Only return properties estimated to be worth at most this much. |
| `searchYearBuiltMin` | integer | (none) | Only return properties built in or after this year. |
| `searchYearBuiltMax` | integer | (none) | Only return properties built in or before this year. |
| `searchSoldSince` | string | (none) | Only return properties last sold on or after this date, `YYYY-MM-DD`. |
| `searchOwnerType` | array | (none) | Only return properties owned by individuals or by companies/LLCs/trusts. Leave empty for both. |
| `searchMlsStatus` | string | (none) | Only return properties currently in this MLS state. Leave empty for all statuses. |
| `fetchDetails` | boolean | `true` | Read each property's full record: owner, mailing address, ownership length, portfolio, foreclosure, auction, mortgage and transfer history, tax, parcel/zoning, building specs and the full MLS record when one exists. Without it, records carry only the search-card fields. |
| `maxItems` | integer | `0` | Stop after this many property records across the whole run (`0` = no limit). |
| `maxPages` | integer | `0` | Runaway guard: an upper bound on how many result pages any single search walk may read (`0` = as deep as the source serves). |
| `resumeFromRunId` | string | (none) | Continue one earlier, interrupted run of this actor without re-collecting (or re-billing) rows it already returned. |
| `incrementalMode` | boolean | `false` | Turn on for daily or weekly lead monitoring: later runs return only `NEW`, `UPDATED` and `REAPPEARED` records for the same scope. |
| `stateKey` | string | (none) | Name a monitoring campaign to keep its memory stable, or share one memory across differently configured runs. |
| `emitUnchanged` | boolean | `false` | Also return (and bill) records that have not changed since the last run, labelled `UNCHANGED`. |
| `emitExpired` | boolean | `false` | Also return (and bill) records that were present before and are no longer found, labelled `EXPIRED`. Never produced after a capped or continued run; keep the search under Propwire's 10,000-result limit when you use it. |
| `proxyConfiguration` | object | Residential, US | Connection used for every request. Propwire's own protection refuses ordinary datacenter connections, so the default requests the residential connection tier; it needs a plan that includes that tier. You can also paste your own connection links. |

### Output Example

> Sample shape: values are illustrative placeholders, not from a live record.

```json
{
  "recordType": "property",
  "id": 12345678,
  "propwireUrl": "https://propwire.com/realestate/100-Main-St-Anytown-FL/12345678/property-details",
  "address": "100 Main St",
  "city": "Anytown",
  "state": "FL",
  "zip": "32000",
  "county": "Sample",
  "propertyType": "SFR",
  "bedrooms": 3,
  "bathrooms": 2,
  "buildingAreaSf": 1650,
  "lotSizeSf": 6500,
  "yearBuilt": 1998,
  "estimatedValue": 344800,
  "estimatedEquity": 182400,
  "estimatedEquityPercentage": 53,
  "lastSoldDate": "2021-06-17",
  "lastSoldPrice": 250000,
  "daysOnMarket": 42,
  "mlsListPrice": 325000,
  "mlsListDate": "2026-08-07",
  "mlsStatus": "ACTIVE",
  "leadTypes": ["ABSENTEE_OWNER", "HIGH_EQUITY", "OUT_OF_STATE_OWNER"],
  "ownerNames": ["SAMPLE JANE", "SAMPLE JOHN"],
  "ownerTypes": ["INDIVIDUAL"],
  "ownerOccupied": false,
  "ownershipYears": 5,
  "ownerMailingAddress": "PO Box 1000, Sample Town, NJ 07000",
  "portfolioPropertiesOwned": 4,
  "portfolioValue": 1240000,
  "foreclosureActive": true,
  "auctionDate": "2026-12-02",
  "apn": "12-34-56-78-90",
  "zoning": "R1",
  "latitude": "28.500000",
  "longitude": "-81.400000",
  "taxAssessedValue": 270000,
  "taxBilledAmount": "3400.00",
  "imageUrl": "https://images.example.com/sample-cover.jpg",
  "imageUrls": ["https://images.example.com/sample-1.jpg", "https://images.example.com/sample-2.jpg"],
  "photoCount": 28,
  "detailFetched": true,
  "sourceType": "search",
  "scrapedAt": "2026-09-25T12:00:00Z",
  "changeType": "NEW",
  "raw": { "note": "the complete verbatim source payload: owner, portfolio, foreclosure, mortgage, transfer, tax, parcel and full MLS objects" }
}
```

### Plan Requirement

Propwire's own protection refuses ordinary datacenter connections, so this actor requests the residential connection tier by default, pinned to the US. That tier needs a plan that includes it; a run on a plan without that entitlement needs its own connection links set in the Connection section of the input. The actor rotates connections automatically across retries and fails the run loudly when every connection attempt is refused, rather than returning a dataset that looks like a successful empty scrape.

### FAQ

#### How much does it cost?

This actor charges per property record returned, plus a separate charge for each property whose full record was read (Full property records), and a per-run start charge. Records suppressed as unchanged under Recurring updates are never billed. The **Pricing** tab shows the current rates. Use **Max records** to cap the cost of any run.

#### Is it legal to scrape Propwire?

This actor collects only publicly available property, ownership and MLS data as published by Propwire. You are responsible for how you use it: follow Propwire's terms and the laws that apply to you, including data-protection and telemarketing rules where you use owner contact details for outreach, and get legal advice if you plan commercial redistribution.

#### Can I get only new or changed leads on a schedule?

Yes. Schedule the actor from the **Schedules** tab with the same search filters and turn on **Recurring updates**. Each run then returns only `NEW`, `UPDATED` and `REAPPEARED` records for that scope, and unchanged ones are not returned or billed unless you turn on **Also return unchanged records**.

#### Why did a run return fewer properties than I expected?

A few honest reasons: **Max records** or **Max pages per search** stopped the run early; Propwire itself serves only the first 10,000 rows of any one search, so a very broad sweep needs narrower geography or filters; a location in Cities, ZIPs or counties could not be resolved and was skipped; or a lead-type flag marked premium on the site came back empty because it needs a Propwire account. The run log warns when a limit, the 10,000-row cut-off or an unresolved location stopped part of the collection.

#### Why did my run fail instead of returning an empty dataset?

If every request was refused, the run stops with a clear failure message, because that is a connection problem, not evidence that no properties exist. Run it again in a few minutes, or check the Connection section of the input. A search that was genuinely read and holds nothing for your filters succeeds normally and says so on the run page.

#### Can I use it with AI agents or automation platforms?

Yes. Call it from the API, the Scheduler, or any Apify integration (Make, Zapier, n8n, Google Sheets, webhooks), or from an MCP client through Apify's own MCP server.

### 🔗 More scrapers you might like

Pair this actor with these related scrapers from the same team:

<table>
<tr><td>🏠 <a href="https://apify.com/abotapi/auction-com-scraper"><b>Auction.com Scraper</b></a><br>From $1/1K. Extract foreclosure, REO, short-sale, and auction listings from Auction.com...</td><td>🏠 <a href="https://apify.com/abotapi/realtor-com-scraper"><b>Realtor.com</b></a><br>From $0.9/1K. Extract property listings from realtor.com. Get comprehensive data...</td></tr>
<tr><td>🏠 <a href="https://apify.com/abotapi/redfin-scraper"><b>Redfin Scraper</b></a><br>Scrape redfin.com home listings: price, beds, baths, sqft, lot, year built, coordinates...</td><td>🧩 <a href="https://apify.com/abotapi/zillow-scraper"><b>Zillow Scraper</b></a><br>Scrape zillow.com properties for sale, for rent and recently sold across the US: price...</td></tr>
<tr><td>🏠 <a href="https://apify.com/abotapi/crexi-commercial-listings-scraper"><b>Crexi Scraper</b></a><br>Scrape crexi.com commercial listings: asking price, cap rate, square footage, units, year...</td><td>🧩 <a href="https://apify.com/abotapi/homes-com-scraper"><b>Homes.com Scraper</b></a><br>Scrape US property records from Homes.com. Pick a city, state or ZIP and a channel (for...</td></tr>
</table>

👉 [Browse all abotapi scrapers](https://apify.com/abotapi)

### 💬 Support & custom scrapers

- 🐞 **Found a bug or a missing field?** Open a ticket on the [Issues tab](https://apify.com/abotapi/propwire-property-leads-scraper/issues/open). We usually reply within hours.
- 🛠️ **Need another site, extra fields or a private build?** Email <abotapi@proton.me> or message [Telegram @abotapi](https://t.me/abotapi).
- ⭐ **Enjoying it?** A quick review on the actor page helps other users find it.

# Actor input Schema

## `addresses` (type: `array`):

Free-text street addresses or APN parcel numbers, one per line, e.g. 101 Crawfords Corner Rd, Holmdel, NJ 07733. Each is resolved through the site's own lookup and returns that property's full record. Leave empty unless you want address mode - any value here takes priority over links and the search filters below.

## `addressMatchMode` (type: `string`):

How to handle addresses where the lookup returns several parcel matches (for example condos at one street address). First takes the top suggestion, exactly like clicking it on the site; all returns every match so you can deduplicate by APN afterwards.

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

Search links (https://propwire.com/search?filters=...) and property links (https://propwire.com/realestate/.../property-details) copied from propwire.com. A search link is walked forward page by page; a property link returns that one full record. The example link below is a live property - run it as-is for a one-record demo, replace it with your own links, or clear the field completely to use the address lookup above or the search filters below (links take priority over the filter section).

## `searchStates` (type: `array`):

US state codes to sweep state-wide, e.g. FL. Used only when addresses and links are empty. Keep the total geography small: the site itself answers at most 10 states per search, and very large sweeps stop serving results after the first 10,000 rows - split wide campaigns into several runs.

## `searchLocations` (type: `array`):

Narrow the states above to specific places, one per line - city names (Orlando, FL), ZIP codes (32801) or counties (Orange County, FL). Each is resolved through the site's own location lookup; anything it cannot resolve is reported and skipped. Combined with the states field or usable on its own.

## `searchLeadTypes` (type: `array`):

Only return properties carrying these motivated-seller flags. Values marked premium on the site may require a Propwire account and can come back empty.

## `searchPropertyTypes` (type: `array`):

Restrict the sweep to these property types.

## `searchEstimatedValueMin` (type: `integer`):

Only return properties estimated to be worth at least this much. Leave empty for no floor.

## `searchEstimatedValueMax` (type: `integer`):

Only return properties estimated to be worth at most this much. Leave empty for no ceiling.

## `searchYearBuiltMin` (type: `integer`):

Only return properties built in or after this year. Leave empty for no limit.

## `searchYearBuiltMax` (type: `integer`):

Only return properties built in or before this year. Leave empty for no limit.

## `searchSoldSince` (type: `string`):

Only return properties last sold on or after this date, in YYYY-MM-DD form. Leave empty for no limit.

## `searchOwnerType` (type: `array`):

Only return properties owned by individuals or by companies/llcs/trusts. Leave empty for both.

## `searchMlsStatus` (type: `string`):

Only return properties currently in this MLS state. Leave empty for all statuses.

## `fetchDetails` (type: `boolean`):

Read each property's full record: owner names and mailing address, ownership length, owner portfolio, foreclosure and auction details, mortgage and transfer history, tax assessments, parcel/zoning, building specifications and the full MLS record when one exists. On by default - without it, records carry only the search-card fields (address, value, equity, beds/baths, size and MLS snapshot).

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

Stop after this many property records across the whole run (0 = no limit; the walk then ends when the source runs out). This is the limit that stops a run.

## `maxPages` (type: `integer`):

Runaway guard: an upper bound on how many result pages any single search walk may read. Leave 0 to go as deep as the source serves, with the record cap above as the only real limit.

## `resumeFromRunId` (type: `string`):

Paste the run id (or dataset id) of an earlier run of this Actor to continue it. Records that run already returned are skipped, so an interrupted large collection can finish without paying for the same rows twice. Leave empty for a normal run.

## `incrementalMode` (type: `boolean`):

Turn this on for daily or weekly lead monitoring. The first run returns everything as NEW. Later runs return only NEW, UPDATED and REAPPEARED records, each labelled in a changeType column - price and equity moves count as UPDATED, and a lead that left the result set can be reported as EXPIRED. Leave off for a normal one-off run.

## `stateKey` (type: `string`):

Optional. Name this monitoring campaign to keep its memory stable, or to deliberately share one memory across differently configured runs. Leave empty and the memory is keyed on the run setup automatically.

## `emitUnchanged` (type: `boolean`):

Off by default. Turn on to also return records that have not changed since the last run, labelled UNCHANGED. This returns, and bills, rows you already have.

## `emitExpired` (type: `boolean`):

Off by default. Turn on to also return records that were present in the previous run's result set and are no longer found, labelled EXPIRED. Only produced when a run covered its whole setup, so a capped or continued run never reports records as gone. This returns, and bills, extra rows.

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

Connection used for every request. The site's protection refuses ordinary datacenter connections, so the default requests the premium residential connection tier; it needs a paid plan that includes that tier. You can also paste your own connection links.

## Actor input object example

```json
{
  "addressMatchMode": "first",
  "startUrls": [
    "https://propwire.com/realestate/4055-Britt-Rd/51608674/property-details"
  ],
  "searchStates": [
    "FL"
  ],
  "fetchDetails": true,
  "maxItems": 20,
  "maxPages": 0,
  "incrementalMode": false,
  "emitUnchanged": false,
  "emitExpired": false,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  }
}
```

# Actor output Schema

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

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

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

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "addressMatchMode": "first",
    "startUrls": [
        "https://propwire.com/realestate/4055-Britt-Rd/51608674/property-details"
    ],
    "searchStates": [
        "FL"
    ],
    "fetchDetails": true,
    "maxItems": 20,
    "maxPages": 0,
    "incrementalMode": false,
    "emitUnchanged": false,
    "emitExpired": false,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "apifyProxyCountry": "US"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("abotapi/propwire-property-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 = {
    "addressMatchMode": "first",
    "startUrls": ["https://propwire.com/realestate/4055-Britt-Rd/51608674/property-details"],
    "searchStates": ["FL"],
    "fetchDetails": True,
    "maxItems": 20,
    "maxPages": 0,
    "incrementalMode": False,
    "emitUnchanged": False,
    "emitExpired": False,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "US",
    },
}

# Run the Actor and wait for it to finish
run = client.actor("abotapi/propwire-property-leads-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "addressMatchMode": "first",
  "startUrls": [
    "https://propwire.com/realestate/4055-Britt-Rd/51608674/property-details"
  ],
  "searchStates": [
    "FL"
  ],
  "fetchDetails": true,
  "maxItems": 20,
  "maxPages": 0,
  "incrementalMode": false,
  "emitUnchanged": false,
  "emitExpired": false,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  }
}' |
apify call abotapi/propwire-property-leads-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,abotapi/propwire-property-leads-scraper"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/SLSCb6RMGrdFIoINH/builds/YtwXeRt8TpQ33GWLD/openapi.json