# Property Deed & Lien Records Search (`shelvick/property-deed-records`) Actor

Search US property deed and lien records by LLC or company name, covered property address, or NYC parcel. Returns normalized recorded documents: deeds, mortgages, releases, liens — grantor/grantee, dates, instrument numbers, and book/page references.

- **URL**: https://apify.com/shelvick/property-deed-records.md
- **Developed by:** [Scott Helvick](https://apify.com/shelvick) (community)
- **Categories:** Real estate, Developer tools
- **Stats:** 1 total users, 1 monthly users, 80.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $4.25 / 1,000 recorded document delivereds

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/platform/actors/running/actors-in-store#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

## Property Deed & Lien Records Search

Search public recorder indexes for property deeds, mortgages, releases, liens, satisfactions, assignments, easements, and related recorded documents. Submit a company or LLC name in any covered jurisdiction, a covered US address, or an NYC BBL, and get normalized JSON with grantors, grantees, recording dates, instrument numbers, book/page references, parcel or legal data where published, consideration where published, and cross-references — never document images.

The registry currently spans 240 jurisdictions across 26 states and territories. That count describes registered routes, not identical capabilities or jurisdiction levels: coverage includes counties, Massachusetts registry districts, Connecticut, Rhode Island, and Vermont municipalities, statewide Alaska, and territory-wide U.S. Virgin Islands. Read the run's `COVERAGE` artifact for the authoritative capability snapshot.

### What this does

- Searches recorded-document indexes maintained by county recorder offices and equivalent public recording authorities.
- Finds property records by LLC or company name through `partyLookups`; a state-level search checks all eligible covered jurisdictions in that state, while routes requiring an explicit district return guidance.
- Searches NYC addresses through the native street index. Elsewhere, resolves a covered address to its current owner of record and searches that name in the recorder party index.
- Normalizes source labels into `deed`, `mortgage`, `release`, `lien`, `satisfaction`, `assignment`, `easement`, or `other`, while preserving the recorder's original label in `document_type_raw`.
- Returns one `document` row per delivered index entry and one free `lookup_summary` row per lookup.
- Applies optional recording-date and document-type filters, with a per-lookup result cap from 1 to 1,000.
- Pushes each document row before charging for it. Unsupported lookups, uncovered jurisdictions, no-match results, source failures, and summary rows are free.

Typical workflows include:

- Find every recorded deed, mortgage, release, lien, and assignment for a company or LLC.
- Reconstruct an entity's recorded property-document portfolio across supported recorder offices.
- Review documents indexed under a property's current owner; this is not a full historical ownership-chain walk.
- Monitor new recorded documents for a known entity within a recording-date window.
- Build normalized recorder-index datasets for diligence, title research, and property-data pipelines.

### Why coverage-specific lookup support matters

Recorder data is public, but the available search keys are not uniform. Some offices publish a party index but no usable address or parcel index. Treating every jurisdiction as if it accepted every lookup type produces the worst kind of result: a silent empty response that looks like a real no-match.

This Actor makes lookup support explicit. Company and entity party search works in every covered jurisdiction. NYC addresses use the recorder's native street index. Outside NYC, a covered address is resolved via the property's current owner of record, then that owner name is searched in the recorder party index. This finds documents indexed under the current owner's name; it is not a full historical ownership-chain walk. An unresolved owner, address mismatch, or unsupported property/recorder area returns a free `lookup_summary` row with an honest `status` and `reason`. Parcel search remains NYC-only.

Coverage is explicit too. A request outside the registered routes in `COVERAGE` returns a free summary row with `coverage_miss`, rather than pretending that the recorder found nothing. That lets an agent distinguish "no document matched" from "this office is not covered" without parsing logs or inferring from an empty dataset.

Freshness is also source-specific. NYC records come from a monthly-refreshed NYC Open Data extract of ACRIS, so NYC results can lag live ACRIS by up to one month. The output exposes `retrieved_at` and the jurisdiction's advertised `index_coverage_start` where known; NYC index coverage begins in 1966.

Records come straight from official county systems, as-is. Indexes can lag recent filings and occasionally contain clerk-side errors — for anything with legal weight, verify against the official record at the source.

### How it compares to recorder-search alternatives

| Approach | Multiple offices, one schema | Company/entity portfolio search | Explicit coverage misses | Document images | Billing model |
|---|---|---|---|---|---|
| Search each recorder site manually | no | one office at a time | manual judgment | sometimes | staff time |
| Build one integration per office | only after custom work | varies | custom work | varies | infrastructure + maintenance |
| Bulk recorder datasets | often | often | contract-dependent | varies | subscription or contract |
| **Property Deed & Lien Records Search** | **yes** | **all covered jurisdictions** | **structured free summary rows** | **never** | **per delivered record** |

Use this Actor when the index metadata is the product: who appears on the recorded document, what was recorded, when, and under which instrument or book/page reference. It is not a document-image retrieval service.

### Input

At least one nonblank lookup is required across `addresses`, `parcelLookups`, and `partyLookups`.

| Field | Type | Required | Default | Description |
|---|---|---:|---:|---|
| `addresses` | array of strings | one lookup source | `[]` | Full US street addresses. NYC uses native address search; elsewhere, covered properties resolve to the current owner and search that name in the recorder index. Finds current-owner-indexed documents, not a full historical chain. Misses are free. |
| `parcelLookups` | array of strings | one lookup source | `[]` | NYC BBL lookups as `STATE/Jurisdiction/ParcelID`, for example `NY/Kings/3-01234-0056`. Parcel search is NYC-only; unsupported requests return a free summary. |
| `partyLookups` | array of strings | one lookup source | `[]` | Company/entity searches as `STATE/Jurisdiction/Name` or `STATE/Name`. State-level searches check all eligible covered jurisdictions in that state; routes that require a district return guidance. Consult `COVERAGE` for exact routing. |
| `docTypes` | array of strings | no | `[]` | Optional normalized filter: `deed`, `mortgage`, `release`, `lien`, `satisfaction`, `assignment`, `easement`, or `other`. Empty returns all supported types. |
| `dateFrom` | string | no | blank | Inclusive recording-date start in ISO `YYYY-MM-DD`. Blank searches from the source's published index start. Use a date range to narrow broad company searches on recorder sources that cap result sets. |
| `dateTo` | string | no | blank | Inclusive recording-date end in ISO `YYYY-MM-DD`. Blank searches through the latest records published by the source. Use with `dateFrom` for the most reliable results on common company names. |
| `maxRecordsPerLookup` | integer | no | `100` | Maximum billable document rows per lookup. Range 1–1,000. The free summary row does not count toward the cap. |

The input field is named `partyLookups` because recorder indexes classify grantors and grantees as parties. The customer workflow documented here is company and entity portfolio research: pass a company or LLC name to retrieve its recorded documents.

#### Coverage and lookup support

This state-level table is a compact evaluation guide. Jurisdiction routes and capabilities can change as public sources change; the `COVERAGE` key-value record written by each completed run is authoritative for that run.

| State or territory | Jurisdictions | Party search | Native address / parcel search | Notes |
|---|---:|---:|---:|---|
| Alaska (AK) | 1 | yes | no / no | Statewide across recording districts |
| Arkansas (AR) | 2 | yes | no / no | County routes |
| Colorado (CO) | 5 | yes | no / no | County and equivalent recorder routes |
| Connecticut (CT) | 16 | yes | no / no | Municipality routes; coverage is municipality-level, not county-wide |
| Delaware (DE) | 1 | yes | no / no | County route |
| Florida (FL) | 3 | yes | no / no | County routes |
| Illinois (IL) | 4 | yes | no / no | County routes; recent recordings may take up to two weeks to appear for some sources |
| Indiana (IN) | 1 | yes | no / no | County route; recent recordings may take about one week to appear |
| Iowa (IA) | 1 | yes | no / no | County route |
| Massachusetts (MA) | 11 | yes | no / no | Registry districts; broad-search guidance below |
| Maine (ME) | 1 | yes | no / no | Registry route |
| Michigan (MI) | 15 | yes | no / no | County routes |
| New Mexico (NM) | 5 | yes | no / no | County routes |
| New Jersey (NJ) | 1 | yes | no / no | County route |
| Nevada (NV) | 1 | yes | no / no | County route; broad searches require an explicit county |
| New York (NY) | 9 | yes | NYC only / NYC only | Native address and BBL search cover Manhattan, Bronx, Brooklyn, and Queens; eligible addresses elsewhere can use the current-owner crosswalk |
| New Hampshire (NH) | 9 | yes | no / no | County routes; broad searches require an explicit county |
| Ohio (OH) | 58 | yes | no / no | County routes; some broad searches require an explicit county |
| Pennsylvania (PA) | 9 | yes | no / no | County routes |
| Rhode Island (RI) | 22 | yes | no / no | Municipality routes; coverage is municipality-level, not statewide or county-wide |
| South Carolina (SC) | 3 | yes | no / no | County routes |
| Texas (TX) | 51 | yes | no / no | County routes |
| Utah (UT) | 1 | yes | no / no | County route |
| U.S. Virgin Islands (VI) | 1 | yes | no / no | Territory-wide |
| Vermont (VT) | 1 | yes | no / no | Town route; coverage is town-level, not county-wide |

The artifact has one row per jurisdiction under `jurisdictions`, with `state`, `jurisdiction`, `statewide`, `source_id`, `index_coverage_start`, `party_lookup`, `address_lookup`, `parcel_lookup`, and `state_party_fanout`, plus run-level `updated_at`:

```json
{
  "updated_at": "2026-08-05T14:03:11Z",
  "jurisdictions": [
    {
      "state": "AK",
      "jurisdiction": "Statewide",
      "statewide": true,
      "source_id": "ak_dnr",
      "index_coverage_start": null,
      "party_lookup": true,
      "address_lookup": false,
      "parcel_lookup": false,
      "state_party_fanout": true
    }
  ]
}
```

Read it from the run's default key-value store:

```python
coverage_record = client.key_value_store(run["defaultKeyValueStoreId"]).get_record("COVERAGE")
coverage = coverage_record["value"]
```

Staten Island is not part of ACRIS and is not covered by the NYC routes. Washington, DC is not covered. Uncovered requests are free and labeled rather than silently treated as no-match results.

##### Broad party searches

Some recorder sources limit very broad searches to their first 1,000 records. When a query reaches that limit, the Actor automatically narrows the search using recent date windows so it can still return results. Supply `dateFrom` and `dateTo` for the most reliable results when searching common company names. When the Actor auto-narrows a search, the source does not expose enough information to know the total match count, so `total_matches` is null.

### Output

Each successful match becomes a `document` row:

```json
{
  "record_type": "document",
  "lookup": "NY/Kings/Example Property Holdings LLC",
  "query_type": "party",
  "state": "NY",
  "jurisdiction": "Kings",
  "source": "acris",
  "instrument_number": "2024031800421001",
  "document_type": "mortgage",
  "document_type_raw": "MTGE",
  "recording_date": "2024-03-18",
  "grantors": ["EXAMPLE PROPERTY HOLDINGS LLC"],
  "grantees": ["EXAMPLE NATIONAL BANK"],
  "book_page": null,
  "parcel_id": "3-01234-0056",
  "legal_description": "Borough 3, Block 01234, Lot 0056",
  "consideration": null,
  "cross_references": [],
  "source_url": "https://a836-acris.nyc.gov/",
  "index_coverage_start": "1966-01-01",
  "retrieved_at": "2026-08-05T14:03:11Z",
  "status": null,
  "reason": null,
  "records_returned": null,
  "total_matches": null,
  "coverage_miss": null
}
```

Every lookup also emits a free `lookup_summary` row. Unsupported and uncovered requests are represented explicitly:

```json
{
  "record_type": "lookup_summary",
  "lookup": "TX/Dallas/100 Main St, Dallas, TX",
  "query_type": "address",
  "state": "TX",
  "jurisdiction": "Dallas",
  "grantors": [],
  "grantees": [],
  "cross_references": [],
  "status": "unsupported",
  "reason": "Address lookups are not available for this jurisdiction; use a company or entity party lookup.",
  "records_returned": 0,
  "total_matches": null,
  "coverage_miss": false
}
```

`document_type_raw` preserves the office's own label; `document_type` provides the normalized class. `parcel_id`, `legal_description`, `consideration`, `book_page`, `cross_references`, and `source_url` are nullable because recorder offices publish different index fields. The run-level `OUTPUT` record contains `lookups_requested`, `documents_delivered`, `summaries_delivered`, `failed`, and `charged` counts.

### Example

Find deeds, mortgages, releases, and liens recorded for a company in Dallas County since 2024:

```json
{
  "partyLookups": ["TX/Dallas/Example Property Holdings LLC"],
  "docTypes": ["deed", "mortgage", "release", "lien"],
  "dateFrom": "2024-01-01",
  "maxRecordsPerLookup": 100
}
```

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/shelvick~property-deed-records/run-sync-get-dataset-items?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "partyLookups": ["TX/Dallas/Example Property Holdings LLC"],
    "docTypes": ["deed", "mortgage", "release", "lien"],
    "dateFrom": "2024-01-01",
    "maxRecordsPerLookup": 100
  }'
