# Maricopa County Property Records Scraper (`automation-lab/maricopa-county-property-records-scraper`) Actor

Search Maricopa County assessor records by APN, owner, or address. Export owner, mailing, deed, valuation, lot, district, and residential facts to JSON, CSV, or Excel.

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

## Pricing

Pay per event

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 a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js/docs.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/integrations/mcp.md).

If your project is in a different language, use 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

Extract **Maricopa County property records** from the public Assessor website by APN, owner name, or street address.

Get parcel identity, ownership, situs and mailing addresses, deeds, lot facts, districts, valuation history, tax classification, and residential characteristics without an assessor account or API key.

Use the results in JSON, CSV, Excel, XML, an API integration, a scheduled workflow, or an AI agent.

### What does Maricopa County Property Records Scraper do?

Maricopa County Property Records Scraper searches the public [Maricopa County Assessor](https://mcassessor.maricopa.gov/) and turns parcel pages into structured records.

It supports three common lookup jobs:

- 🔎 Find parcels from a property address.
- 👤 Find parcels associated with an owner name.
- 🧾 Look up a precise assessor parcel number (APN).

Each result can include six years of valuation data and detailed residential attributes.

The Actor uses the Assessor site's anonymous page-issued request tokens.

No browser, login, private credential, or paid third-party property API is required.

### Who is it for?

**Real-estate investors and wholesalers**

- Build parcel-owner lead lists for Phoenix and surrounding Maricopa County markets.
- Add mailing addresses and deed facts to property research.
- Schedule recurring owner or address searches to refresh lists.

**Appraisers and tax-appeal analysts**

- Compare full cash value, limited property value, and assessed LPV by year.
- Review classification, use code, tax area, lot, and building characteristics.
- Export source-linked evidence for analysis in spreadsheets or databases.

**Title, lending, and proptech teams**

- Resolve APNs into normalized owner and property facts.
- Sync parcel records through the Apify API.
- Route completed datasets to data warehouses, CRMs, or review queues.

**Home buyers and researchers**

- Inspect public assessor facts for a known property.
- Compare situs and mailing addresses.
- Review construction year, livable area, pool, roof, HVAC, and parking data when available.

### Why use this Maricopa County assessor scraper?

- ✅ **No login or assessor API key** — the useful public scope is anonymous.
- ✅ **Three search intents** — APN, owner, and address searches use one stable input contract.
- ✅ **Rich parcel enrichment** — one row combines search, detail, valuation, and building facts.
- ✅ **Typed exports** — monetary values, years, areas, booleans, and counts are normalized.
- ✅ **Source traceability** — every row includes the parcel detail URL and original query.
- ✅ **Low-overhead HTTP extraction** — no browser runtime is needed.
- ✅ **Apify automation** — schedule runs, call an API, use webhooks, and integrate with other tools.
- ✅ **Global item limit** — control output volume and cost across multiple searches.

### What Maricopa County property data can you extract?

| Category | Example fields |
|---|---|
| Parcel identity | `apn`, `mcr`, `subdivisionName`, `sectionTownshipRange` |
| Ownership | `ownerName`, `mailingAddress`, `isRental` |
| Property location | `situsAddress`, `situsCity`, `situsZip`, `fullSitusAddress` |
| Property type | `propertyType`, `currentPropertyUse`, `currentLegalClassification` |
| Deed and sale | `deedNumber`, `deedDate`, `saleDate`, `salePrice` |
| Land and jurisdiction | `lotSizeSqFt`, `lotNumber`, school districts, jurisdiction, neighborhood |
| Current valuation | tax year, full cash value, limited property value, assessed LPV, tax area |
| Valuation history | all available years with classification, ratio, use code, and source |
| Residential building | construction year, livable area, pool, quality, walls, roof, HVAC |
| Parking | garage spaces, carport spaces, and parking type |
| Provenance | `sourceUrl`, `searchQuery`, `searchType`, `scrapedAt` |

Some fields are naturally absent for vacant land, commercial parcels, or records where the Assessor does not publish that fact.

Missing optional source values are omitted instead of filled with misleading placeholders.

### How much does it cost to scrape Maricopa County property records?

This Actor uses pay-per-event pricing.

There is one small run-start charge and one charge per unique property record saved.

| Apify plan | Start | Per property |
|---|---:|---:|
| Free | $0.005 | $0.00076486 |
| Starter / Bronze | $0.005 | $0.00066510 |
| Scale / Silver | $0.005 | $0.00051878 |
| Business / Gold | $0.005 | $0.00039906 |
| Platinum | $0.005 | $0.00026604 |
| Diamond | $0.005 | $0.00018623 |

Example costs with the current prices:

| Output | Free plan | Starter plan |
|---:|---:|---:|
| 1 property | about $0.0058 | about $0.0057 |
| 100 properties | about $0.081 | about $0.072 |
| 1,000 properties | about $0.77 | about $0.67 |

The Apify Free plan includes platform credits, so you can test a small lookup before starting a larger workflow.

A query returning zero matching properties incurs no per-property charge.

### How to scrape Maricopa County property records

1. Open Maricopa County Property Records Scraper on Apify.
2. Enter one or more APNs, owner names, or addresses.
3. Choose the matching search type, or keep **Auto detect / mixed**.
4. Set a conservative maximum number of properties.
5. Keep parcel details and valuation history enabled for enriched output.
6. Click **Start**.
7. Preview the property records in the Dataset tab.
8. Export the dataset as JSON, CSV, Excel, XML, or RSS.
9. Save the task or schedule it if you need repeat refreshes.

Start with a single known APN such as `10578232` to see the complete residential output shape.

### Input parameters

| Field | Type | Default | Purpose |
|---|---|---|---|
| `searchQueries` | string array | `["10578232"]` | APNs, owner names, or property addresses; one per line |
| `searchType` | string | `auto` | `auto`, `apn`, `owner`, or `address` |
| `maxItems` | integer | `25` | Maximum unique parcels across all searches, from 1 to 1,000 |
| `includeDetails` | boolean | `true` | Load owner mailing, deed, lot, school, and jurisdiction facts |
| `includeValuations` | boolean | `true` | Add valuation history and normalized current value fields |
| `includeResidentialDetails` | boolean | `true` | Add residential building and parking characteristics |
| `includeImprovements` | boolean | `true` | Add source-provided improvement records when available |
| `proxyConfiguration` | object | direct connection | Optional Apify Proxy configuration |

APN mode accepts compact or hyphenated Maricopa parcel numbers, for example `10578232` or `105-78-232`.

A run supports up to 50 search entries.

`maxItems` is global, so duplicate APNs found by multiple queries appear only once.

### Input examples

**One exact APN with full details**

```json
{
  "searchQueries": ["10578232"],
  "searchType": "apn",
  "maxItems": 1
}
````

**Address search with a small lead sample**

```json
{
  "searchQueries": ["301 W Jefferson St Phoenix"],
  "searchType": "address",
  "maxItems": 10,
  "includeDetails": true
}
```

**Multiple owner searches for a recurring list**

```json
{
  "searchQueries": ["MARICOPA COUNTY", "ARIZONA STATE OF"],
  "searchType": "owner",
  "maxItems": 100,
  "includeValuations": true
}
```

**Fast search-only export**

```json
{
  "searchQueries": ["301 W Jefferson St Phoenix"],
  "searchType": "address",
  "maxItems": 25,
  "includeDetails": false
}
```

### Output example

```json
{
  "apn": "10578232",
  "ownerName": "QUINTERO MARIA ROSAURA BELTRAN",
  "mailingAddress": "1934 W JEFFERSON ST, PHOENIX, AZ 85009",
  "fullSitusAddress": "1752 W HIDALGO AVE, PHOENIX, 85041",
  "subdivisionName": "VISTA GRANDE",
  "propertyType": "RESIDENTIAL",
  "isRental": false,
  "deedNumber": "20180548275",
  "deedDate": "07/19/2018",
  "lotSizeSqFt": 6194,
  "localJurisdiction": "PHOENIX",
  "currentTaxYear": 2027,
  "currentFullCashValue": 279300,
  "currentLimitedPropertyValue": 56626,
  "currentAssessedLimitedPropertyValue": 5663,
  "currentPropertyUse": "Single Family Residence",
  "constructionYear": 1970,
  "livableAreaSqFt": 1296,
  "pool": false,
  "garageSpaces": 1,
  "carportSpaces": 1,
  "sourceUrl": "https://mcassessor.maricopa.gov/mcs/?q=10578232&mod=pd",
  "searchQuery": "10578232",
  "searchType": "apn"
}
```

The complete record also contains a `valuations` array with all available years.

Improvement rows are included only when the source returns them.

### Understanding valuation fields

`currentFullCashValue` is the newest full cash value published by the Assessor.

`currentLimitedPropertyValue` is the newest limited property value.

`currentAssessedLimitedPropertyValue` is the assessed LPV after the source assessment ratio is applied.

The first `valuations` entry is also flattened into the current-value fields for easy spreadsheet filtering.

Every valuation entry can contain:

- Tax year.
- Full cash value.
- Limited property value.
- Assessed full cash and limited values when published.
- Legal classification code and description.
- Assessment ratio.
- Property use code and description.
- Tax area code.
- Valuation source.

Assessor values are public assessment facts, not an appraisal or a guaranteed market price.

### Tips for best results

- 🎯 Use APN mode when you know the parcel number; it is the most precise lookup.
- 🏠 Include city names in address searches to reduce broad matches.
- 👤 Enter owner names in the order shown by public records when possible.
- 📦 Start with `maxItems` between 1 and 10 while testing a new query.
- ⚡ Disable `includeDetails` when you need only APN, owner, situs, subdivision, and property type.
- 📊 Keep valuation enrichment enabled for tax, appraisal, and portfolio workflows.
- 🔁 Schedule repeat owner searches rather than downloading the same broad result manually.
- 🔗 Retain `sourceUrl` when analysts need to review the current public parcel page.
- 🧹 Deduplicate downstream records by `apn`, not by owner or address.

### Integrations and recurring workflows

**Maricopa property records → Google Sheets**

Schedule an owner search and append new APNs to a lead-review sheet.

**Maricopa property records → Airtable or a CRM**

Use `apn` as the external key, then update owner, mailing, deed, and valuation columns on each run.

**Maricopa property records → Slack or Microsoft Teams**

Send a webhook when a watched parcel's newest valuation or deed fact changes.

**Maricopa property records → Make or Zapier**

Start a task from a new address row, wait for the run, and send the normalized property result to another system.

**Maricopa property records → a data warehouse**

Pull the dataset through the API and store valuation arrays for longitudinal analysis.

**Scheduled portfolio refresh**

Save a task containing known APNs and run it weekly or monthly to refresh public assessor facts.

### API usage with Node.js

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/maricopa-county-property-records-scraper').call({
  searchQueries: ['10578232'],
  searchType: 'apn',
  maxItems: 1,
});

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

Install the client with `npm install apify-client`.

### Using the Apify API with Python

```python
import os
from apify_client import ApifyClient

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/maricopa-county-property-records-scraper').call(run_input={
    'searchQueries': ['301 W Jefferson St Phoenix'],
    'searchType': 'address',
    'maxItems': 10,
})

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

