# NYC ACRIS Property Records Scraper (`automation-lab/nyc-acris-property-records-scraper`) Actor

Search and export official NYC ACRIS deeds, mortgages, assignments, parties, recorded amounts, parcels, and source links for title research.

- **URL**: https://apify.com/automation-lab/nyc-acris-property-records-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Real estate
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.68 / 1,000 acris 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?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.
Actors are written with capital "A".

## 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.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

## NYC ACRIS Property Records Scraper

Search and export **NYC ACRIS property records** from the official NYC Open Data ACRIS datasets. Find deeds, mortgages, assignments, and other recorded documents by parcel, address, party name, document ID, document type, or recording date.

Each result is a normalized property-document record with its document ID, CRFN, recording date, amount, transfer percentage, parcels, parties, references, and canonical source links. This is useful for title research, transaction research, real-estate intelligence, and repeatable data pipelines.

### What does this Actor do?

The Actor joins four official ACRIS data surfaces:

- Real Property Master records
- Real Property Legals and parcel addresses
- Real Property Parties
- Real Property References

It turns those separate tables into one dataset row per ACRIS document. You do not need to download and join large citywide files yourself.

Supported searches include:

- borough, block, and lot (BBL)
- street name and optional exact street number
- recorded party name or leading-name prefix
- one or more current or legacy ACRIS document IDs
- recording-date range
- document-type codes such as `DEED`, `MTGE`, `ASST`, and `SAT`

### Who is it for?

**Title researchers** can retrieve the document chain, parties, parcel references, and source links for a known property.

**Real-estate analysts** can export deeds or mortgages recorded during a selected period and compare transaction amounts.

**Proptech teams** can feed normalized ACRIS documents into warehouses, enrichment jobs, and internal search tools.

**Brokerage and investment teams** can research recorded parties and connect documents back to BBLs and addresses.

**Legal and compliance teams** can preserve source-attributed public-record extracts for a defined research question.

### Why use this Actor?

- Uses official NYC Open Data rather than scraping a rendered search page.
- Joins documents, parcels, parties, and references into one usable record.
- Supports precise parcel and document-ID workflows as well as date searches.
- Returns stable identifiers and both ACRIS and NYC Open Data source URLs.
- Applies bounded retries for transient NYC Open Data rate limits or server errors.
- Charges only for dataset rows actually produced; joined parties and parcels have no separate event charge.

### What data can I extract?

| Field | Description |
| --- | --- |
| `documentId` | Current 16-digit or legacy ACRIS document identifier |
| `crfn` | City Register File Number, when assigned |
| `documentType` | ACRIS document-type code, such as `DEED` or `MTGE` |
| `documentDate` | Date stated on the document |
| `recordedDate` | Date recorded or filed |
| `recordedAmount` | Document amount reported by ACRIS |
| `percentTransferred` | Transfer percentage when available |
| `recordedBoroughName` | Human-readable master-record borough |
| `parcels` | BBL, address, unit, property type, and partial-lot status |
| `parties` | Party role, name, and public mailing-address fields |
| `references` | Referenced CRFN, document ID, or legacy reel/page |
| `acrisDocumentUrl` | Canonical ACRIS document-view link |
| `sourceUrl` | Official NYC Open Data API link for the record |
| `sourceGoodThroughDate` | Freshness date reported by the source |
| `scrapedAt` | UTC extraction timestamp |

Null values mean the official source did not provide that value for the document. Empty `parties` or `references` arrays can also result when those joins are disabled.

### How to search ACRIS by borough, block, and lot

Use borough code `1` through `5` with both `block` and `lot`:

```json
{
  "borough": 4,
  "block": 12992,
  "lot": 42,
  "documentTypes": ["DEED", "MTGE"],
  "includeParties": true,
  "includeReferences": true,
  "maxItems": 10
}
```

Borough codes are:

1. Manhattan
2. Bronx
3. Brooklyn
4. Queens
5. Staten Island

The Actor searches the legal/parcel table first and then joins matching master documents and parties.

### How to search ACRIS by party name

Supply a full recorded name or a leading-name prefix:

```json
{
  "partyName": "HILLSIDE BUYERS LLC",
  "includeParties": true,
  "includeReferences": true,
  "maxItems": 20
}
```

Party matching follows the text recorded in ACRIS. Corporate suffixes, punctuation, initials, and name order can affect results. Start with the exact recorded name when possible, then shorten from the end if needed.

### How to export recent deeds and mortgages

Use a recording-date range with document types:

```json
{
  "borough": 1,
  "documentTypes": ["DEED", "MTGE"],
  "recordedFrom": "2026-07-01",
  "recordedTo": "2026-07-31",
  "includeParties": true,
  "includeReferences": true,
  "maxItems": 100
}
```

Dates use `YYYY-MM-DD`. `recordedFrom` is inclusive and `recordedTo` includes the complete selected day.

### Input parameters

| Input | Type | Default | Notes |
| --- | --- | --- | --- |
| `borough` | integer | none | Optional borough code from 1 to 5 |
| `block` | integer | none | Must be supplied together with `lot` |
| `lot` | integer | none | Must be supplied together with `block` |
| `streetNumber` | string | none | Exact house number; requires `streetName` |
| `streetName` | string | none | Leading street-name text |
| `partyName` | string | none | Full party name or leading-name prefix |
| `documentIds` | string array | none | Current 16-digit or legacy `FT_`/`BK_` IDs |
| `documentTypes` | string array | none | ACRIS document-type codes |
| `recordedFrom` | date string | none | Inclusive recording-date lower bound |
| `recordedTo` | date string | none | Inclusive recording-date upper bound |
| `includeParties` | boolean | `true` | Include joined party rows |
| `includeReferences` | boolean | `true` | Include referenced document/reel rows |
| `maxItems` | integer | `20` | From 1 to 10,000 result documents |

Provide at least one search selector: document IDs, party name, street name, block and lot, or a recording-date bound.

### Output example

The default dataset contains one object per matched document:

```json
{
  "documentId": "2026072400844001",
  "crfn": "2026000215302",
  "recordType": "A",
  "documentType": "DEED",
  "documentDate": "2026-07-16",
  "recordedDate": "2026-07-31",
  "modifiedDate": "2026-07-31",
  "recordedAmount": 570220,
  "percentTransferred": 100,
  "recordedBorough": 1,
  "recordedBoroughName": "Manhattan",
  "reelYear": 0,
  "reelNumber": 0,
  "reelPage": 0,
  "parcels": [
    {
      "borough": 4,
      "boroughName": "Queens",
      "block": 12992,
      "lot": 42,
      "bbl": "4129920042",
      "streetNumber": "178-35",
      "streetName": "137 AVENUE",
      "unit": null,
      "propertyType": "D1",
      "partialLot": false
    }
  ],
  "parties": [
    {
      "partyType": "2",
      "name": "HILLSIDE BUYERS LLC",
      "address": "147-20 HILLSIDE AVENUE",
      "city": "JAMAICA",
      "state": "NY",
      "zip": "11435",
      "country": "US"
    }
  ],
  "references": [],
  "acrisDocumentUrl": "https://a836-acris.nyc.gov/DS/DocumentSearch/DocumentImageView?doc_id=2026072400844001",
  "sourceUrl": "https://data.cityofnewyork.us/resource/bnx9-e6tj.json?document_id=2026072400844001",
  "sourceDataset": "NYC Open Data — ACRIS Real Property",
  "sourceGoodThroughDate": "2026-07-31",
  "scrapedAt": "2026-09-01T06:20:00.000Z"
}
```

This is a public-record example. Mailing-address fields come from ACRIS and may be absent or historical.

### How much does it cost to export NYC ACRIS property records?

Pay-per-event pricing consists of:

- **$0.005 per run** for the start event
- **$0.0028 per property record on the BRONZE plan**

The per-record rate decreases on higher Apify plans. Parties, parcels, and references included inside a property-record row do not trigger separate events.

Example BRONZE costs:

| Useful records | Estimated Actor charge |
| ---: | ---: |
| 1 | $0.0078 |
| 10 | $0.033 |
| 100 | $0.285 |
| 1,000 | $2.805 |

These examples cover Actor events, not any separate Apify platform usage charged under your account plan. A no-result run normally incurs only the start event.

### Getting started

1. Open the Actor in Apify Console.
2. Choose a parcel, party, document, address, or recording-date search.
3. Keep `maxItems` small for the first run.
4. Decide whether party and reference joins are needed.
5. Click **Start**.
6. Inspect the **Dataset** tab.
7. Export results as JSON, CSV, Excel, XML, or RSS through Apify dataset tools.
8. Save the configuration as an Apify Task if you will run it repeatedly.

### Useful workflows

#### Parcel title research

Start with a known BBL. Export all matching documents, sort by `recordedDate`, and follow `references` and `acrisDocumentUrl` for source review.

#### Recent transaction feed

Schedule a Task with a narrow recording-date window and selected document types. Load the dataset into a warehouse and deduplicate by `documentId`.