```

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_TOKEN")
run = client.actor("shelvick/property-deed-records").call(run_input={
    "partyLookups": ["TX/Dallas/Example Property Holdings LLC"],
    "docTypes": ["deed", "mortgage", "release", "lien"],
    "dateFrom": "2024-01-01",
    "maxRecordsPerLookup": 100,
})

for row in client.dataset(run["defaultDatasetId"]).iterate_items():
    if row["record_type"] == "document":
        print(row["recording_date"], row["document_type"], row["instrument_number"])
    else:
        print(row["status"], row["records_returned"], row.get("reason"))
```

### Calling from an AI agent

#### Apify MCP server

Expose `shelvick/property-deed-records` through `mcp.apify.com` as a callable tool. The input schema tells the agent which lookup types work where, how to format a company/entity search, and which rows are free summaries. Agents can pay per call through x402 USDC on Base or Skyfire managed tokens.

A reliable agent instruction is: "Search the covered recorder indexes for every deed, mortgage, release, lien, satisfaction, assignment, and easement associated with this company. Branch on `record_type`; treat `lookup_summary.status` as the lookup outcome; do not infer no-match from an empty document list."

#### Apify SDK (Python)

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_TOKEN")
run = client.actor("shelvick/property-deed-records").call(run_input={
    "partyLookups": ["AK/Northern Star Holdings LLC"],
    "dateFrom": "2023-01-01",
})