Install the client with `pip install apify-client`.

### Using the Apify API with cURL

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~maricopa-county-property-records-scraper/runs?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "searchQueries": ["10578232"],
    "searchType": "apn",
    "maxItems": 1
  }'
```

After the run succeeds, read items from its `defaultDatasetId` through the Apify Dataset API.

Do not place an Apify token in client-side code or a public repository.

### Use Maricopa County property data with AI agents via MCP

This Actor is available to assistants that support the [Model Context Protocol](https://docs.apify.com/platform/integrations/mcp).

For Claude Code, run:

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

For Claude Desktop, Cursor, or VS Code, add:

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

Your client will ask you to authenticate with Apify.

Example prompts:

- “Use `automation-lab/maricopa-county-property-records-scraper` to look up APN 10578232 and summarize its newest valuation.”
- “Find up to 10 parcels matching 301 W Jefferson St Phoenix and save their owners and mailing addresses.”
- “Refresh these Maricopa County APNs and compare current full cash values with the previous tax year.”

### Legality: is it legal to scrape Maricopa County property records?

The Actor extracts publicly accessible government property records without bypassing a login.

Public availability does not remove every responsibility.

Use the data for a lawful purpose, follow applicable website terms and access rules, and avoid excessive requests.

Property records can contain owner and mailing information.

If personal data is involved, comply with privacy, marketing, fair-housing, consumer-protection, and data-retention laws that apply to your jurisdiction and use case.

Do not use the output for harassment, discrimination, identity theft, or decisions that require a regulated data source.

This Actor is a technical extraction tool and does not provide legal, tax, title, or appraisal advice.

### Limitations and source behavior

- The Actor covers the public Maricopa County Assessor website, not every Arizona county.
- Search matching and record availability are controlled by the Assessor.
- Broad owner names can return many matches; `maxItems` stops output after the selected limit.
- Some commercial, vacant-land, and personal-property records do not have residential characteristics.
- Sale price and sale date can be unavailable even when deed information exists.
- Valuation years change as the Assessor publishes a new cycle.
- Source maintenance, rate limits, or token changes can temporarily affect extraction.
- An address search can return nearby or textually related records; review APN and situs fields.
- The Actor reports public assessor data and does not verify ownership or title status independently.

### Troubleshooting

**Why did my search return no properties?**

Check spelling and search intent. Try a compact APN, a shorter owner name, or an address with the city. A valid no-match search completes successfully with an empty dataset.

**Why are residential fields missing?**

The parcel may be commercial, vacant land, or another type without a residential-detail response. The core parcel record remains useful.

**Why is the Assessor request failing?**

Retry after a short interval. If your network is blocked, enable Apify Proxy and keep one stable US session. The Actor automatically obtains fresh anonymous page tokens.

**Why did I receive fewer rows than the source total?**

`maxItems` is a global cap. Increase it carefully, and remember duplicate APNs across searches are emitted only once.

**How do I inspect a questionable value?**

Open the row's `sourceUrl` and compare the current public parcel page. Keep `scrapedAt` when data freshness matters.

### FAQ

**How fast is the Maricopa County property scraper?**

A single enriched APN usually completes in seconds. Broad searches take longer because each selected parcel can require detail and valuation requests.

**Does it require an official assessor API key?**

No. It uses anonymous public pages and the same page-issued request tokens used by the Assessor website.

**Can I search owners and addresses in one run?**

Yes. Use `searchType: "auto"` and place mixed values in `searchQueries`.

**Can I export CSV or Excel?**

Yes. Apify datasets support JSON, CSV, Excel, XML, HTML, and RSS exports.

**How are duplicate properties handled?**

The Actor normalizes APNs and emits each parcel once per run, even when multiple queries find it.

**Does it include tax bills or delinquency status?**

No. It focuses on Assessor parcel, valuation, classification, deed, lot, and building data. Tax-collector balances are a different source and workflow.

**Can I monitor changes over time?**

Yes. Save a task, schedule it, and compare records by APN and tax year in your destination system.

**Is this an appraisal or title report?**

No. It is a structured export of public assessor facts and should not replace professional appraisal or title work.

### Related real-estate and public-record actors

- [Clark County Property Records Scraper](https://apify.com/automation-lab/clark-county-property-records-scraper) — assessor parcel and owner records for Clark County, Nevada.
- [Zillow Scraper](https://apify.com/automation-lab/zillow-scraper) — current US real-estate listing and property data.
- [Redfin Scraper](https://apify.com/automation-lab/redfin-scraper) — Redfin listing and market records.
- [Realtor Agents Scraper](https://apify.com/automation-lab/realtor-agents-scraper) — agent profiles for real-estate research.
- [California DRE Licensee Search Scraper](https://apify.com/automation-lab/california-dre-licensee-search-scraper) — California real-estate license lookup.
- [Georgia Real Estate License Lookup Scraper](https://apify.com/automation-lab/georgia-real-estate-license-lookup-scraper) — Georgia licensee records.

Choose the county assessor Actor when you need government parcel and valuation facts.

Choose listing Actors when you need current marketed homes, asking prices, photos, or listing-agent information.

### Data quality and responsible automation

The Actor preserves source-native text where normalization could change legal meaning, while converting unambiguous amounts, years, areas, counts, and booleans into typed values.

Use `apn` as the stable parcel key.

Store historical snapshots if your workflow needs change detection because the public page shows the current state.

Keep runs bounded and scheduled at a reasonable frequency.

Review high-impact decisions against authoritative county records and qualified professionals.

For technical questions, include the run ID, a redacted input example, and the affected APN when opening an issue on Apify.

# Actor input Schema

## `searchQueries` (type: `array`):

Enter one search per line. Examples: 105-78-232, QUINTERO MARIA, or 301 W JEFFERSON ST PHOENIX.

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

Choose the intent of every search. Auto accepts mixed APNs, owners, and addresses.

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

Stop after this many unique parcel records across all searches.

## `includeDetails` (type: `boolean`):

Enrich search results with owner mailing, deed, sale, lot, district, and jurisdiction fields.

## `includeValuations` (type: `boolean`):

Add all available tax years plus normalized current valuation fields.

## `includeResidentialDetails` (type: `boolean`):

Add construction year, livable area, pool, quality, roof, HVAC, garage, carport, and parking fields for residential parcels.

## `includeImprovements` (type: `boolean`):

Add source-provided improvement records when available.

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

Optionally route requests through Apify Proxy. Direct HTTP works by default; use a stable US session if your network is blocked.

## Actor input object example

```json
{
  "searchQueries": [
    "10578232"
  ],
  "searchType": "auto",
  "maxItems": 5,
  "includeDetails": true,
  "includeValuations": true,
  "includeResidentialDetails": true,
  "includeImprovements": true,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `overview` (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 = {
    "searchQueries": [
        "10578232"
    ],
    "searchType": "auto",
    "maxItems": 5,
    "includeDetails": true,
    "includeValuations": true,
    "includeResidentialDetails": true,
    "includeImprovements": true,
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/maricopa-county-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 = {
    "searchQueries": ["10578232"],
    "searchType": "auto",
    "maxItems": 5,
    "includeDetails": True,
    "includeValuations": True,
    "includeResidentialDetails": True,
    "includeImprovements": True,
    "proxyConfiguration": { "useApifyProxy": False },
}

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

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

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

```

## CLI example

```bash
echo '{
  "searchQueries": [
    "10578232"
  ],
  "searchType": "auto",
  "maxItems": 5,
  "includeDetails": true,
  "includeValuations": true,
  "includeResidentialDetails": true,
  "includeImprovements": true,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call automation-lab/maricopa-county-property-records-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=automation-lab/maricopa-county-property-records-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Maricopa County Property Records Scraper",
        "description": "Search Maricopa County assessor records by APN, owner, or address. Export owner, mailing, deed, valuation, lot, district, and residential facts to JSON, CSV, or Excel.",
        "version": "0.1",
        "x-build-id": "WOMRbOhW69pdvYH9o"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~maricopa-county-property-records-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-maricopa-county-property-records-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/automation-lab~maricopa-county-property-records-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-maricopa-county-property-records-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/automation-lab~maricopa-county-property-records-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-maricopa-county-property-records-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "searchQueries"
                ],
                "properties": {
                    "searchQueries": {
                        "title": "🔎 APNs, owners, or addresses",
                        "minItems": 1,
                        "maxItems": 50,
                        "type": "array",
                        "description": "Enter one search per line. Examples: 105-78-232, QUINTERO MARIA, or 301 W JEFFERSON ST PHOENIX.",
                        "default": [
                            "10578232"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "searchType": {
                        "title": "Search type",
                        "enum": [
                            "auto",
                            "apn",
                            "owner",
                            "address"
                        ],
                        "type": "string",
                        "description": "Choose the intent of every search. Auto accepts mixed APNs, owners, and addresses.",
                        "default": "auto"
                    },
                    "maxItems": {
                        "title": "Maximum properties",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Stop after this many unique parcel records across all searches.",
                        "default": 25
                    },
                    "includeDetails": {
                        "title": "Load parcel details",
                        "type": "boolean",
                        "description": "Enrich search results with owner mailing, deed, sale, lot, district, and jurisdiction fields.",
                        "default": true
                    },
                    "includeValuations": {
                        "title": "Include valuation history",
                        "type": "boolean",
                        "description": "Add all available tax years plus normalized current valuation fields.",
                        "default": true
                    },
                    "includeResidentialDetails": {
                        "title": "Include residential characteristics",
                        "type": "boolean",
                        "description": "Add construction year, livable area, pool, quality, roof, HVAC, garage, carport, and parking fields for residential parcels.",
                        "default": true
                    },
                    "includeImprovements": {
                        "title": "Include improvements",
                        "type": "boolean",
                        "description": "Add source-provided improvement records when available.",
                        "default": true
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Optionally route requests through Apify Proxy. Direct HTTP works by default; use a stable US session if your network is blocked.",
                        "default": {
                            "useApifyProxy": false
                        }
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```