#### Party-to-property research

Search a recorded business or person name, then expand each result's `parcels` array to obtain BBL and address context.

#### Document enrichment

Supply known `documentIds` from another system. The Actor returns normalized master, parcel, party, and reference fields for downstream processing.

### Scheduling and integrations

Apify Tasks can run on a schedule. Common destinations include:

- Google Sheets through Make or Zapier
- webhooks for internal automation
- Amazon S3, Google Drive, or Dropbox exports
- SQL warehouses and BI pipelines
- Python or JavaScript data-processing jobs

For incremental pipelines, persist the last accepted `recordedDate` and `documentId`. Advance the checkpoint only after downstream storage succeeds.

### Run with the Apify API using cURL

Replace `APIFY_TOKEN` with your token:

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~nyc-acris-property-records-scraper/runs?token=APIFY_TOKEN&waitForFinish=300" \
  -H "Content-Type: application/json" \
  -d '{
    "borough": 1,
    "documentTypes": ["DEED", "MTGE"],
    "recordedFrom": "2026-07-01",
    "recordedTo": "2026-07-31",
    "maxItems": 25
  }'
```

The run response includes `defaultDatasetId`. Fetch its records from `/v2/datasets/{datasetId}/items`.

### Run with JavaScript

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/nyc-acris-property-records-scraper').call({
  borough: 4,
  block: 12992,
  lot: 42,
  documentTypes: ['DEED', 'MTGE'],
  includeParties: true,
  maxItems: 20,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

### Run with Python

```python
import os
from apify_client import ApifyClient

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/nyc-acris-property-records-scraper').call(run_input={
    'partyName': 'HILLSIDE BUYERS LLC',
    'includeParties': True,
    'includeReferences': True,
    'maxItems': 20,
})

items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

### Use with MCP and AI assistants

Add the Actor to Claude Code through Apify MCP:

```bash
claude mcp add --transport http apify \
  "https://mcp.apify.com?tools=automation-lab/nyc-acris-property-records-scraper"
```

#### Claude Desktop, Cursor, and VS Code setup

