# Jefferson Parish Assessor Scraper (`automation-lab/jefferson-parish-property-assessment-records`) Actor

Search official Jefferson Parish assessor records and export parcel ownership, addresses, legal descriptions, and assessed values.

- **URL**: https://apify.com/automation-lab/jefferson-parish-property-assessment-records.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 $2.40 / 1,000 item extracteds

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

## Jefferson Parish Assessor Scraper

Search the official Jefferson Parish assessor website and export useful parcel assessment records as structured JSON.

The Actor supports owner, physical-address, parcel-number, and subdivision/block/lot searches.
It follows each official result to collect parcel identity, owners, addresses, legal description, property classes, assessed and market values, deeds, locations, and source links.

It is designed for repeatable property due diligence and assessment comparison.
It does not claim to provide billed taxes or historical snapshots that are not displayed by the source.

### What can you do with the Jefferson Parish assessor scraper?

- Look up parcels owned by a person or organization.
- Resolve a physical address to official assessment records.
- Retrieve one known parcel by parcel number.
- Search a subdivision and narrow it by block and lot.
- Export current assessed and market values to a spreadsheet.
- Capture source URLs for review and audit trails.
- Schedule recurring runs and compare datasets in your own workflow.
- Feed normalized parcel records into underwriting or due-diligence systems.

### Who is this Actor for?

**Property researchers** can turn public parcel searches into consistent datasets.

**Real-estate investors** can collect owner, location, legal-description, and valuation context before deeper diligence.

**Tax and assessment professionals** can retrieve current source-displayed assessments for review.

**Data teams** can integrate official Jefferson Parish parcel records into recurring pipelines.

**Portfolio managers** can schedule the same search and compare current records with prior run datasets.

### Why use this Actor?

The public website is useful for individual lookups, but repeated manual searches are difficult to automate reliably.

This Actor:

1. establishes the public source session;
2. submits the official search form;
3. follows matching parcel links;
4. normalizes detail tables into typed records;
5. respects your `maxItems` limit;
6. preserves official detail and map links.

No browser or paid proxy is automatically used.
The implementation uses the public server-rendered source pages directly.

### Data extracted

| Field | Meaning |
|---|---|
| `parcelNumber` | Official Jefferson Parish parcel number |
| `assessmentYear` | Assessment listing year displayed by the source |
| `primaryOwner` | Primary owner shown on the parcel |
| `mailingAddress` | Mailing address displayed for the owner |
| `physicalAddress` | Physical property address |
| `ward` | Parish ward identifier |
| `propertyType` | Source property type, such as `REAL` |
| `legalDescription` | Source-displayed legal description |
| `assessedValue` | Total assessed value |
| `marketValue` | Total market value |
| `propertyValues` | Assessment components by property class |
| `deeds` | Public deed rows shown on the parcel page |
| `owners` | Current and prior owner rows displayed by the source |
| `locations` | Subdivision, block, and lot rows |
| `subdivision` | First subdivision value for convenient tabular use |
| `block` | First block value for convenient tabular use |
| `lot` | First lot value for convenient tabular use |
| `mapUrl` | Official assessor map link, when shown |
| `sourceUrl` | Official parcel detail URL |
| `scrapedAt` | Extraction timestamp in ISO 8601 format |

A missing source value is returned as `null` or an empty nested array.

### Getting started

1. Open the Actor in Apify Console.
2. Select a value under **Search by**.
3. Enter the corresponding owner, address, parcel, or subdivision value.
4. Set **Maximum parcels** to control output volume.
5. Click **Start**.
6. Open the **Dataset** tab to inspect or download records.

For a quick test, use:

```json
{
  "searchType": "parcel",
  "parcelNumber": "0100000082",
  "maxItems": 1
}
```

### Input parameters

| Input | Type | Description |
|---|---|---|
| `searchType` | string | `owner`, `address`, `parcel`, or `subdivision` |
| `ownerName` | string | Owner text in the source's `LAST,FIRST` style |
| `address` | string | Physical street-address text |
| `parcelNumber` | string | Official parcel number |
| `subdivision` | string | Subdivision name |
| `block` | string | Optional block for subdivision search |
| `lot` | string | Optional lot for subdivision search |
| `startUrls` | array | Official `www.jpassessor.com/Parcel/Details` URLs |
| `maxItems` | integer | Maximum parcel records, from 1 through 500 |

Use either `startUrls` or search fields, not both.
`block` and `lot` are supported only with subdivision searches.

### Search examples

Search by owner:

```json
{
  "searchType": "owner",
  "ownerName": "SMITH",
  "maxItems": 25
}
```

Search by address:

```json
{
  "searchType": "address",
  "address": "746 12TH ST",
  "maxItems": 5
}
```

Search by subdivision, block, and lot:

```json
{
  "searchType": "subdivision",
  "subdivision": "SLATTERYVILLE",
  "block": "2",
  "lot": "16",
  "maxItems": 5
}
```

Extract an official detail URL:

```json
{
  "startUrls": [
    {
      "url": "https://www.jpassessor.com/Parcel/Details?ParcelID=0100000082"
    }
  ],
  "maxItems": 1
}
```

### Output example

The default dataset contains one object per accepted parcel.
A current run can produce:

```json
{
  "parcelNumber": "0100000082",
  "assessmentYear": 2026,
  "primaryOwner": "SMITH,BRENDA LEE",
  "mailingAddress": "746-48 12TH ST GRETNA LA 70053 USA",
  "physicalAddress": "746 12TH ST",
  "ward": "10",
  "propertyType": "REAL",
  "legalDescription": "LOT 16 SQ 2 SLATTERY #1",
  "assessedValue": 5370,
  "marketValue": 53700,
  "subdivision": "SLATTERYVILLE",
  "block": "2",
  "lot": "16",
  "sourceUrl": "https://www.jpassessor.com/Parcel/Details?ParcelID=0100000082",
  "scrapedAt": "2026-08-18T06:08:00.000Z"
}
```

Nested `propertyValues`, `deeds`, `owners`, and `locations` are also included.
The example reflects source-observed structure; public records can change.

### How much does it cost to extract Jefferson Parish parcel assessments?

Pricing uses one `start` event per run plus one tiered `item` event per saved parcel.
At the BRONZE tier, the run start is **$0.005** and each saved parcel is **$0.004**.
Higher-volume tiers automatically reduce the per-parcel price.

| Saved parcels | BRONZE price calculation |
|---:|---:|
| 1 | $0.005 start + 1 × $0.004 item |
| 10 | $0.005 start + 10 × $0.004 item |
| 25 | $0.005 start + 25 × $0.004 item |
| 100 | $0.005 start + 100 × $0.004 item |

Only useful records written to the default dataset receive an `item` charge.
No-result searches have no item charge, but the one-time start event still applies.
Platform limits and your account tier can affect the final displayed total.

### Scheduling assessment comparisons

Apify schedules can run the same saved input daily, weekly, or monthly.
Each run produces a timestamped dataset.

A typical comparison workflow is:

1. save a stable owner, parcel, or subdivision input;
2. schedule the Actor;
3. export each completed dataset;
4. join records by `parcelNumber`;
5. compare `primaryOwner`, `assessedValue`, `marketValue`, or nested owner rows;
6. alert only on changes relevant to your process.

The Actor returns current source data.
It does not create an authoritative historical record inside the source.
Your workflow is responsible for retaining and comparing prior datasets.

### Export and integrations

The dataset can be downloaded as JSON, CSV, Excel, XML, or RSS from Apify Console.

Common integrations include:

- Google Sheets for review lists;
- Airtable for property research queues;
- webhooks for completed-run notifications;
- Make or Zapier for downstream routing;
- cloud storage for scheduled snapshots;
- Python, JavaScript, SQL, or BI pipelines for comparisons.

Nested arrays are preserved in JSON.
For flat CSV workflows, use the top-level parcel, owner, address, location, and value fields first.

### Run through the API with cURL

Replace `YOUR_TOKEN` with an Apify API token:

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~jefferson-parish-property-assessment-records/runs?token=YOUR_TOKEN&waitForFinish=120" \
  -H "Content-Type: application/json" \
  -d '{"searchType":"parcel","parcelNumber":"0100000082","maxItems":1}'
```

Fetch the run's default dataset through the dataset URL returned by the API.

### Run through the API with JavaScript

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/jefferson-parish-property-assessment-records').call({
  searchType: 'address',
  address: '746 12TH ST',
  maxItems: 5,
});

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

### Run through the API with Python

```python
import os
from apify_client import ApifyClient

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/jefferson-parish-property-assessment-records').call(
    run_input={
        'searchType': 'subdivision',
        'subdivision': 'SLATTERYVILLE',
        'block': '2',
        'lot': '16',
        'maxItems': 5,
    }
)
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

### Use with MCP and AI assistants

Add the Apify MCP server to Claude Code:

```bash
claude mcp add --transport http apify \
  "https://mcp.apify.com?tools=automation-lab/jefferson-parish-property-assessment-records"
```

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

