# Property Owner Records - Absentee Owner Lists by County (`neverempty/statewide-property-owners`) Actor

Absentee-owner and direct-mail lists from official statewide parcel layers (FL, NC, WI, CT, AR, MA, NY, VT, MN, NJ, MD): owner name, mailing address, value, last sale. NJ and MD publish no owner names; AR no mailing addresses. Filter by absentee or out-of-state owner, value, sale date, owner name.

- **URL**: https://apify.com/neverempty/statewide-property-owners.md
- **Developed by:** [NeverEmpty](https://apify.com/neverempty) (community)
- **Categories:** Real estate, Lead generation, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $36.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

## Property Owner Records - Absentee Owner Lists by County

Build **absentee-owner and direct-mail lists** for a county, a town or a whole state: owner name, owner mailing address, property value and last sale, from the **official statewide parcel layers of Florida, North Carolina, Wisconsin, Connecticut, Arkansas, Massachusetts, New York, Vermont, Minnesota, New Jersey and Maryland**. Not every state publishes every field: New Jersey and Maryland publish no owner names, and Arkansas publishes no mailing addresses. The [Coverage](#coverage) table shows which fields each state has. You need no API key, login or account with any county.

Filter in one run by **absentee or out-of-state owner**, **value range**, **sale-date range** and **owner name** (LLC, TRUST, SMITH...). It is built for real-estate investors, wholesalers, direct-mail marketers, roofers, solar and home-service companies, and anyone who needs a county owner list rather than one lookup at a time.

### What you get

- **One row per parcel**, with the same column names in every state: `ownerName`, `mailingAddress`, `mailingCity`, `mailingState`, `mailingZip`, `propertyAddress`, `valueUsd`, `lastSaleDate`, `lastSalePriceUsd`, `yearBuilt`, `acres`, `landUse` and more.
- **Absentee owners marked on every row.** `ownerOccupancy` is `out_of_state`, `mails_elsewhere`, `owner_occupied_likely` or `unknown`. `absenteeOwner` is `true`, `false` or `null`.
- **A whole county in one line of input.** Type `Wake, NC`, `Hennepin County, MN`, `Vermont`, or a Massachusetts, Vermont or Connecticut town such as `Cambridge, MA`.
- **Up to 100 areas per run**, mixed across states.
- **Every row names its source.** `sourceLayer` is the state's layer and `sourceRecordId` is the record number in it, so any row can be looked up again.
- **An honest answer when there is nothing to return.** These cases each get their own row that says why:

  - an area with no matches;
  - a filter the county's data cannot answer;
  - a layer that could not be reached;
  - a search that stopped early.

  These rows are not charged.

### Coverage

These are the share of parcels with each field. They were measured against each state's live layer on 2026-10-20.

| State | Areas | Owner name | Mailing address | Value | Last sale |
|---|---|---|---|---|---|
| Florida | 67 of 67 counties | 100% | 99.8% | 99.4%\* | year and month, with price |
| North Carolina | 100 of 100 counties | 99.0% | 99.3% | 95.0% | date, no price |
| New York | 62 of 62 counties | 99.6% | 83.9% | 76.6% | not published |
| Wisconsin | 72 of 72 counties | 98.3% | 96.4% | 88.0% | not published |
| New Jersey | 21 of 21 counties | not published | 100% | 99.2% | date and price |
| Minnesota | 59 of 87 counties | 92.3% | 93.7% | 82.0% | date and price |
| Massachusetts | 14 of 14 counties (351 towns) | 99.2% | 98.9% | 98.4% | date and price |
| Maryland | 24 of 24 counties (incl. Baltimore City) | not published | 100% | 98.0% | date and price |
| Arkansas | 75 of 75 counties | 100% | not published | 95.1% | not published |
| Connecticut | 9 of 9 planning regions (169 towns) | 97.9% | 97.8% | 96.7% | date and price |
| Vermont | 14 of 14 counties | 100% | 99.6% | 99.9% | not published |

\* Florida value: sampled 2,000 parcels in each of 64 counties (Miami-Dade, Lee and Palm Beach timed out on the sample). The other cells count every parcel.

#### Gaps in the data

Each gap below is a gap in what the state publishes; this Actor does not fill it in from anywhere else.

- **Minnesota** covers 59 of its 87 counties. The other 28 do not release parcel data openly: Beltrami, Blue Earth, Brown, Cottonwood, Dodge, Faribault, Freeborn, Goodhue, Hubbard, Kanabec, Kandiyohi, Kittson, Le Sueur, Lincoln, Mahnomen, Martin, Meeker, Nicollet, Nobles, Pine, Redwood, Rock, Roseau, Sibley, Swift, Todd, Wadena and Watonwan.
  - Inside the covered counties, Fillmore, Houston, Norman, Rice, Stearns and Waseca publish no owner names.
  - Fillmore, Houston, Murray, Norman and Waseca publish no mailing addresses.
  - Big Stone, Pipestone and Renville publish mailing addresses for only part of their parcels (9% to 24%).
  - These 24 counties publish no property values: Benton, Big Stone, Carlton, Chippewa, Douglas, Fillmore, Grant, Houston, Lac qui Parle, Marshall, McLeod, Mille Lacs, Murray, Norman, Otter Tail, Pennington, Polk, Pope, Red Lake, Renville, Stevens, Traverse, Waseca and Yellow Medicine.
- **New York City** (Bronx, Kings, New York, Queens and Richmond counties) has owner names and property addresses only. The layer carries no mailing address or value there.
- **New Jersey and Maryland** publish no owner names in their statewide layers. You still get the mailing address, value and sale.
- **Arkansas** publishes no owner mailing address. You still get the owner name, property address and value.
- **North Carolina**:
  - Hoke County publishes no owner names.
  - Camden, Chowan, Hoke and Yancey publish no values.
  - In Duplin and Onslow the mailing address is the street line only, without city or state.
  - `propertyCity` and `propertyZip` are filled only where the county publishes them for the property itself: the city for about 38% of parcels (Wake, Mecklenburg and Durham among them; not Johnston) and the ZIP for about 16% (Durham and Onslow among them; not Wake, Mecklenburg or Johnston).
- **Wisconsin** mailing addresses are one line in the source. Where a county writes the street and city with no separator between them (Milwaukee does, for example), the city stays inside `mailingAddress` and `mailingCity` is empty.
- **Partial values.** Suffolk County, NY publishes values for 45% of its parcels. Menominee County, WI publishes them for 49%, and Columbus County, NC for 36%.
- **Connecticut** publishes no mailing ZIP code.
- **Florida** records the sale year and month, not the day, so `lastSaleDate` looks like `2024-06`.

### Filters

| Input | What it does |
|---|---|
| `areas` | One area per line: a county with its state (`Alachua, FL`, `Wake County, NC`), a whole state (`VT` or `Vermont`), or a town in Massachusetts, Vermont or Connecticut |
| `absenteeOwners` | `any`, `absentee` (mailing address in another state, or a different house number than the property), `out_of_state`, or `owner_occupied` |
| `minValueUsd` / `maxValueUsd` | Value range. The value is the one each state publishes, and `valueBasis` on every row says which it is (market, assessed or listed) |
| `soldFrom` / `soldTo` | Range for the most recent recorded sale (YYYY-MM-DD) |
| `ownerName` | Owner name contains this text, such as `LLC`, `TRUST` or `SMITH`. Case does not matter |
| `maxResultsPerArea` | The most parcels returned per area line (default 100) |

When a filter cannot be answered in an area, that area is left out with a note row. This happens with a sale-date range in Wisconsin, an owner name in New Jersey, or a value range in Otter Tail County, MN, for example. The Actor never quietly returns that area unfiltered.

### How absentee owners are decided

| `ownerOccupancy` | Rule |
|---|---|
| `out_of_state` | The mailing state (or country) differs from the property's state |
| `mails_elsewhere` | Same state, but the mailing house number differs from the property's |
| `owner_occupied_likely` | Same house number and at least one shared street word |
| `unknown` | No mailing address, a PO box, no house number on the property, or the same number on a different street |

PO boxes count as `unknown`, not absentee, because a PO box says nothing about where the owner lives. The `absentee` filter returns `out_of_state` and `mails_elsewhere` rows only.

### Where each column comes from

The source column names below are the ones each state uses in its own layer.

| Output | FL | NC | WI | CT | AR | MA |
|---|---|---|---|---|---|
| ownerName / ownerName2 | OWN_NAME | ownname / ownname2 | OWNERNME1 / OWNERNME2 | Owner / Co_Owner | ownername | OWNER1 |
| mailingAddress | OWN_ADDR1 + OWN_ADDR2 | mailadd + munit | PSTLADRESS (split) | Mailing_Address | - | OWN_ADDR |
| mailingCity / State / Zip | OWN_CITY / OWN_STATE\_ or OWN_STATE / OWN_ZIPCD | mcity / mstate / mzip (or split from mailadd) | from PSTLADRESS | Mailing_City / Mailing_State / - | - | OWN_CITY / OWN_STATE / OWN_ZIP |
| propertyAddress | PHY_ADDR1 + PHY_ADDR2 | siteadd | SITEADRESS | Location | adrlabel | SITE_ADDR |
| valueUsd | JV (just value) | parval | CNTASSDVALUE | Appraised land + building + outbuilding | totalvalue | TOTAL_VAL |
| lastSaleDate / Price | SALE_YR1 + SALE_MO1 / SALE_PRC1 | saledate / - | - | Sale_Date / Sale_Price | - | LS_DATE / LS_PRICE |
| parcelId | PARCEL_ID | parno | PARCELID | Parcel_ID | parcelid | PROP_ID |

| Output | NY | VT | MN | NJ | MD |
|---|---|---|---|---|---|
| ownerName / ownerName2 | PRIMARY_OWNER / ADD_OWNER | OWNER1 / OWNER2 | owner_name (or tax_name) / owner_more | - | - |
| mailingAddress | MAIL_ADDR (or PO_BOX) | ADDRGL1 + ADDRGL2 | own_add_l1-l4 (or tax_add_l1-l4), split | ST_ADDRESS | OWNADD1 + OWNADD2 |
| mailingCity / State / Zip | MAIL_CITY / MAIL_STATE / MAIL_ZIP | CITYGL / STGL / ZIPGL | from the address lines | CITY_STATE (split) / ZIP_CODE | OWNCITY / OWNSTATE / OWNERZIP + OWNZIP2 |
| propertyAddress | PARCEL_ADDR | E911ADDR | address number + street parts | PROP_LOC | ADDRESS |
| valueUsd | FULL_MARKET_VAL | REAL_FLV | emv_total (or emv_land + emv_bldg) | NET_VALUE | NFMTTLVL |
| lastSaleDate / Price | - | - | sale_date / sale_value | DEED_DATE / SALE_PRICE | TRADATE / CONSIDR1 |
| parcelId | PRINT_KEY | SPAN | state_pin | PAMS_PIN | ACCTID |

Every row also carries `marketValueUsd`, `assessedValueUsd`, `landValueUsd` and `improvementValueUsd` wherever the state publishes them separately, plus `valueYear`. `mailingCity` and `propertyCity` are the town names of the two addresses. They are filled where the state publishes them, as the tables above show.

### Output example

```json
{
  "status": "ok",
  "state": "NC",
  "county": "Wake",
  "ownerName": "SMITH, JOHN A",
  "mailingAddress": "123 OAK ST",
  "mailingCity": "CHARLOTTE",
  "mailingState": "NC",
  "mailingZip": "28202",
  "propertyAddress": "4501 PINE RIDGE DR",
  "ownerOccupancy": "mails_elsewhere",
  "absenteeOwner": true,
  "valueUsd": 412000,
  "valueBasis": "assessed (parcel value)",
  "lastSaleDate": "2021-06-14",
  "sourceLayer": "https://...",
  "sourceRecordId": 1234567
}
```

The values above are invented to show the shape. Real rows come from the state layers.

### Pricing

You pay per parcel row delivered. Note rows are never charged: no matches, a skipped area, a layer that could not be reached, or a search that stopped early.

### FAQ

**How do I get a list of absentee owners in a county?**
Put the county in `areas` (for example `Wake, NC`) and set `absenteeOwners` to `absentee`, or to `out_of_state` for owners who live in another state. Each row has the owner's mailing address for direct mail.

**Can I download every property owner in a whole state?**
Type the state (`VT`, `Florida`) as an area line. Each area line returns up to `maxResultsPerArea` parcels, at most 50,000. For a state larger than that, list it county by county: one county per line, up to 100 lines per run.

**Where does the data come from?**
From the statewide parcel layer each state publishes from its county or town tax rolls. Every row links to that layer and gives the record number in it.

**How current is it?**
As current as the state's layer. Most states refresh their layer once a year from the tax roll. `valueYear` shows the roll year where the state publishes it.

**Why is a sale price $100, or far above the value?**
`lastSalePriceUsd` is the price the state recorded for the deed. Transfers between family members or into a trust are often recorded at $0 to $100, and a sale of several parcels together is often recorded with the total price on each parcel. Use `soldFrom` with `minValueUsd` and check the price against `valueUsd` when you need arm's-length sales only.

**Does it include phone numbers or emails?**
No. Property tax rolls do not contain them.

### Limitations

- Coverage is limited to the 11 states and the areas in the table above. Counties outside them, and the 28 Minnesota counties listed above, are not available.
- Owner names are not published statewide in New Jersey or Maryland. Mailing addresses are not published in Arkansas. Sale dates are not published in Wisconsin, New York, Vermont or Arkansas.
- Very narrow filters on very large areas read up to 300,000 parcels per area line. If that limit is reached before `maxResultsPerArea` is filled, a note row says the result is incomplete.
- The absentee rule compares addresses as the counties wrote them. Typing differences between the two addresses can put a parcel in `unknown`.

# Actor input Schema

## `areas` (type: `array`):

One area per line: a county with its state ("Alachua, FL", "Wake County, NC"), a whole state ("VT" or "Vermont"), or a town in Massachusetts, Vermont or Connecticut ("Brookline, MA"). Supported states: FL, NC, WI, CT, AR, MA, NY, VT, MN, NJ, MD. Connecticut has no county governments; use one of its 9 planning regions (for example "Capitol Region, CT") or a town. New York City's five boroughs (Bronx, Kings, New York, Queens, Richmond) come with owner names and property addresses but no mailing address or value.

## `absenteeOwners` (type: `string`):

absentee = the owner's mailing address is in another state, or has a different house number than the property. out_of_state = the mailing address is in another state or country. owner_occupied = the mailing address has the same house number and street as the property (unit numbers are not compared). Properties where this cannot be told (no mailing address, PO box, no house number) are left out of all three.

## `minValueUsd` (type: `integer`):

Keep properties whose value is at least this many dollars. The value is the one each state publishes (market value in most states, assessed value in some); every row says which in valueBasis. Properties with no value are left out when this is set.

## `maxValueUsd` (type: `integer`):

Keep properties whose value is at most this many dollars.

## `soldFrom` (type: `string`):

Keep properties whose most recent recorded sale is on or after this date. Wisconsin, New York, Vermont and Arkansas publish no sale dates statewide, so areas there are left out (with a note row) when a sale range is set. Florida records the sale month only.

## `soldTo` (type: `string`):

Latest sale date. Empty means today.

## `ownerName` (type: `string`):

Keep properties whose owner name contains this text, such as SMITH, LLC or TRUST. Case does not matter.

## `maxResultsPerArea` (type: `integer`):

The most property records returned for each area line. One record is one parcel.

## Actor input object example

```json
{
  "areas": [
    "Alachua, FL",
    "Wake, NC"
  ],
  "absenteeOwners": "any",
  "soldFrom": "",
  "soldTo": "",
  "maxResultsPerArea": 100
}
```

# Actor output Schema

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

One row per parcel, plus one row when an area's layer rejected the search, matched nothing, was skipped because it cannot answer a filter, or could not be read in full.

# 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 = {
    "areas": [
        "Alachua, FL",
        "Wake, NC"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("neverempty/statewide-property-owners").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 = { "areas": [
        "Alachua, FL",
        "Wake, NC",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("neverempty/statewide-property-owners").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 '{
  "areas": [
    "Alachua, FL",
    "Wake, NC"
  ]
}' |
apify call neverempty/statewide-property-owners --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,neverempty/statewide-property-owners"
        }
    }
}
```

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/4wuq9tvjchmfpBo4l/builds/bc7aGIKZ7HBaXMQj9/openapi.json