Desktop and editor clients can use this Apify MCP server configuration:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=automation-lab/nyc-acris-property-records-scraper"
    }
  }
}
```

Example prompts:

- "Export Manhattan deeds and mortgages recorded in July 2026, maximum 25 records."
- "Find ACRIS documents for Queens block 12992 lot 42 and include parties."
- "Research documents recorded under HILLSIDE BUYERS LLC and summarize the parcels."

Verify source links before relying on an AI-generated legal or financial conclusion.

### Reliability and retries

The Actor uses the official public Socrata JSON API and does not require a browser, login, or proxy. Each API call has a timeout and up to three attempts for transient failures.

A deterministic invalid query fails immediately. HTTP 429 and server errors receive bounded exponential backoff. If all attempts fail, the run exits as failed rather than returning a misleading partial success.

Use narrower filters when a broad party or street prefix scans too many source records. For repeat runs, keep each date interval bounded.

### Limits and source freshness

- ACRIS covers recorded property documents, not every fact about a property.
- Party names and addresses reflect recorded source text and can be historical.
- Document-type codes are ACRIS codes, not expanded legal interpretations.
- A master record can reference parcels in a different borough than its master `recordedBorough`; inspect `parcels` for property location.
- The Actor returns up to 10,000 documents per run.
- Source updates are controlled by NYC, and `sourceGoodThroughDate` reports the available freshness boundary.
- Naturally empty queries produce no dataset items.
- This Actor does not download document images or PDFs.
- This Actor does not provide title insurance, legal advice, ownership certification, or a complete title opinion.

### Responsible use and legality

ACRIS and NYC Open Data are public government-record sources. Public availability does not remove your obligations.

Use the data for lawful research. Respect applicable privacy, fair-housing, consumer-reporting, marketing, and data-retention rules. Do not use public mailing addresses for harassment, unlawful discrimination, or unsupported identity conclusions.

Names can collide, entities can use variants, and recordings can be corrected. Confirm material decisions against the canonical source document and consult a qualified professional for legal title work.

### FAQ

#### Does this Actor certify legal ownership or title?

No. It exports public ACRIS records for research. Confirm material conclusions against source documents and use a qualified title or legal professional when needed.

#### Can I schedule an incremental ACRIS feed?

Yes. Save the input as an Apify Task, use narrow recording-date windows, schedule the Task, and deduplicate downstream by `documentId`.

### Troubleshooting

#### The run says I must provide a selector

Add at least one of: `documentIds`, `partyName`, `streetName`, `block` plus `lot`, `recordedFrom`, or `recordedTo`.

#### My block search fails

Supply both `block` and `lot`. Add the correct borough code for a precise BBL.

#### A party search returns no results

Use the recorded name spelling and remove words from the end. The search supports full names and leading prefixes, not arbitrary middle-of-name substrings.

#### I received zero records

Check date bounds, borough, document-type codes, and source freshness. Remove one optional filter at a time. A zero-result search is not retried because it can be a valid source response.

#### The source timed out

Retry after a short interval or narrow a broad search. The Actor already retries transient requests three times, so repeated failures usually indicate a temporary NYC Open Data problem or an expensive unindexed query.

#### Why are `parties` or `references` empty?

The document may have no matching rows, or the relevant include option may be disabled. Empty joined arrays are not charged separately.

### Related Automation Lab Actors

- [NYC DOB NOW Building Permits Scraper](https://apify.com/automation-lab/nyc-dob-now-building-permits-scraper) — complement recorded-property research with permit activity.
- [NYC Restaurant Inspection Results Scraper](https://apify.com/automation-lab/nyc-restaurant-inspection-results-scraper) — research public inspection records for NYC food-service locations.

Use ACRIS for recorded deeds, mortgages, parties, and parcels. Use the related Actors only when the buyer job also needs those separate public-record domains.

### Data provenance

Primary datasets:

- ACRIS - Real Property Master (`bnx9-e6tj`)
- ACRIS - Real Property Parties (`636b-3b5g`)
- ACRIS - Real Property Legals (`8h5j-fqxa`)
- ACRIS - Real Property References (`pwkr-dpni`)

Every dataset item retains official source URLs, source freshness, and the extraction timestamp so downstream users can audit where the record came from.

# Actor input Schema

## `borough` (type: `integer`):

Optional NYC borough filter. Required for a precise BBL search.

## `block` (type: `integer`):

NYC tax block. Supply together with lot.

## `lot` (type: `integer`):

NYC tax lot. Supply together with block.

## `streetNumber` (type: `string`):

Optional exact house number used with streetName, for example 350.

## `streetName` (type: `string`):

Search ACRIS parcel addresses whose street name starts with this text, for example 5TH AVENUE.

## `partyName` (type: `string`):

Search grantor, grantee, lender, borrower, or other recorded party names. Full names and leading-name prefixes are supported.

## `documentIds` (type: `array`):

Fetch specific current or legacy ACRIS document IDs. Other document/date filters still apply.

## `documentTypes` (type: `array`):

Optional ACRIS document-type codes such as DEED, MTGE, ASST, or SAT.

## `recordedFrom` (type: `string`):

Include documents recorded on or after this date (YYYY-MM-DD).

## `recordedTo` (type: `string`):

Include documents recorded on or before this date (YYYY-MM-DD).

## `includeParties` (type: `boolean`):

Join recorded party names and public mailing addresses to each document.

## `includeReferences` (type: `boolean`):

Join referenced CRFNs, document IDs, and reel/page identifiers.

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

Maximum number of matched ACRIS documents saved to the dataset.

## Actor input object example

```json
{
  "borough": 1,
  "documentTypes": [
    "DEED",
    "MTGE"
  ],
  "recordedFrom": "2026-07-01",
  "recordedTo": "2026-07-31",
  "includeParties": true,
  "includeReferences": true,
  "maxItems": 20
}
```

# Actor output Schema

## `dataset` (type: `string`):

Default dataset containing all matched ACRIS documents.

# 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 = {
    "borough": 1,
    "documentTypes": [
        "DEED",
        "MTGE"
    ],
    "recordedFrom": "2026-07-01",
    "recordedTo": "2026-07-31",
    "maxItems": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/nyc-acris-property-records-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "borough": 1,
    "documentTypes": [
        "DEED",
        "MTGE",
    ],
    "recordedFrom": "2026-07-01",
    "recordedTo": "2026-07-31",
    "maxItems": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/nyc-acris-property-records-scraper").call(run_input=run_input)

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

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

```

## CLI example

```bash
echo '{
  "borough": 1,
  "documentTypes": [
    "DEED",
    "MTGE"
  ],
  "recordedFrom": "2026-07-01",
  "recordedTo": "2026-07-31",
  "maxItems": 20
}' |
apify call automation-lab/nyc-acris-property-records-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,automation-lab/nyc-acris-property-records-scraper"
        }
    }
}

```

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

## OpenAPI specification

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