# County Property Records – Owner Lookup & Absentee Leads (`gazidev/property-owner-leads`) Actor

Find property owners, owner mailing addresses, absentee and out-of-state owners and LLC-owned parcels by county from official open statewide parcel data (Florida, North Carolina, Wisconsin, New York City). Values, land use, sale date. No skip tracing.

- **URL**: https://apify.com/gazidev/property-owner-leads.md
- **Developed by:** [Cemal Atakli](https://apify.com/gazidev) (community)
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $5.00 / 1,000 parcel 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/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 Lookup – Parcel & Absentee Owner Leads (FL, NC, WI, NYC)

Find **who owns a property** and **where the owner gets mail**, straight from official open statewide parcel data.
Search a county by owner name (for example every `LLC`), parcel number or street address, or pull lists of
**absentee owners**, **out-of-state owners**, corporate or trust-owned parcels, long-term owners and high-value parcels.

Every record comes from a public government dataset (county property appraiser and assessor rolls, published by the state).
There is no scraping of Zillow, Propwire or other private sites, no login and no proxies. The data is public record, so you can build
mailing lists for direct mail, door knocking or outreach.

### What it does

- **Datasets:** Florida (all 67 counties, Dept. of Revenue cadastral, ~10M parcels), North Carolina (all 100 counties, NC OneMap),
  Wisconsin (72 counties, V12 statewide parcel database 2026) and New York City (5 boroughs, PLUTO).
- **Per parcel:** state, county, parcel ID, **owner name**, **owner mailing address** (street, city, state, ZIP and one full line),
  property (site) address, city and ZIP, land use code and description, market/just value, assessed value, land and building value,
  year built, living area, residential units, last sale date and price (where published), acres, homestead flag (FL) and tax year.
- **Computed flags:** `absenteeOwner` (mailing address differs from the property), `outOfStateOwner`, `ownerType`
  (`company`, `trust`, `government`, `individual`) and `corporateOwner`.
- **Filters:** owner name contains, parcel IDs, address contains, ZIP codes, absentee only, out-of-state only, owner types,
  value range, land use, sold after / sold before.
- **No skip tracing.** This Actor does **not** return phone numbers or e-mail addresses. Pair it with your own skip-trace provider if you need them.

#### Coverage by state

| Field | FL | NC | WI | NYC |
|---|---|---|---|---|
| Owner name | yes | yes | yes (2 names) | yes |
| Owner mailing address | yes | yes | yes | **no** (PLUTO has no mailing address) |
| Absentee / out-of-state flags | yes | yes | yes | no |
| Market / assessed value | just value + assessed | total parcel value | assessed (+ estimated market) | assessed |
| Year built / living area | yes | year built (most counties) | no | yes |
| Last sale | year, month and price | date (no price) | no | no |

### Use cases

- **Real-estate investors & wholesalers:** absentee and out-of-state owner lists, LLC-owned rentals, long-term owners (`soldBefore`).
- **Solar, roofing, HVAC, pool and home-services sales:** owner mailing lists by county, ZIP and land use (e.g. single family).
- **Commercial real estate:** find who owns a building or every parcel held by one company.
- **Proptech and data teams:** a clean, single schema across four very different government datasets.

### Input example

```json
{
  "state": "FL",
  "county": "Alachua",
  "absenteeOnly": true,
  "landUseContains": "Single family",
  "soldBefore": "2010",
  "maxItems": 500
}
```

More examples:

- Every LLC-owned parcel in Wake County, NC: `{"state":"NC","county":"Wake","ownerContains":"LLC"}`
- Out-of-state owners of $1M+ parcels in Miami-Dade: `{"state":"FL","county":"Miami-Dade","outOfStateOnly":true,"minValue":1000000}`
- Look up parcels: `{"state":"NC","county":"Durham","parcelIds":["0822537639"]}`
- Brooklyn multi-family owned by an LLC: `{"state":"NYC","county":"Brooklyn","ownerContains":"LLC","landUseContains":"Multi-family"}`

A county is always required. The state servers time out on statewide or ZIP-only queries, so the Actor walks one county at a time
(you can list several counties separated by commas).

### Output example

```json
{
  "state": "FL",
  "county": "Alachua",
  "parcelId": "05900-109-003",
  "ownerName": "BLC FL LLC",
  "ownerName2": null,
  "mailingAddress": "13510 N SILVER CASSIA PLACE",
  "mailingCity": "ORO VALLEY",
  "mailingState": "AZ",
  "mailingZip": "85755",
  "mailingCountry": null,
  "siteAddress": "7321 NW 117TH LN",
  "siteCity": "ALACHUA",
  "siteZip": "32615",
  "landUseCode": "001",
  "landUse": "Single family",
  "marketValue": 223367,
  "assessedValue": 223367,
  "landValue": 55000,
  "buildingValue": null,
  "yearBuilt": 2003,
  "livingAreaSqft": 1408,
  "residentialUnits": 1,
  "lastSaleDate": null,
  "lastSalePrice": null,
  "acres": 0.21,
  "homesteadExemption": false,
  "taxYear": 2026,
  "ownerType": "company",
  "corporateOwner": true,
  "outOfStateOwner": true,
  "absenteeOwner": true,
  "mailingAddressFull": "13510 N SILVER CASSIA PLACE, ORO VALLEY, AZ 85755",
  "source": "Florida Department of Revenue statewide cadastral (via Florida Geographic Information Office)",
  "scrapedAt": "2026-10-27T10:51:23+00:00"
}
```

Fields the source does not publish are `null`.

### Pricing (pay per event)

| Event | Price |
|---|---|
| Actor start | $0.00005 |
| Parcel record (one matching parcel saved) | **$0.005** |

1,000 owner records cost **$5**. Parcels that do not match your filters, duplicates and error rows are free.
Set *Maximum cost per run* and the Actor stops cleanly when it is reached.

| Actor | Price per record |
|---|---|
| shelvick/county-property-records | $0.05 |
| scrapebench/us-county-property-records-export | $0.02 (export) / $0.045 (lookup) |
| malonestar/parcel-owner-lookup | $0.02 |
| **This Actor** | **$0.005** |

(Apify Store prices checked on 27 Oct 2026.)

### FAQ

**Where does the data come from?** Public ArcGIS / Socrata services run by the states: Florida Dept. of Revenue cadastral via the
Florida Geographic Information Office, NC OneMap (NC Center for Geographic Information & Analysis), the Wisconsin State Cartographer's Office
statewide parcel database, and NYC Department of City Planning PLUTO on NYC Open Data. Each row names its source.

**How fresh is it?** As fresh as the state's latest load: FL and WI publish yearly tax-roll extracts (`taxYear` shows the roll year), NC OneMap
refreshes counties on a rolling basis, and PLUTO is updated a few times a year.

**How is "absentee" decided?** The owner mailing street is compared with the property street (house number and street name, after
normalising ST/STREET, N/NORTH, units). A different state is always absentee. A PO box in the same city is left as `null`
(unknown), because it does not prove the owner lives elsewhere. `absenteeOnly` keeps only `true`.

**Why is a county required?** Statewide parcel layers hold millions of rows and the servers time out on unscoped queries.
The Actor scans a county in small object-ID windows, so even Miami-Dade (590k parcels) works.

**Can I get phone numbers or e-mails?** No. This Actor only returns what the public parcel roll publishes.

**Some names look cut off.** The Florida roll limits owner names to about 30 characters; the Actor returns them exactly as published (`taxYear` shows the roll year).

**Privacy.** Owner names and mailing addresses are public records. Records that Florida law exempts from disclosure
(Ch. 119) are withheld by the counties before publication; the Actor returns only what the state publishes. Use the data in line with the laws that apply to you (for example
do-not-mail and anti-solicitation rules).

### Use with AI agents (Apify MCP)

Add this Actor as a tool through the [Apify MCP server](https://mcp.apify.com) and ask your agent things like
*"List 50 out-of-state owners of single-family homes in Leon County, Florida"*. The structured input (state, county, filters)
and flat JSON output work well for LLM tool calls.

# Actor input Schema

## `state` (type: `string`):

Which official open statewide parcel dataset to search.

## `county` (type: `string`):

County name, e.g. 'Wake', 'Mecklenburg' (NC), 'Alachua', 'Miami-Dade', 'Palm Beach' (FL), 'Dane', 'Milwaukee' (WI), or a borough for NYC: Manhattan, Bronx, Brooklyn, Queens, Staten Island. Separate several counties with commas. A county is required: the state servers time out on statewide or ZIP-only queries.

## `ownerContains` (type: `string`):

Case-insensitive text the owner name must contain, e.g. 'LLC', 'TRUST', 'SMITH JOHN' (most counties store LAST FIRST).

## `parcelIds` (type: `array`):

Look up specific parcels by the county's parcel number exactly as the source stores it (NC 'parno', FL 'PARCEL_ID', WI 'PARCELID', NYC 10-digit BBL).

## `siteAddressContains` (type: `string`):

Case-insensitive text in the property (site) address, e.g. '123 MAIN' or 'OCEAN BLVD'.

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

Keep only parcels whose site ZIP is in this list. Use together with a county (ZIP is not indexed by the state servers). Some counties do not publish a site ZIP.

## `absenteeOnly` (type: `boolean`):

Only parcels whose owner mailing address differs from the property address (or is out of state). Not available for NYC.

## `outOfStateOnly` (type: `boolean`):

Only parcels whose owner mailing address is in another state or country. Not available for NYC.

## `ownerTypes` (type: `array`):

Keep only these owner types (classified from the owner name). Empty = all.

## `minValue` (type: `integer`):

FL: just (market) value. NC: total parcel value. WI and NYC: total assessed value.

## `maxValue` (type: `integer`):

Same value field as the minimum.

## `landUseContains` (type: `string`):

Comma-separated text matched against the land-use code and description, e.g. 'Single family, Condominium' (FL), 'Residential' (WI), 'D1' (NYC building class).

## `soldAfter` (type: `string`):

YYYY, YYYY-MM or YYYY-MM-DD. FL and NC only (FL publishes year and month). Parcels without a sale date are excluded when set.

## `soldBefore` (type: `string`):

YYYY, YYYY-MM or YYYY-MM-DD. FL and NC only. Use it to find long-term owners (e.g. 2005).

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

Stop after this many matching parcel records (0 = no limit). Each record is one charged event.

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

Add every original column from the state dataset under 'raw'.

## Actor input object example

```json
{
  "state": "NC",
  "county": "Wake",
  "ownerContains": "LLC",
  "absenteeOnly": false,
  "outOfStateOnly": false,
  "maxItems": 20,
  "includeRawFields": false
}
```

# Actor output Schema

## `owners` (type: `string`):

No description

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

No description

## `summary` (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 = {
    "state": "NC",
    "county": "Wake",
    "ownerContains": "LLC",
    "maxItems": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("gazidev/property-owner-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 = {
    "state": "NC",
    "county": "Wake",
    "ownerContains": "LLC",
    "maxItems": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("gazidev/property-owner-leads").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 '{
  "state": "NC",
  "county": "Wake",
  "ownerContains": "LLC",
  "maxItems": 20
}' |
apify call gazidev/property-owner-leads --silent --output-dataset

```

## MCP server setup

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

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/lAbeLFaLTZ2QJ6fIY/builds/tbbFDX1dG1hUX9FOb/openapi.json