rows = list(client.dataset(run["defaultDatasetId"]).iterate_items())
documents = [row for row in rows if row["record_type"] == "document"]
summary = next(row for row in rows if row["record_type"] == "lookup_summary")
```

#### REST API

Use `run-sync-get-dataset-items` for small lookups that fit the synchronous response window. For larger batches or high per-lookup caps, start an async run at `/v2/acts/shelvick~property-deed-records/runs`, wait for terminal status, then read the default dataset and the `OUTPUT` key-value record.

### Pricing

Priced per delivered recorded-document row. Each `document` row is pushed to the dataset before its charge is created. The `lookup_summary` row is always free, as are uncovered jurisdictions, unsupported lookup types, no-match results, source failures, failed runs, and records withheld after the run reaches its maximum cost.

See the **Pricing** tab on this Store page for the current per-event rates and any active subscriber discounts.

### Behavior

Input validation fails the run when all lookup arrays are blank, a parcel lookup is not `STATE/Jurisdiction/ParcelID`, a party lookup is not `STATE/Name` or `STATE/Jurisdiction/Name`, a document type is outside the supported normalized list, a date is not valid ISO format, `dateFrom` is after `dateTo`, or `maxRecordsPerLookup` is outside 1–1,000.

Lookup-level outcomes stay in free summary rows:

- `ok` — one or more document rows were delivered.
- `no_matches` — the recorder index answered but found no matching document.
- `unsupported` — the jurisdiction is covered but does not offer that lookup type, or the request could not be routed.
- `coverage_miss` — the requested jurisdiction is outside current coverage.
- `source_error` — the public source or delivery step could not complete.
- `challenge` — the public source returned a defensive interstitial instead of recorder data.
- `budget_exhausted` — the run reached its maximum cost before all matching records could be delivered; nothing beyond the budget is pushed or charged.

Lookups run in parallel and results are delivered in the order you submitted them. Response time depends on the recorder office and the number of matching documents; use async runs for larger batches. One source failing stays local to that lookup — completed rows from the rest of the batch are still delivered and the run still succeeds.

**Telemetry:** to improve coverage and reliability, this Actor reports anonymous usage metrics and diagnostic events to the developer — lookup/result counts and delivered-field coverage, and, only when a source fails, the relevant lookup text and lookup type. No account identifiers are collected, and telemetry never affects a run.

### FAQ

**Can I search every covered jurisdiction by company or LLC name?**

Yes. Use `partyLookups` with `STATE/Company Name` to search all eligible covered jurisdictions in a state, or `STATE/Jurisdiction/Company Name` to target one office. Some district-based routes require the explicit jurisdiction form; the free summary explains when that applies. Consult the run's `COVERAGE` artifact for exact routes.

**Can I search by address or parcel outside NYC?**

Addresses can be searched outside NYC where both property-owner resolution and recorder party search cover the property. The Actor resolves the current owner of record, then finds recorder documents indexed under that name; it does not walk every historical owner. Unresolved or uncovered addresses return a free summary. Parcel BBL search remains limited to Manhattan, Bronx, Brooklyn, and Queens.

**How current is NYC ACRIS data?**

NYC records come from a monthly-refreshed NYC Open Data extract, so they can lag live ACRIS by up to one month. The searchable index begins in 1966.

**Do failed or unsupported lookups cost anything?**

No. Charges occur only after a document row has been pushed. Summary rows, misses, unsupported lookups, failures, and undelivered records are free.

**Does this return the recorded deed or lien image?**

No. It returns index metadata and a verification URL where the public source provides one, never scans, PDFs, or document images.

### What this doesn't do

- **No document images.** The output is recorded-document index metadata, never deed scans, lien PDFs, or image retrieval.
- **No nationwide claim.** Coverage is limited to the routes in the run's `COVERAGE` artifact, and uncovered requests return explicit free summary rows.
- **No non-public data.** Output stays within fields published by recorder offices and NYC Open Data.
- **No address or parcel search outside NYC.** Company/entity party search is the supported path in the other covered jurisdictions.
- **No silent empty results.** Every accepted lookup ends with a summary that distinguishes no-match, unsupported, coverage miss, source failure, and budget exhaustion.

Use a county assessor/property-record tool when you need current assessment values, tax history, building characteristics, or owner-of-record by address rather than recorded-document history. Use an official recorder document-ordering service when the scanned instrument itself is required. Use this Actor when you need normalized deed, mortgage, release, lien, satisfaction, assignment, or easement index entries across its covered recorder offices.

### Related Actors

| Actor | Use it when |
|---|---|
| [County Property Records API — Owner, Value, Tax & Assessor Data](https://apify.com/shelvick/county-property-records) | you need the assessor record behind an address or parcel: owner where public, assessed value, tax history, sales, and property characteristics |
| [Secretary of State Business Search + UCC Liens](https://apify.com/shelvick/business-entity-lien-search) | a company named in a recorded document needs entity-status verification or a UCC filing search |

***

Design notes: [www.scotthelvick.com/tools/property-deed-records](https://www.scotthelvick.com/tools/property-deed-records)

# Actor input Schema

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

Each address is one array element; a single address must be a one-element array, for example \["350 5th Ave, New York, NY"]. NYC uses its native street index; elsewhere, addresses resolve through the current owner of record where covered, then search the recorder's party index. This finds documents indexed under the current owner, not a full historical chain. Misses and unsupported areas return free summaries; only document records are charged.

## `parcelLookups` (type: `array`):

Parcel lookups as "STATE/Jurisdiction/ParcelID". PARCEL LOOKUPS ARE CURRENTLY NYC-ONLY and take a BBL (borough-block-lot): "NY/Kings/3-01234-0056", "NY/New York/1-00835-0019". Borough names and Manhattan/Brooklyn aliases both work. Other jurisdictions return a free summary row explaining that parcel search is unavailable there — use partyLookups instead. Never charged for an unsupported lookup.

## `partyLookups` (type: `array`):

Party search works in every covered jurisdiction. Formats: STATE/Jurisdiction/Name or STATE/Name. State-level searches fan out across eligible covered jurisdictions; routes that require an explicit district return guidance instead. Examples: WV/Acme Holdings LLC; TX/Acme Holdings LLC; TX/Dallas/Acme Holdings LLC; AK/Northern Star LLC. Read the run's COVERAGE artifact for exact routes and capabilities. Use dateFrom/dateTo to narrow broad company searches.

## `docTypes` (type: `array`):

Optional normalized document-type filter. Valid values: deed, mortgage, release, lien, satisfaction, assignment, easement, other. Values are validated at runtime; omit the field or pass an empty list to return every supported document type.

## `dateFrom` (type: `string`):

Optional inclusive start of the recording-date range in ISO YYYY-MM-DD format. Leave blank to search from the jurisdiction's published index coverage start. Use with dateTo to narrow broad company searches, especially common names in Massachusetts.

## `dateTo` (type: `string`):

Optional inclusive end of the recording-date range in ISO YYYY-MM-DD format. Leave blank to search through the latest published records. Use with dateFrom to narrow broad company searches, especially common names in Massachusetts.

## `maxRecordsPerLookup` (type: `integer`):

Maximum billable recorded-document rows returned for each address, parcel, or party lookup. Summary rows are free and do not count toward this cap. Default 100; maximum 1000.

## Actor input object example

```json
{
  "addresses": [
    "350 5th Ave, New York, NY",
    "1 Bay St, Brooklyn, NY"
  ],
  "parcelLookups": [
    "NY/Kings/3-01234-0056"
  ],
  "partyLookups": [
    "TX/Dallas/Acme Holdings LLC"
  ],
  "docTypes": [],
  "maxRecordsPerLookup": 100
}
```

# Actor output Schema

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

Normalized recorded-document index entries and free lookup summaries for this run.

# 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": [
        "350 5th Ave, New York, NY",
        "1 Bay St, Brooklyn, NY"
    ],
    "parcelLookups": [
        "NY/Kings/3-01234-0056"
    ],
    "partyLookups": [
        "TX/Dallas/Acme Holdings LLC"
    ],
    "docTypes": [],
    "dateFrom": "",
    "dateTo": "",
    "maxRecordsPerLookup": 100
};

// Run the Actor and wait for it to finish
const run = await client.actor("shelvick/property-deed-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 = {
    "addresses": [
        "350 5th Ave, New York, NY",
        "1 Bay St, Brooklyn, NY",
    ],
    "parcelLookups": ["NY/Kings/3-01234-0056"],
    "partyLookups": ["TX/Dallas/Acme Holdings LLC"],
    "docTypes": [],
    "dateFrom": "",
    "dateTo": "",
    "maxRecordsPerLookup": 100,
}

# Run the Actor and wait for it to finish
run = client.actor("shelvick/property-deed-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 '{
  "addresses": [
    "350 5th Ave, New York, NY",
    "1 Bay St, Brooklyn, NY"
  ],
  "parcelLookups": [
    "NY/Kings/3-01234-0056"
  ],
  "partyLookups": [
    "TX/Dallas/Acme Holdings LLC"
  ],
  "docTypes": [],
  "dateFrom": "",
  "dateTo": "",
  "maxRecordsPerLookup": 100
}' |
apify call shelvick/property-deed-records --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,shelvick/property-deed-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/IDwPjZo61JpJaqgsy/builds/yDwZ0cONj2Hn7QgwW/openapi.json