# New England Property Records: Owner & Assessor Lookup (`spheric_outcrop/new-england-property-records`) Actor

Look up owners, assessed values, year built and sales (where published) for New England parcels by address or parcel ID. Open government GIS data.

- **URL**: https://apify.com/spheric_outcrop/new-england-property-records.md
- **Developed by:** [Joshua Herrick](https://apify.com/spheric_outcrop) (community)
- **Categories:** Real estate, Lead generation, Integrations
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

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

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

## New England Property Records Lookup

Look up property and assessor records for New England parcels by **town + street address** or **town + parcel ID**. Each result gives the owner, assessed land/building/total values, year built, zoning or land use, acreage and the last sale where the source publishes them, plus the source link and data vintage.

All data comes from **openly published government GIS and open-data services** (statewide and municipal ArcGIS layers, plus the City of Providence open data portal). This Actor does not log in anywhere, does not solve CAPTCHAs, and does not scrape paid or bot-restricted assessor portals.

### What it does

- Takes one lookup or a batch of lookups (town + address, or town + parcel ID).
- Finds the matching parcel(s) in the best public source for that town.
- Returns one clean, normalized record per matched parcel, with the same field names for every state.
- Labels every record `full`, `partial` or `limited` in `field_coverage`, and explains gaps in `notes`, so you always know how complete it is (`partial` means the source had an owner or values, but not both).
- Gives a source name, query URL, data vintage and retrieval time on every record so you can check it yourself.

### Who it's for

- **Real estate investors and wholesalers** - check owner, assessed value and last sale before you make an offer or send mail.
- **Agents and brokers** - pull owner of record and assessment details for prospecting and CMAs.
- **Lenders, title and appraisal teams** - fast first-pass parcel lookups before ordering official documents.
- **Lead-gen and data teams** - enrich address lists with owner and value fields in batch.
- **Developers and AI agents** - call it through the Apify API, or from an AI agent through Apify's MCP server (`mcp.apify.com`), and get structured JSON back.

### Coverage

Town counts are from the coverage check on Oct 12, 2026.

| State | FULL records (owner + assessed values) | LIMITED records (parcel ID + address; acreage in NH) | Not covered |
| --- | --- | --- | --- |
| **Massachusetts** | 351 cities and towns (MassGIS statewide) | - | - |
| **Vermont** | 260 municipalities (VCGI parcels + Tax Dept grand list) | - | No sale history or year built in the statewide data |
| **Connecticut** | 169 municipalities (CT GIS Office CAMA and Parcel Layer, 2026 collection) | - | - |
| **Maine** | 187 organized towns (177 via GeoLibrary parcels + assessor table, plus 10 town layers: Appleton, Cushing, Deer Isle, Durham, Eliot, Hope, Orono, Pittsfield, Searsmont, Washington) | About 133 organized towns (parcel only) | Unorganized territories (their open data is PDF valuation books, not a queryable layer) |
| **New Hampshire** | 18 towns: Manchester, Nashua, Alton, Barrington, Candia, Farmington, Hooksett, Keene, Lee\*, Litchfield, Merrimack, Milton, North Hampton, Northwood\*, Nottingham, Peterborough, Rollinsford, Stratham | About 218 other towns (NH GRANIT parcel mosaic), for example Concord, Portsmouth, Dover, Bradford, Henniker | - |
| **Rhode Island** | 13 municipalities: Providence, Cranston, Barrington, Burrillville, Coventry, Foster, Glocester, Johnston, Lincoln, Middletown, Narragansett, North Smithfield, South Kingstown | - | The other 26 RI cities and towns (for example Warwick, Pawtucket, East Providence, Newport, Westerly) |

\* Lee and Northwood publish the street name only (no house number), so a lookup returns the parcels on that street.

**What FULL and LIMITED mean**

| Field | FULL | LIMITED (NH GRANIT, ME parcel-only) |
| --- | --- | --- |
| town, state, parcel_id, address | Yes | Yes |
| owner / co_owner | Yes | No (NH GRANIT shows a placeholder ID, so the Actor returns null) |
| mailing_address | Usually | No |
| assessed_land / assessed_building / assessed_total | Yes | No |
| last_sale_date / last_sale_price / sale_history | When the source publishes it | No |
| year_built | When the source publishes it | No |
| zoning / land use | When published | Land-use codes when present |
| acreage | When published | Yes (NH, from parcel geometry) |
| source, source_name, source_url, data_vintage, retrieved_at, field_coverage, notes | Yes | Yes |

### Input

Single lookup by address:

```json
{
  "town": "Manchester",
  "address": "102 Elm St",
  "maxResultsPerLookup": 5
}
```

Outside New Hampshire, set `state` (or write the town as `"Cranston, RI"`). If you leave `state` out, the Actor assumes NH.

```json
{
  "town": "Cranston",
  "state": "RI",
  "address": "43 Church Hill Drive"
}
```

Lookup by parcel ID:

```json
{
  "town": "Litchfield",
  "parcelId": "1-28"
}
```

Batch (`listMode`):

```json
{
  "listMode": true,
  "lookups": [
    { "town": "Peterborough", "address": "48 KEENAN DR" },
    { "town": "Boston", "state": "MA", "address": "865 Saratoga ST" },
    { "town": "Burlington", "state": "VT", "address": "43 EDSON ST" },
    { "town": "Hartford", "state": "CT", "address": "55 BRISTOL ST" },
    { "town": "Portland", "state": "ME", "address": "1531 CONGRESS ST" },
    { "town": "Cranston", "state": "RI", "address": "43 CHURCH HILL DRIVE" },
    { "town": "Bradford", "address": "172 BREEZY HILL ROAD" }
  ],
  "maxResultsPerLookup": 3
}
```

| Input field | What it does |
| --- | --- |
| `town` | Municipality name. Required (per lookup in batch mode). |
| `state` | `NH` (default), `MA`, `VT`, `CT`, `ME` or `RI`. |
| `address` | Street address. Partial street-name matches are supported. |
| `parcelId` | Parcel / map-lot ID. Used when `address` is empty. |
| `listMode` + `lookups` | Run many lookups in one run. One bad lookup does not stop the batch. |
| `maxResultsPerLookup` | Most records returned per lookup (default 10, max 100). |
| `requestDelayMs` | Pause between queries to the public servers (default 400 ms). |

### Output

A real FULL record (Worcester, MA; `source_url` shortened here):

```json
{
  "town": "WORCESTER",
  "state": "MA",
  "parcel_id": "01_01E_00036",
  "address": "15 SAGAMORE RD",
  "owner": "SAGAMORE + GROVE LLC",
  "co_owner": null,
  "mailing_address": "100 INSTITUTE RD, WORCESTER, MA, 01609",
  "assessed_land": 313000,
  "assessed_building": 3903800,
  "assessed_total": 4297600,
  "last_sale_date": "2017-08-01",
  "last_sale_price": 2625000,
  "sale_history": [
    { "date": "2017-08-01", "price": 2625000, "book_page": "57516/0288" }
  ],
  "zoning": "BG-3 / Research and Development facilities",
  "acreage": 3.37,
  "year_built": "1955",
  "source": "ma-massgis",
  "source_name": "MassGIS (Commonwealth of Massachusetts) — Property Tax Parcels (Level 3 + assessor extract)",
  "source_url": "https://services1.arcgis.com/hGdibHYSPO59RG1h/arcgis/rest/services/Massachusetts_Property_Tax_Parcels/FeatureServer/0/query?...",
  "data_vintage": "FY2026",
  "retrieved_at": "2026-10-07T02:02:18.301Z",
  "field_coverage": "full",
  "notes": null
}
```

A real LIMITED record (Bradford, NH; `source_url` shortened):

```json
{
  "town": "Bradford",
  "state": "NH",
  "parcel_id": "018-001-000",
  "address": "172 BREEZY HILL ROAD",
  "owner": null,
  "assessed_total": null,
  "last_sale_date": null,
  "year_built": null,
  "zoning": "11 / 11 / N-E",
  "acreage": 0.1993,
  "source": "granit",
  "source_name": "NH GRANIT / NHDRA Parcel Mosaic",
  "source_url": "https://nhgeodata.unh.edu/nhgeodata/rest/services/CAD/ParcelMosaic/MapServer/1/query?...",
  "field_coverage": "limited",
  "notes": "GRANIT public Name field is a CamaID placeholder (owner/values require town assessor or licensed feed). Limited GRANIT fields: no assessed values, sale history, or year built on public REST. ..."
}
```

You can download results as JSON, CSV, Excel, XML or HTML from the dataset, or read them through the API.

### Pricing

**Pay per event: $0.035 per property record returned** (event: `property-record`).

- You pay for each matched parcel record in the dataset.
- **No charge** for "no match" results, unsupported towns (for example Warwick, RI) or lookups that fail because a public server is down. These still show up in the dataset with a note, so you can see what happened.
- LIMITED records are matched parcels too, so they cost the same $0.035. Check the coverage table first if you only want FULL records.
- One lookup can return more than one record (for example a street-only search, or a partial address that matches several units). `maxResultsPerLookup` caps this.

| Records returned | Cost |
| ---: | ---: |
| 100 | $3.50 |
| 1,000 | $35.00 |
| 10,000 | $350.00 |

Example: a batch of 1,000 addresses with `maxResultsPerLookup: 1`, where 950 match and 50 don't, costs 950 x $0.035 = **$33.25**.

Set a maximum cost per run in the run options. When it is reached, the Actor stops adding records.

### Limitations and data freshness

- **Data is only as current as the public layer.** Each record has `data_vintage` and `retrieved_at`. Vintages seen in testing:
  - MA: FY2018 to FY2027 in the current MassGIS layer, depending on the town (most towns are recent; check `data_vintage`).
  - CT: 2026 statewide CAMA collection (each town's valuation year varies, often 2021 to 2025).
  - VT: grand list 2025.
  - NH: Peterborough, Litchfield and North Hampton are 2026. Farmington is 2025, Merrimack about 2023, Keene a Dec 2022 snapshot, and Stratham, Hooksett, Lee, Milton, Nottingham and Rollinsford about 2020-2021. Nashua and Alton are 2026, Candia 2025.
  - RI: Cranston is a live city layer. Providence is the 2025 city tax roll. Glocester and Foster are 2025-2026, Burrillville Dec 2024. Narragansett, North Smithfield, Barrington, Coventry and Johnston are about 2022. South Kingstown is as of May 2021.
  - ME town layers: Durham 2025; Eliot, Deer Isle, Orono, Appleton, Hope and Washington 2025-2026 (Cushing, Searsmont and Washington publish last year's values).
- **Not every field is in every source.** VT has no sales or year built. Barrington, Northwood, Alton and Candia (NH), Middletown (RI) and Eliot (ME) publish no sales. Providence (RI) publishes owner and total assessment only. Milton, Nottingham and Rollinsford (NH) publish sale dates but no prices. Year built is missing for some towns and parcels.
- **Sale prices of $0 or $1** usually mean a nominal or non-arm's-length transfer (for example family or trust transfers), exactly as the source recorded them.
- **Maine sale fields are often empty in the source.** Many records show `1899-12-30` / `0`, which is a blank placeholder in the source data, not a real sale. Treat it as "no sale data".
- **Date formats follow the source.** Most are `YYYY-MM-DD`, but Manchester, NH uses `M/D/YYYY`.
- **Connecticut assessed values are 70% of appraised value**, as state law requires.
- **Most NH towns and about 133 ME towns are LIMITED.** No owner or values.
- **Single parcels can be LIMITED even in a FULL town.** For example, a Maine parcel with no matching assessor row comes back `limited` with a note. It is still a matched parcel and is charged.
- **Rhode Island covers 13 of 39 municipalities.** The state has no open statewide layer with owners and values; towns without an open municipal layer are not supported.
- **Lookups only.** You search by address or parcel ID. Owner-name search and whole-town exports are not supported.
- Manchester, NH parcels that the city marks as suppressed from internet access are skipped.
- Public government servers can be slow or briefly unavailable. A failed lookup is reported in the dataset and is not charged.

### Data sources and disclaimer

Data is published by public agencies and their GIS partners: MassGIS (MA), VCGI and the VT Department of Taxes (VT), CT Office of Policy and Management / CT GIS Office (CT), Maine GeoLibrary / MaineIT GIS (ME), NH GRANIT / NHDRA, NH regional planning commissions and NH municipal GIS (NH), Maine municipal and county GIS (ME), and RI municipal GIS and the City of Providence open data portal (RI). Each record names its source in `source_name` and `source_url`.

The data was collected for tax assessment and GIS purposes. **Neither this Actor nor the source agencies guarantee that it is accurate, complete, current or fit for any particular use.** This Actor is not affiliated with or endorsed by any of these agencies.

**This is not a title search, appraisal, survey, or legal or financial advice.** Before any transaction, lending decision or legal filing, confirm owner, value and sale details with the town assessor and the registry of deeds. You are responsible for using the data lawfully, including any rules on marketing, fair lending and fair housing, and contact compliance that apply to you.

**Sources not used:** vendor-hosted assessor portals that block automated access or charge for access (AxisGIS, Avitar kiosks, Vision/VGSI web pages).

### FAQ

**Which towns give full owner and value data?**
All of MA, VT and CT; 187 Maine towns; 18 NH towns; and 13 RI municipalities. See the coverage table above. Every record also says `full` or `limited` in `field_coverage`.

**Why is the owner empty for my NH town?**
Most NH towns don't publish owners or values in an open GIS layer. For those towns the Actor falls back to the statewide GRANIT parcel map, which has parcel ID, address and acreage only.

**Am I charged when nothing is found?**
No. No-match, unsupported-town and error results are free.

**How current is the data?**
As current as the public source. Check `data_vintage` on each record and the freshness notes above. Some NH and RI layers are several years old.

**Can I search by owner name, or download a whole town?**
Not right now. Lookups are by address or parcel ID. Use batch mode for long address lists.

**Can I use this from an AI agent or my own app?**
Yes. Run it through the Apify API, SDKs, integrations (Zapier, Make, n8n and others), or Apify's MCP server at `mcp.apify.com` so AI agents can call it as a tool.

**Is this data legal to use?**
The Actor only reads data that agencies publish openly for public access. How you use the data (for example for marketing or lending decisions) is your responsibility. This is not legal advice.

**My town or state isn't covered. Can you add it?**
Open an issue with the town name. New towns are added when a public layer with owners and assessed values becomes available.

### Support

Report problems or request towns in the **Issues** tab of this Actor. Please include the town, state, the address or parcel ID you searched, and the run ID.

# Actor input Schema

## `town` (type: `string`):

Municipality name (e.g. Bradford, Manchester, Boston, Burlington, Hartford, Portland, Cranston). For non-NH towns set state or append ", RI".

## `address` (type: `string`):

Situs street address to search (e.g. "172 Breezy Hill Road"). Partial street-name matches are supported.

## `parcelId` (type: `string`):

Parcel / map-lot ID (e.g. "18-001-00" or Manchester ParcelID). Used when address is empty.

## `listMode` (type: `boolean`):

If true, process the lookups array (batch). Each item needs town + address and/or parcelId.

## `lookups` (type: `array`):

Array of { town, address?, parcelId? } objects when listMode is true.

## `maxResultsPerLookup` (type: `integer`):

Cap matches returned for a single address/parcel search (default 10).

## `requestDelayMs` (type: `integer`):

Polite pause between ArcGIS queries (default 400).

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

Optional state code: NH (default), MA, VT, CT, ME, or RI. Also accepted as suffix on town ("Cranston, RI").

## Actor input object example

```json
{
  "town": "Manchester",
  "address": "102 Elm St",
  "listMode": false,
  "maxResultsPerLookup": 10,
  "requestDelayMs": 400,
  "state": "NH"
}
```

# Actor output Schema

## `results` (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 = {
    "town": "Manchester",
    "address": "102 Elm St",
    "state": "NH"
};

// Run the Actor and wait for it to finish
const run = await client.actor("spheric_outcrop/new-england-property-records").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 = {
    "town": "Manchester",
    "address": "102 Elm St",
    "state": "NH",
}

# Run the Actor and wait for it to finish
run = client.actor("spheric_outcrop/new-england-property-records").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 '{
  "town": "Manchester",
  "address": "102 Elm St",
  "state": "NH"
}' |
apify call spheric_outcrop/new-england-property-records --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,spheric_outcrop/new-england-property-records"
        }
    }
}
```

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/9O6pwTkYKGapcbdkY/builds/Ua7YAVDg8phZrw3z6/openapi.json