# Property Owner Phone & Email Lookup by Address (USA) (`nice_dev/property-owner-skip-trace`) Actor

Find the owner of any US property address and get their phone numbers (line type, carrier), emails, age, mailing address, relatives and the property record. Owner-occupied check, absentee flag, owner name from your list. Pay only for owners found with a contact.

- **URL**: https://apify.com/nice\_dev/property-owner-skip-trace.md
- **Developed by:** [Nice Dev](https://apify.com/nice_dev) (community)
- **Categories:** Lead generation, Real estate, MCP servers
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $6.80 / 1,000 owner found with a phone or an emails

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

### 🔎 What is Property Owner Skip Trace?

**Property Owner Skip Trace** takes a list of **US property addresses** and returns the **owner** of each one with their **phone numbers (mobile, landline or VoIP, with the carrier)**, **emails**, **age**, **mailing address**, **relatives**, and the **property record** (value, equity, last sale, parcel number, sale history, occupancy) — the data real-estate investors, wholesalers, cash buyers and agents use to reach a property owner.

Paste your addresses (or a CSV file), click **Start**, and download **one row per address** in JSON, CSV or Excel. It reads the free people-search site FastPeopleSearch: **5 addresses in about 40 seconds**, about 10 owners a minute. 

**The owner, not just whoever lives there.** Many tools return the most recent occupant of an address — often a tenant. This one reads the property record of the address: when it says the owner lives there, the resident is returned as the owner; when the home is rented out, the owner lives elsewhere and cannot be named from the address alone — add the owner's name from the tax roll (`| Full name`) and that person is found, even when they live in another city. Each row says how the owner was found (`ownerMatch`); an owner is charged only when found with a phone or an email, each address searched a small search fee.

### 📋 What data can you extract with Property Owner Skip Trace?

One row per address, 81 fields:

| Category | What you get |
| --- | --- |
| 🏷️ **Lookup** | found or not, how the owner was identified (name you gave, owner-occupied home, occupant), why no owner was found, the property address as you gave it |
| 👤 **Owner** | full name, first, middle and last name, other names used, age, month and year of birth, deceased or not and when |
| 📬 **Mailing address** | where the owner lives now: street, city, state, ZIP code, county, since when, map coordinates — and whether it is the property itself |
| 📞 **Phone numbers** | every number with its line type (mobile, landline, VoIP), carrier and date first reported, the main number first — the first 5 also in their own columns |
| ✉️ **Emails** | every email shown for the owner — the first 5 also in their own columns |
| 🏡 **Property record** | estimated value and equity, last sale amount and date, owner since, parcel number, bedrooms, bathrooms, living and lot area, year built, land use, parking, heating and cooling, owner-occupied or absentee, sale and mortgage history, tax assessments |
| 🕰️ **Address history** | the owner's past addresses with their county and the month they were recorded |
| 👪 **Relatives and associates** | names, ages, month of birth and the page of each; possible spouse and marital status |
| 💼 **Work and education** | employer and job title, schools and degrees, companies the owner is linked to and the role held |

Every field, with an example, is listed in the **Output** section below.

### ✅ Why use Property Owner Skip Trace?

- 🏠 **The owner, honestly labelled**: owner-occupied homes give their resident as the owner; rented-out homes are flagged absentee instead of returning the tenant — add the owner's name from the tax roll and the owner is found among the people linked to the address and their relatives.
- 💸 **The owner's price only for real results**: an address with no owner found, or an owner without any phone or email, costs its search fee only ($2.20 per 1,000) and comes back with the reason.
- 📞 **Every phone number, typed**: mobile, landline or VoIP, carrier and date first reported — not just the first number.
- 🏡 **The property too**: value, equity, last sale, owner since, parcel number (APN), sale and mortgage history, tax assessments, absentee flag.
- 📥 **Your lists as they are**: one address per line, a list of objects for your CRM, or a CSV / Google Sheets link with your own ids.
- 🔁 **Never pay twice**: tick **Only new owners** and each later run skips the owners already delivered; an owner of several addresses of your list is charged once.
- 🔌 API, scheduling, integrations (Make, Zapier, n8n, Google Sheets…) and JSON/CSV/Excel export via the Apify platform.

### 🚀 How to find a property owner's phone number and email

1. Create a free Apify account.
2. Open **Property Owner Skip Trace** and paste your addresses into **Property addresses** (one per line, owner's name after `|` when you have it), or give a list of objects in **Properties (structured)**, or a **CSV file URL**.
3. Set **Max owners** (100 by default, 0 = no limit).
4. Click **Start**.
5. Download the dataset in JSON, CSV, Excel or via API.

### 💰 How much does it cost to skip trace property owners?

This Actor uses **pay per event** pricing. Platform usage (compute, proxy) is included in the price. 

| What you pay for | Price |
| --- | --- |
| 🔎 Each address searched (`address-search`), **whether an owner is found or not** | $2.20 per 1,000 |
| 🏠 Each owner found with at least one phone number or email (`owner-found`) | $11.30 per 1,000 (Bronze $8.60, Silver $7.70, Gold and above $6.80) |
| 🧹 Each owner a filter drops before their report (`filter-check`) | $0.35 per 1,000 |
| 🧹 Each owner a filter drops after reading their report (`detail-filter-check`) | $2.50 per 1,000 |
| ▶️ Each run start (`apify-actor-start`) | $0.01 (per GB of run memory, 1 GB minimum: $0.01 up to 1 GB, $0.02 at 2 GB) |

That is $0.0113 per owner found on the Free plan, $0.0068 on Gold and above, plus $0.0022 per address searched. An address where no owner is found (rented out without the owner's name, nobody at that address), an owner without any phone or email (`partial`) and the same owner found again for another address of the run cost the search fee only; a line that could not be searched costs nothing. Example: a list of 1,000 addresses where 600 owners are found with a contact ≈ $8.99 on the Free plan (1,000 addresses $2.20 + 600 owners $6.78 + $0.01). With your own proxies (`proxyUrls`), addresses searched are not charged: you pay per owner found, per owner a filter drops and per run start.

### ⚙️ Input

```json
{
    "addresses": [
        "18081 SW 41st St, Miramar, FL 33029",
        "641 NW 59th Ave; Miami, FL 33126 | Janette Suarez"
    ],
    "maxItems": 100
}
```

From a CRM or an automation, one object per property (your `id` comes back as `inputId`):

```json
{
    "properties": [
        { "id": "crm-4812", "street": "641 NW 59th Ave", "city": "Miami", "state": "FL", "zip": "33126", "ownerName": "Janette Suarez" },
        { "id": "crm-4813", "street": "275 E 46th St", "city": "Hialeah", "state": "FL", "zip": "33013" }
    ],
    "requirePhone": true
}
```

From a spreadsheet, and only the owners not delivered before:

```json
{
    "csvUrl": "https://docs.google.com/spreadsheets/d/1AbCdEfGhIjKlMnOpQrStUvWxYz/export?format=csv",
    "onlyNew": true,
    "stateKey": "miami-absentee"
}
```

| Field | Notes |
| --- | --- |
| `addresses` | One US property per line, street then city, state and ZIP code, separated by `;` or commas: `18081 SW 41st St, Miramar, FL 33029`; a unit follows its street: `18081 SW 41st St, Apt 5, Miramar, FL 33029`. Add a vertical bar and the owner's name at the end when you know it: `641 NW 59th Ave; Miami, FL 33126 \| Janette Suarez`. Up to 1,000 lines per list. |
| `properties` | A JSON list of objects with `street`, `city`, `state`, `zip` (or the whole address in `street`), optionally `unit` (or `apt`, `unit #`, `address line 2`), `ownerName` (or `firstName` and `lastName`) and your own `id` (returned as `inputId`): one property per object. |
| `csvUrl` | Link to a CSV file with a header row (Google Sheets: `…/export?format=csv`, or the sheet's own link shared as "Anyone with the link"), max 5 MB. Recognised columns: `street`, `address` or `property address` (the street, or the whole address in one column), `unit` / `apt` / `address line 2`, `city`, `state`, `zip` (a ZIP code that lost its leading zero in a spreadsheet, `2108`, is read as `02108`), `owner name` or `first name` and `last name`, `id`. |
| `maxItems` | Stop after this many owners for the whole run (`0` = unlimited). Addresses without an owner do not count. All lines, objects and CSV rows together make up to 5,000 addresses per run. |
| `includeOccupants` | When the owner cannot be named (rented out, or no property record) and you gave no name: return the most recent resident instead, marked `occupant` and charged like an owner. Off by default: such an address gets a `not_found` row (search fee only). |
| `requirePhone`, `requireEmail` | Only the owners with at least one phone number, or one email. |
| `minAge`, `maxAge` | Age range of the owner, for example `18` to `75`; owners whose age is not known are kept. |
| `excludeKeywords` | Drop the owners whose name contains one of these words: `LLC`, `Trust`. |
| `onlyNew`, `stateKey`, `resetState` | Monitoring: only the owners never delivered under this memory key (`miami-absentee`); `resetState` forgets the memory. |
| Advanced | `proxyConfiguration` (keep the default, included in the price; your own proxies are used when you give them; the residential proxy is not available), `maxConcurrency`, `maxRequestsPerMinute`, `minRequestIntervalMs`, `maxRequestRetries`, `debugLog`. |

### 📦 Output

One real row, shortened (lists cut to their first entries) and with the personal values masked (`X`):

```json
{
    "lookupStatus": "found",
    "ownerMatch": "owner_occupied",
    "ownerNote": null,
    "propertyAddress": "2XX E 46th St, Hialeah, FL 33013",
    "id": "G-539833XXXXXXXXXXXXX",
    "url": "https://www.fastpeoplesearch.com/renier-hernandez_id_G-539833XXXXXXXXXXXXX",
    "source": "fastpeoplesearch",
    "fullName": "Renier Aguilar Hernandez",
    "firstName": "Renier",
    "middleName": "Aguilar",
    "lastName": "Hernandez",
    "aliases": ["Renier A Hernandez", "Renier Aguilar"],
    "age": 40,
    "born": "April 1986",
    "birthYear": 1986,
    "birthMonth": 4,
    "isDeceased": false,
    "deathDate": null,
    "currentAddress": "2XX E 46th St, Hialeah, FL 33013",
    "street": "2XX E 46th St",
    "city": "Hialeah",
    "state": "FL",
    "zip": "33013",
    "county": "Miami-Dade County",
    "livingSince": "June 2018",
    "currentAddressUrl": "https://www.fastpeoplesearch.com/address/2xx-e-46th-st_hialeah-fl-33013",
    "latitude": 25.86,
    "longitude": -80.28,
    "phones": [
        {
            "number": "(786) 343-XXXX",
            "e164": "+1786343XXXX",
            "type": "Wireless",
            "carrier": "MetroPCS California LLC",
            "firstReported": "May 2013",
            "isPrimary": true
        },
        {
            "number": "(407) 558-XXXX",
            "e164": "+1407558XXXX",
            "type": "Wireless",
            "carrier": "T-Mobile USA Inc",
            "firstReported": "July 2026",
            "isPrimary": false
        }
    ],
    "phoneCount": 3,
    "bestPhone": "(786) 343-XXXX",
    "bestPhoneType": "Wireless",
    "bestPhoneCarrier": "MetroPCS California LLC",
    "phone1": "(786) 343-XXXX",
    "phone1Type": "Wireless",
    "phone1Carrier": "MetroPCS California LLC",
    "phone1FirstReported": "May 2013",
    "phone2": "(407) 558-XXXX",
    "phone2Type": "Wireless",
    "phone2Carrier": "T-Mobile USA Inc",
    "phone2FirstReported": "July 2026",
    "phone3": "(786) 315-XXXX",
    "phone3Type": "Wireless",
    "phone3Carrier": "T-Mobile USA Inc",
    "phone3FirstReported": "March 2026",
    "phone4": null,
    "phone4Type": null,
    "phone4Carrier": null,
    "phone4FirstReported": null,
    "phone5": null,
    "phone5Type": null,
    "phone5Carrier": null,
    "phone5FirstReported": null,
    "emails": ["xxxxxxxxxxxx@yahoo.com", "xxxxxxxx@yahoo.es"],
    "emailCount": 2,
    "bestEmail": "xxxxxxxxxxxx@yahoo.com",
    "email1": "xxxxxxxxxxxx@yahoo.com",
    "email2": "xxxxxxxx@yahoo.es",
    "email3": null,
    "email4": null,
    "email5": null,
    "previousAddresses": [
        {
            "address": "8XX W 74th St, Unit 2XX, Hialeah, FL 33014",
            "street": "8XX W 74th St, Unit 2XX",
            "city": "Hialeah",
            "state": "FL",
            "zip": "33014",
            "county": "Miami-Dade County",
            "recorded": "April 2013"
        }
    ],
    "relatives": [
        {
            "name": "Addel A.",
            "age": 21,
            "born": "Aug 2005",
            "id": "G240713XXXXXXXXXXXXX",
            "url": "https://www.fastpeoplesearch.com/addel-a_id_G240713XXXXXXXXXXXXX"
        }
    ],
    "associates": [
        {
            "name": "Luis C.",
            "age": 34,
            "born": "Jun 1992",
            "id": "G823368XXXXXXXXXXXXX",
            "url": "https://www.fastpeoplesearch.com/luis-c_id_G823368XXXXXXXXXXXXX"
        }
    ],
    "possibleSpouse": null,
    "maritalStatus": "We can not find any public records stating that Renier Hernandez is currently Married. It is not likely.",
    "livesAtProperty": true,
    "ownerSince": "2019-02-05",
    "property": {
        "bedrooms": 2,
        "bathrooms": 1,
        "squareFeet": 1552,
        "lotSquareFeet": 6900,
        "yearBuilt": 1951,
        "estimatedValue": 594000,
        "estimatedEquity": 342780,
        "lastSaleAmount": 304000,
        "lastSaleDate": "2019-02-05",
        "occupancyType": "Owner Occupied",
        "ownershipType": "Individual",
        "landUse": "Single Family",
        "propertyClass": "Residential",
        "subdivision": "Flamingo Estate",
        "stories": 1,
        "parkingSpaces": null,
        "airConditioning": null,
        "heating": null,
        "garage": null,
        "apn": "04-3106-XXX-XXXX",
        "schoolDistrict": "Dade County School District",
        "sales": [
            {
                "saleDate": "2020-03-11",
                "recordedDate": "2020-03-24",
                "amount": null,
                "mortgage": 288000,
                "secondMortgage": null,
                "docType": "Stand Alone Mortgage"
            },
            {
                "saleDate": "2019-02-05",
                "recordedDate": "2019-02-14",
                "amount": 304000,
                "mortgage": 288800,
                "secondMortgage": null,
                "docType": "Special Warranty Deed"
            }
        ],
        "taxAssessments": [
            {
                "year": 2025,
                "assessedValue": 276707,
                "landValue": null,
                "improvementValue": null,
                "taxAmount": null
            }
        ]
    },
    "isAbsentee": false,
    "employment": [
        {
            "company": "MERCEDES MEDICAL CENTERS (CLINICA LAS MERCEDES)",
            "title": "NETWORK ENGINEER",
            "location": "Homestead, FL"
        }
    ],
    "education": [],
    "businesses": [],
    "searchType": "address",
    "searchInput": "2XX E 46th St, Hialeah, FL 33013",
    "inputId": null,
    "targetName": null,
    "nameMatch": "none",
    "matchScore": 0,
    "searchUrl": "https://www.fastpeoplesearch.com/address/2xx-e-46th-st_hialeah-fl-33013",
    "scrapedAt": "2026-09-26T13:17:25.740Z"
}
```

An address without an owner has a row too, at no extra cost: the same columns, the owner's empty, `lookupStatus` and `ownerNote` saying why (for a rented-out home: `not_found`, "The owner does not live here…", `isAbsentee: true`, the property record without its history).

You can download the dataset in various formats such as JSON, HTML, CSV or Excel.

#### All 81 fields

| Fields | What you get |
| --- | --- |
| `lookupStatus` | **Lookup**: `found` (owner with a phone or an email — the only row charged the owner fee), `partial` (owner without any contact), `not_found` (no owner delivered: none could be named, the owner was found but dropped by one of your filters, or his full report could not be read — the Owner note says which), `duplicate` (same owner as another address of the run, or delivered by a previous run with **Only new owners**), `invalid` (the line could not be searched), `error` (the address page could not be read), `skipped` (the run stopped before it) |
| `ownerMatch`, `ownerNote` | how the owner was found: `name` (the name you gave), `owner_occupied` (the record says the owner lives there: its most recent resident), `occupant` (Include occupants); why no owner, or a caution |
| `propertyAddress` | the address searched, as read from your input |
| `id`, `url`, `source` | **Owner**: the owner's id and page on FastPeopleSearch, the site it was read on |
| `fullName`, `firstName`, `middleName`, `lastName`, `aliases` | `Renier Aguilar Hernandez`, `Renier`, `Aguilar`, `Hernandez`, other names used |
| `age`, `born`, `birthYear`, `birthMonth` | `40`, `April 1986`, `1986`, `4` |
| `isDeceased`, `deathDate` | `true` when the site says the owner passed away, and when (`October 2018`) |
| `currentAddress`, `street`, `city`, `state`, `zip`, `county` | **Mailing address**: where the owner lives now, one line, then its parts |
| `livingSince`, `currentAddressUrl`, `latitude`, `longitude` | month moved in (`June 2018`), the address page, map coordinates |
| `phones`, `phoneCount` | **Phone numbers**: every number with `number`, `e164`, `type`, `carrier`, `firstReported`, `isPrimary`; how many |
| `bestPhone`, `bestPhoneType`, `bestPhoneCarrier` | the main number, else the first mobile, else the first number |
| `phone1`, `phone1Type`, `phone1Carrier`, `phone1FirstReported` | first number in its own columns (`Wireless`, `MetroPCS California LLC`, `May 2013`) |
| `phone2`, `phone2Type`, `phone2Carrier`, `phone2FirstReported` | second number |
| `phone3`, `phone3Type`, `phone3Carrier`, `phone3FirstReported` | third number |
| `phone4`, `phone4Type`, `phone4Carrier`, `phone4FirstReported` | fourth number |
| `phone5`, `phone5Type`, `phone5Carrier`, `phone5FirstReported` | fifth number |
| `emails`, `emailCount`, `bestEmail` | **Emails**: every email, how many, the first one |
| `email1`, `email2`, `email3`, `email4`, `email5` | the first 5 emails in their own columns |
| `previousAddresses` | **Address history**: `address`, `street`, `city`, `state`, `zip`, `county`, `recorded` (`April 2013`) |
| `relatives`, `associates` | **Relatives and associates**: `name`, `age`, `born`, `id`, `url` of each |
| `possibleSpouse`, `maritalStatus` | the person the records say the owner is likely married to; the site's sentence on marriage records |
| `livesAtProperty`, `ownerSince` | `true` when the owner's mailing address is the property itself; date the owner acquired it (newest deed, else last sale: `2019-02-05`) |
| `property`, `isAbsentee` | **Property record**: `bedrooms`, `bathrooms`, `squareFeet`, `lotSquareFeet`, `yearBuilt`, `estimatedValue`, `estimatedEquity`, `lastSaleAmount`, `lastSaleDate`, `occupancyType`, `ownershipType`, `landUse`, `propertyClass`, `subdivision`, `stories`, `parkingSpaces`, `airConditioning`, `heating`, `garage`, `apn`, `schoolDistrict`, `sales` (sale and mortgage history), `taxAssessments` (assessed values and the tax paid, most often for the last year only; amounts in USD); `true` when the property record says the owner does not live there |
| `employment`, `education`, `businesses` | **Work and education**: employer and title, schools and degrees, linked companies with role and since when |
| `searchType`, `searchInput`, `inputId`, `targetName` | **Search and match**: `address`; the line as you gave it; your own id; the owner's name you gave |
| `nameMatch`, `matchScore` | `matched` (first and last names match the name you gave, in either order), `none` (no name given, or a row with no owner such as `not_found`: nothing to compare), rarely `fallback` (the owner's own page no longer shows that name); 0-100 |
| `searchUrl`, `scrapedAt` | the address page the owner was searched on, ISO timestamp |

### 💡 Tips

#### How the owner is found

- **You give the owner's name** (`641 NW 59th Ave; Miami, FL 33126 | Janette Suarez`, from the county tax roll or your list): the person whose first AND last names match is looked for among the people linked to the address — the first 3 pages, about 40 people — and among their relatives, where the owner of a rented-out home usually is. Nicknames, middle names and the tax-roll order (`SUAREZ JANETTE M`, `Suarez, Janette`) are tolerated. `ownerMatch: name`. Not found: a `not_found` row (search fee only), never someone else in their place.
- **No name, owner-occupied home** (the property record says so): the most recent resident is the owner. `ownerMatch: owner_occupied`, and `livesAtProperty` tells whether that person still lives there.
- **No name, rented out or no record**: the owner lives elsewhere and the address alone cannot name them. `not_found` row (search fee only) with `isAbsentee: true` and the property record — or, with **Include occupants**, the most recent resident marked `occupant` (charged like an owner).

#### How to reduce costs

An owner is charged only when found with a phone or an email; any other address costs its search fee only ($2.20 per 1,000). Use **Only new owners** for lists you run again (an owner already delivered is never read nor charged twice). Filters drop an owner before it is saved: one dropped on the search result (name words, age) costs only the filter fee ($0.35 per 1,000); one dropped for lack of a phone or an email costs its report fee ($2.50 per 1,000) — less than an owner you keep.

#### Several addresses in one run

Fill **Property addresses** (up to 1,000 lines), **Properties (structured)** and a **CSV file URL** together: up to 5,000 addresses per run. A line that cannot be searched (an address without its state, a street without its number) gets an `invalid` row with the reason — one bad line does not stop the run. The same address given twice with two different owner names is searched once, for the first name. An owner of several addresses of your list is saved — and charged — once; the other addresses get a `duplicate` row naming them (search fee only).

#### Monitoring: only the new owners

Tick **Only new owners** (`onlyNew`) and schedule the Actor on the same list. The first run returns everything; each later run skips the owners already delivered: they are not saved nor charged, and their report is not even opened. The memory lives in a named key-value store of your account (`property-owner-skip-trace-seen`, up to 150,000 owners per key) and is only updated with owners that really reached the dataset, so a failed run never hides anyone. Give each schedule its own `stateKey`, and tick `resetState` once to start over.

### 🔌 Integrations and API

Call the Actor via the Apify API, the JavaScript or Python clients, or connect it with integrations and webhooks (Make, Zapier, n8n, Google Sheets, Slack, Airtable, HubSpot…). The dataset can be fetched as JSON or CSV from any tool; `inputId` brings your own record id back with each row.

### 🤖 Use with AI agents (MCP)

AI agents (Claude, ChatGPT, Cursor…) can find and run this Actor through the [Apify MCP server](https://mcp.apify.com), billed to their Apify account like any run. It returns one item per address. Actor id: `nice_dev/property-owner-skip-trace`; MCP server with this Actor only: `https://mcp.apify.com/?tools=fetch-actor-details,nice_dev/property-owner-skip-trace`.

Smallest input, for a cheap first call:

```json
{
    "addresses": ["18081 SW 41st St, Miramar, FL 33029"],
    "maxItems": 1
}
```

Key output fields: `lookupStatus`, `ownerMatch`, `fullName`, `bestPhone`, `phones`, `emails`, `currentAddress`, `isAbsentee`.

Cost: $11.30 per 1,000 owners found with a phone or an email on the Free plan ($6.80 on Gold), $2.20 per 1,000 addresses searched, plus $0.01 per run (see the pricing section above). Cap each call with `maxItems` and, through the API, with the run option `maxTotalChargeUsd`.

### ❓ FAQ

#### Is it legal to skip trace property owners with this Actor?

The Actor only reads what FastPeopleSearch shows publicly to any anonymous visitor: public records. It logs in to nothing and needs no account. The results are personal data: store and use them only with a legitimate reason, under the privacy laws that apply to you (GDPR, CCPA and the other US state laws). You are responsible for using the data in compliance with the site's Terms of Use and applicable law, in particular:

- **FCRA**: this is not a consumer reporting agency. Never use the results to decide on credit, employment, tenant screening, insurance or any other purpose covered by the Fair Credit Reporting Act.
- **TCPA and Do Not Call**: calling or texting a mobile number with an autodialer or a prerecorded message needs the person's consent; check the numbers against the National Do Not Call Registry before any marketing call. The Actor does not flag them.
- **Data broker laws**: reselling data about people you have no direct relationship with can require a registration (California, Vermont, Texas, Oregon).
- **Daniel's Law (New Jersey)** and similar laws: remove the people who ask for it (judges, law enforcement officers…) within the legal delay.

This Actor is not affiliated with FastPeopleSearch.

#### Is the person returned really the owner?

It is the owner when `ownerMatch` is `name` (the name you gave, found) or `owner_occupied` (the property record says the owner lives there, and this is its most recent resident). The public records do not carry the deed holder's name: for a rented-out home, give the owner's name from the county tax roll, or turn on **Include occupants** to get the resident, marked `occupant`. `livesAtProperty: false` on an `owner_occupied` row means that resident has moved: it may be a previous owner.

#### Am I charged for an address where no owner is found?

The search fee only (`address-search`, $2.20 per 1,000): the site is read to find out that no owner can be named. No owner fee: that is charged only for an owner found with at least one phone number or email (`owner-found`). The address still gets its row, with `lookupStatus` and the reason in `ownerNote`. The same address given twice is searched, and charged, once; a line that cannot be searched is never charged.

#### Does it need a login or an account on the site?

No. Nothing to set up either: leave **Proxy configuration** as it is, it is included in the price.

#### Is the data safe to open in Excel or to show on a web page?

Phone numbers start with `(` or `+` and a few names or addresses start with a digit: when you open a CSV in Excel or Google Sheets, import the phone and ZIP columns as text so that they are not turned into numbers (a ZIP code such as `02111` would lose its leading zero). On a web page, escape every field like any text written by a stranger.

#### Known limitations

- The owner's name is never on the public records of an address: a rented-out home needs the owner's name from you (tax roll, county records), else it is returned as `not_found` (search fee only) or, with **Include occupants**, as its occupant.
- Company, trust and LLC owners are not people: the public records of people do not list them, so their addresses come back `not_found` unless a person is named.
- Each phone number comes with the date it was **first** reported, not the last one; the site says nothing about a number being disconnected, on the Do Not Call list or tied to a litigator.
- Names are matched on first and last names with common nicknames (Bill / William); a very rare nickname is not recognised.
- `onlyNew` remembers owners, not their details: an owner whose phone numbers changed is not returned again.
- Two runs sharing the same `stateKey` at the same time may both return the same new owner.

**A run that reaches its timeout** stops itself about 45 seconds before it: no new page is asked, the owners it read are saved and, with `onlyNew`, remembered, and the run ends *Succeeded* with "Stopped before the run's timeout". Resurrect it to go on from there (the rows of the addresses without an owner are written when it ends), or give a big list a longer timeout (Run options).

**A run the platform stops without warning** (out of memory)

- Resurrect it: it goes on from where it stood at most a minute before the stop, and the owners already saved are skipped: none is delivered or charged twice, and `maxItems` still counts them.
- With `onlyNew`, the memory is saved once a minute: resurrect the stopped run and the owners it had saved meanwhile join the memory; leave it stopped for good, and the next run may return up to a minute of them once more.

#### Something doesn't work?

The last line of the log counts the owners saved, filtered out, and the requests that failed after every retry. Those requests are listed, with the reason, in the `FAILED_REQUESTS` record of the run's key-value store. The `SEARCH_STATS` record lists every address with the number of owners it saved and the reason when there is none, and the lines that were skipped. A run that saved nothing and had failed requests fails, and its last message gives the cause.

If the site changes its pages, you are told instead of paying for blank rows. If the first 20 owners read all lack their name or their relatives, or their phones, the run saves nothing more, stops and fails, and its last message names the missing field: at most those first owners are charged. The same goes for the addresses: if none of the first 20 addresses with people shows a property record, or whether its owner lives there, the run stops and fails instead of charging every address searched for no owner (units of a building, often without a record, do not count). A shorter run is checked at its end, from 5 owners (10 addresses for the address pages): it fails the same way, with the owners it saved.

### 🛟 Support

Open an issue in the **Issues** tab with a link to your run: the run log and the `FAILED_REQUESTS` and `SEARCH_STATS` records of the key-value store show exactly which addresses failed and why.

# Actor input Schema

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

One US property per line: `Street; City, ST ZIP` or `Street, City, ST ZIP` (e.g. `18081 SW 41st St, Miramar, FL 33029`; a unit after its street: `18081 SW 41st St, Apt 5, Miramar, FL 33029`). Add `| Owner name` at the end when you know it (tax roll, county records, in either order): `641 NW 59th Ave; Miami, FL 33126 | Janette Suarez` — the only way to reach the owner of a rented-out home.

## `properties` (type: `array`):

For CRMs and automations: a JSON list of objects with `street`, `city`, `state`, `zip` (or the whole address in `street`), optionally `unit` (or `apt`, `unit #`, `address line 2`), `ownerName` (or `firstName` + `lastName`) and your own `id` (copied to the result as `inputId`). Each object is one property.

## `csvUrl` (type: `string`):

Link to a CSV file (e.g. a Google Sheets `…/export?format=csv` link) with a header row. Recognised columns: `street` / `address` / `property address` (the street, or the whole address), `unit` / `apt` / `address line 2`, `city`, `state`, `zip` (a ZIP code that lost its leading zero, `2108`, is read as `02108`), `owner name` (or `first name` + `last name`), `id`. Each row is one property, like **Properties (structured)**.

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

Maximum number of owners to save for the whole run (after filters). Addresses without an owner found get a row too (search fee only) and do not count. 0 = no limit.

## `includeOccupants` (type: `boolean`):

When the property record says the owner does not live there (rented out) or says nothing, and you gave no owner name: return the most recent resident instead, marked `ownerMatch: occupant` and charged like an owner. Off = a `not_found` row for that address (search fee only).

## `requirePhone` (type: `boolean`):

Drop the owners without any phone number.

## `requireEmail` (type: `boolean`):

Drop the owners without any email.

## `minAge` (type: `integer`):

Drop the owners younger than this. Owners whose age is not known are kept.

## `maxAge` (type: `integer`):

Drop the owners older than this (e.g. 75 for a list of likely sellers). Owners whose age is not known are kept.

## `excludeKeywords` (type: `array`):

Drop the owners whose name contains one of these words (case and accents ignored), e.g. `LLC`, `Trust`.

## `onlyNew` (type: `boolean`):

Skip the owners that a previous run (same **Memory key**) already delivered: they are not saved and not charged, and their report is not even opened. First run = everything is new.

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

Name of the memory used by **Only new owners**. Give each schedule / task its own key (e.g. `miami-absentee`) so that they do not share their memory. Letters, digits, `-` and `_`.

## `resetState` (type: `boolean`):

Forget everything remembered under this **Memory key** before the run: this run returns (and charges) every owner again. Untick it afterwards.

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

Keep the default (Apify Proxy): the access to the sites is included in the price. Your own proxies (custom proxy URLs) are used instead when you give them. The residential Apify proxy is not available in this Actor.

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

Maximum number of pages read in parallel.

## `maxRequestsPerMinute` (type: `integer`):

Most page requests in any 60 seconds, address pages and owner reports counted. A budget, not an even pace (spread them with the minimum delay below). Lower it if the log shows many refused pages.

## `minRequestIntervalMs` (type: `integer`):

Smallest gap between two requests, in milliseconds. Unlike the per-minute rate, this spreads the requests evenly. 0 = no gap.

## `maxRequestRetries` (type: `integer`):

Retries per page before it is marked as failed.

## `debugLog` (type: `boolean`):

Include debug messages in the run log.

## Actor input object example

```json
{
  "addresses": [
    "18081 SW 41st St, Miramar, FL 33029"
  ],
  "properties": [],
  "maxItems": 100,
  "includeOccupants": false,
  "requirePhone": false,
  "requireEmail": false,
  "excludeKeywords": [],
  "onlyNew": false,
  "stateKey": "default",
  "resetState": false,
  "proxyConfiguration": {
    "useApifyProxy": true
  },
  "maxConcurrency": 5,
  "maxRequestsPerMinute": 120,
  "minRequestIntervalMs": 0,
  "maxRequestRetries": 5,
  "debugLog": false
}
```

# Actor output Schema

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

No description

## `searchStats` (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 = {
    "addresses": [
        "18081 SW 41st St, Miramar, FL 33029"
    ],
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("nice_dev/property-owner-skip-trace").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 = {
    "addresses": ["18081 SW 41st St, Miramar, FL 33029"],
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("nice_dev/property-owner-skip-trace").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 '{
  "addresses": [
    "18081 SW 41st St, Miramar, FL 33029"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call nice_dev/property-owner-skip-trace --silent --output-dataset

```

## MCP server setup

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

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/Ry7o3SVj41deDvK13/builds/8LDHzaqYafFEMbxlQ/openapi.json