Use this equivalent configuration in Claude Desktop, Cursor, or VS Code:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=automation-lab/jefferson-parish-property-assessment-records"
    }
  }
}
```

Example prompts:

- “Look up Jefferson Parish parcel 0100000082 and summarize its assessment.”
- “Export up to 25 parcels for owner SMITH and return parcel number, address, and market value.”
- “Find Slatteryville block 2 lot 16 and include ownership and deed context.”

Review public-record output before relying on an AI-generated conclusion.

### Reliability and limits

- The Actor reads the public official website without login.
- It uses a bounded direct-HTTP session and does not enable an automatic paid proxy fallback.
- Source timeouts, maintenance, or markup changes can cause a run to fail rather than return misleading empty data.
- Search matching follows the official site's behavior.
- Broad owner or subdivision searches may have many matches; use `maxItems` intentionally.
- Maximum output is 500 parcels per run.
- Detail requests use conservative bounded concurrency.
- Values reflect the source at extraction time and may be preliminary or change later.
- Billed tax is outside this Actor's output contract.
- Unobserved historical assessment snapshots are not invented.

### Responsible use and legality

The Actor accesses public Jefferson Parish Assessor pages.
Public availability does not remove your responsibility to use the data lawfully.

Before processing or redistributing records:

- review the source site's terms and notices;
- comply with applicable privacy, public-record, housing, and anti-discrimination rules;
- collect only the volume needed for a legitimate purpose;
- secure exported ownership and address data;
- verify material decisions against the official source or Assessor's Office.

This Actor is not legal, tax, appraisal, or title advice.

### Troubleshooting

#### Why did my search return no records?

Check the format expected by the official source.
Owner searches commonly work best as `LAST,FIRST` without a space.
Try a shorter address or subdivision value and confirm it manually on the public site.

#### Why did the run fail instead of returning an empty dataset?

The Actor validates the expected search and detail page structure.
If the source returns maintenance content, a block, or an unexpected page, failing is safer than presenting it as a true no-result search.
Retry later after checking source availability.

#### Why is a field null?

Not every official parcel page displays every deed, map, location, or owner-history value.
Missing source values remain null or empty arrays.

#### Can I enter multiple searches in one run?

Each run accepts one search workflow or a list of known parcel detail URLs.
Use multiple Apify tasks or API calls for unrelated owner/address queries.

### Frequently asked questions

#### Does this include tax bills?

No.
The Actor exports source-displayed property assessment values and does not claim billed tax data.

#### Does this include ownership history?

It includes current and prior owner rows displayed on the current official parcel page.
It does not reconstruct records the source does not display.

#### Can I monitor changes?

Yes.
Schedule the same input and compare datasets by `parcelNumber` in your own storage or automation.

#### Does it require an Apify proxy?

No.
The supported implementation uses direct public HTTP requests.

#### Can I search personal property?

No.
This release is scoped to real-property searches (`ParcelType=11`).

### Related Actors

For multi-market public property research, see other automation-lab Actors:

- [Dallas County Property Assessment Scraper](https://apify.com/automation-lab/dallas-county-property-assessment-scraper)
- [Cook County Assessor Parcel Scraper](https://apify.com/automation-lab/cook-county-assessor-parcel-scraper)
- [Clark County Property Records Scraper](https://apify.com/automation-lab/clark-county-property-records-scraper)
- [Maricopa County Property Records Scraper](https://apify.com/automation-lab/maricopa-county-property-records-scraper)

These are separate county sources with separate input and output contracts.

### Support

If a run fails, include the run URL, sanitized input, expected search behavior, and whether the official source worked manually.
Do not post Apify tokens or private downstream credentials.

# Actor input Schema

## `searchType` (type: `string`):

Choose how to search the official assessor records. Not used when parcel detail URLs are supplied.

## `ownerName` (type: `string`):

Owner name in the source's LAST,FIRST format. Required for owner searches.

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

Street address text shown in the official parcel record. Required for address searches.

## `parcelNumber` (type: `string`):

Official Jefferson Parish parcel number. Required for parcel searches.

## `subdivision` (type: `string`):

Subdivision name. Required for subdivision searches.

## `block` (type: `string`):

Optional block filter for a subdivision search.

## `lot` (type: `string`):

Optional lot filter for a subdivision search.

## `startUrls` (type: `array`):

Optional public www.jpassessor.com Parcel/Details URLs. When supplied, do not set search fields.

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

Maximum number of matching parcel records to export.

## Actor input object example

```json
{
  "searchType": "owner",
  "ownerName": "SMITH",
  "startUrls": [],
  "maxItems": 10
}
```

# Actor output Schema

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

Dataset containing all extracted parcel records.

# 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 = {
    "searchType": "owner",
    "ownerName": "SMITH",
    "startUrls": [],
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/jefferson-parish-property-assessment-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 = {
    "searchType": "owner",
    "ownerName": "SMITH",
    "startUrls": [],
    "maxItems": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/jefferson-parish-property-assessment-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 '{
  "searchType": "owner",
  "ownerName": "SMITH",
  "startUrls": [],
  "maxItems": 10
}' |
apify call automation-lab/jefferson-parish-property-assessment-records --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,automation-lab/jefferson-parish-property-assessment-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/SPKOmbpz3xFOfDyJD/builds/pGYc2UatYTtclT11V/openapi.json