# California Unclaimed Property Search (Official SCO Data) (`keeganlabs/ca-unclaimed-property-search`) Actor

Search California's official unclaimed-property database by owner name, city, ZIP, property type, or value. Weekly-refreshed State Controller data, streamed for speed; pay only per matched record. Built for skip tracing, asset recovery, and found-money features.

- **URL**: https://apify.com/keeganlabs/ca-unclaimed-property-search.md
- **Developed by:** [Keegan Labs](https://apify.com/keeganlabs) (community)
- **Categories:** Business, Lead generation
- **Stats:** 1 total users, 0 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $5.00 / 1,000 matched property records

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

Learn more: https://docs.apify.com/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.

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

## California Unclaimed Property Search

Search **California's official unclaimed-property database** — bank accounts, uncashed
checks, insurance benefits, wages, stocks, bonds, and safe-deposit-box contents held by
the State Controller — by **owner name, city, ZIP, property type, and minimum value**.
Get clean, normalized JSON records ready for skip-trace, asset-recovery, and
"found money" workflows.

### Why this data source is different

Most unclaimed-property actors scrape a search portal one query at a time. This actor
reads the **State Controller's own bulk property-records files**
([sco.ca.gov → Download Unclaimed Property Records](https://www.sco.ca.gov/upd_download_property_records.html)):

- **Official and sanctioned.** The SCO publishes the *entire* public database as CSV and
  explicitly invites the public to download it and "conduct outreach to people and
  businesses who may not know they have unclaimed property." No CAPTCHA, no rate-limit
  games, no terms-of-service gray zone.
- **Refreshed every Thursday** by the state. Every run reads the current week's files,
  so results are never staler than 7 days.
- **Complete.** A portal search shows a page of hits; the bulk files contain every
  record, including current cash balance and pending/paid claim counters that tell you
  whether a property is still claimable.
- **Fast where it counts.** The state splits the database into value tiers. If you set
  `minValue: 500`, the actor scans only the ~155 MB high-value file instead of 3+ GB —
  typical high-value name searches finish in a few minutes. Tiers are scanned
  highest-value-first, so `maxRecords` keeps your most valuable matches.

### Who uses this

- **Skip tracers & people-search platforms** — an unclaimed-property hit is both a
  contact-data signal (last known address) and a conversation opener.
- **Asset-recovery / heir-finder firms** — California authorizes professional
  investigators to work these records and **caps finder fees at 10%**, which keeps the
  market professionalized. Filter by `minValue` to build a book of claims worth working.
- **Fintech "found money" features** — match your user base against the state database
  (name + ZIP) and surface claimable cash in-app.
- **Estate attorneys & genealogists** — locate property held under a decedent's name,
  including safe-deposit-box contents and securities.

### Input

| Field | Description |
| --- | --- |
| `ownerName` | Person or business name. Case-insensitive, punctuation-proof, word-order independent: `"john o'brien"` matches `OBRIEN JOHN M`. Every word must appear in the record's owner name. Required unless `browseMode` is on. |
| `city` | Owner's last-known city (handles the source's 15-character truncation — `"Pacific Palisades"` matches the stored `PACIFIC PALISAD`). |
| `zip` | Owner's last-known 5-digit ZIP (matches ZIP and ZIP+4 records). |
| `propertyType` | Keyword (`"insurance"`, `"securities"`, `"safe-deposit"`, …) or exact NAUPA code (`"68"`). |
| `minValue` | Minimum current cash balance in USD. Also selects the smallest set of state value-tier files to scan. Non-cash records (shares on deposit, safe-deposit-box contents) are kept — their value lives outside the cash column, and the tier file bounds it. |
| `maxRecords` | Stop after this many matches (default 100). |
| `browseMode` | Search without a name — e.g. *every $10,000+ property in ZIP 90210*. Requires at least one narrowing filter. |

### Example output record

```json
{
  "propertyId": "9173148",
  "ownerName": "SMITH JOHN",
  "ownersOnRecord": 1,
  "ownerAddress": {
    "street": "13701 ANNANDALE DR 13-E",
    "city": "SEAL BEACH",
    "state": "CA",
    "zip": "90740",
    "countryCode": "USA"
  },
  "propertyType": "Savings accts/crdt union shrs",
  "propertyTypeCode": "82",
  "cashReported": 516.07,
  "currentCashBalance": 516.07,
  "sharesReported": 0,
  "securitiesName": null,
  "cusip": null,
  "pendingClaims": 0,
  "paidClaims": 0,
  "holder": {
    "name": "FIRST INTERSTATE BANK",
    "street": "1200 W 7TH ST G9-32",
    "city": "LOS ANGELES",
    "state": "CA",
    "zip": "90017"
  },
  "source": "California State Controller — claimit.ca.gov bulk property records",
  "sourceFile": "04_From_500_To_Beyond"
}
````

Every record includes the state's **property ID** — the key a claimant (or your client)
uses to file at [claimit.ca.gov](https://claimit.ca.gov/). `pendingClaims` / `paidClaims`
let you skip properties already being claimed.

### What data you get

Each matched record includes: property ID, owner name(s), reported owner address
(street/city/state/ZIP as held by the state), property type (NAUPA code + description),
cash amount, securities/shares where applicable, holder (the company that reported it),
and report year. Output is one normalized JSON record per match — see the example below.

### Pricing

Pay-per-event — you pay for **matches, not rows scanned**:

| Event | Price |
| --- | --- |
| Actor start | $0.02 per run |
| Matched property record | $0.005 per record ($5.00 / 1,000) |

**Why this price:** general skip-trace lookups on Apify run at ~$7 per 1,000 results,
and those results are inferred contact data. These are **official state records with a
dollar value attached**, normalized and claim-ready, at $5 per 1,000. Cheaper
unclaimed-property scrapers exist (~$3 per 1,000), but they replay portal searches:
per-query result caps, no value-tier targeting, no bulk-file completeness guarantee,
and output that mirrors whatever the portal happens to render. This actor reads the
same files the state publishes for exactly this purpose, verifies the schema on every
run, and fails loudly instead of silently drifting.

A full-database browse (e.g. every property over $10,000 statewide) is a single run:
scan cost is the flat $0.02 start fee plus your matched records.

### Notes & good citizenship

- Owner addresses are **last known** addresses reported by holders, often years old.
  For people-search use, treat them as historical signals, not current residences.
- California caps unclaimed-property finder fees at **10%** (CCP §1582). If you work
  claims commercially, know your state's investigator registration rules.
- The actor sets a descriptive User-Agent, downloads each file once per run with
  exponential-backoff retries, and never hammers the state's servers with parallel
  requests.
- Source files are refreshed by the SCO **every Thursday**; property IDs are stable
  across refreshes.

# Actor input Schema

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

Person or business name to search for. Matching is case-insensitive, ignores punctuation, and is word-order independent: "john o'brien" matches "OBRIEN JOHN M". Every word you enter must appear in the record's owner name, so "smith" alone finds all Smiths while "smith maria" narrows to Marias. Required unless Browse mode is on.

## `city` (type: `string`):

Case-insensitive city filter on the owner's last known address, e.g. "San Diego". Handles the source's 15-character truncation ("Pacific Palisades" still matches). Note: owner addresses are often years out of date — when in doubt, search by name only.

## `zip` (type: `string`):

5-digit ZIP filter on the owner's last known address, e.g. "90210". Matches both ZIP and ZIP+4 records.

## `propertyType` (type: `string`):

Filter by property category: a case-insensitive keyword such as "insurance", "securities", "savings", "safe-deposit", "pensions" — or an exact NAUPA type code such as "68". Leave empty for all types.

## `minValue` (type: `integer`):

Only return properties with a current cash balance of at least this amount. Also speeds runs up dramatically: minValue >= 500 lets the actor scan only the state's 155 MB high-value file instead of 3+ GB of records. Share-only securities records (zero cash, shares on deposit) are always kept within the scanned tiers.

## `maxRecords` (type: `integer`):

Stop after this many matching records (each pushed record is one billable event). Higher-value tiers are scanned first, so the cap keeps the most valuable matches.

## `browseMode` (type: `boolean`):

Scan without an owner name — e.g. every $10,000+ property in one ZIP code, or all safe-deposit-box properties in a city. Requires at least one narrowing filter (city, ZIP, property type, or minValue >= 100).

## Actor input object example

```json
{
  "ownerName": "smith john",
  "minValue": 500,
  "maxRecords": 100,
  "browseMode": false
}
```

# 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 = {
    "ownerName": "smith john",
    "minValue": 500,
    "maxRecords": 100
};

// Run the Actor and wait for it to finish
const run = await client.actor("keeganlabs/ca-unclaimed-property-search").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 = {
    "ownerName": "smith john",
    "minValue": 500,
    "maxRecords": 100,
}

# Run the Actor and wait for it to finish
run = client.actor("keeganlabs/ca-unclaimed-property-search").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 '{
  "ownerName": "smith john",
  "minValue": 500,
  "maxRecords": 100
}' |
apify call keeganlabs/ca-unclaimed-property-search --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=keeganlabs/ca-unclaimed-property-search",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "California Unclaimed Property Search (Official SCO Data)",
        "description": "Search California's official unclaimed-property database by owner name, city, ZIP, property type, or value. Weekly-refreshed State Controller data, streamed for speed; pay only per matched record. Built for skip tracing, asset recovery, and found-money features.",
        "version": "0.1",
        "x-build-id": "xPcHczDQgx0oQc8pG"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/keeganlabs~ca-unclaimed-property-search/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-keeganlabs-ca-unclaimed-property-search",
                "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/keeganlabs~ca-unclaimed-property-search/runs": {
            "post": {
                "operationId": "runs-sync-keeganlabs-ca-unclaimed-property-search",
                "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/keeganlabs~ca-unclaimed-property-search/run-sync": {
            "post": {
                "operationId": "run-sync-keeganlabs-ca-unclaimed-property-search",
                "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",
                "properties": {
                    "ownerName": {
                        "title": "Owner name",
                        "type": "string",
                        "description": "Person or business name to search for. Matching is case-insensitive, ignores punctuation, and is word-order independent: \"john o'brien\" matches \"OBRIEN JOHN M\". Every word you enter must appear in the record's owner name, so \"smith\" alone finds all Smiths while \"smith maria\" narrows to Marias. Required unless Browse mode is on."
                    },
                    "city": {
                        "title": "Owner city",
                        "type": "string",
                        "description": "Case-insensitive city filter on the owner's last known address, e.g. \"San Diego\". Handles the source's 15-character truncation (\"Pacific Palisades\" still matches). Note: owner addresses are often years out of date — when in doubt, search by name only."
                    },
                    "zip": {
                        "title": "Owner ZIP code",
                        "pattern": "^[0-9]{5}$",
                        "type": "string",
                        "description": "5-digit ZIP filter on the owner's last known address, e.g. \"90210\". Matches both ZIP and ZIP+4 records."
                    },
                    "propertyType": {
                        "title": "Property type",
                        "type": "string",
                        "description": "Filter by property category: a case-insensitive keyword such as \"insurance\", \"securities\", \"savings\", \"safe-deposit\", \"pensions\" — or an exact NAUPA type code such as \"68\". Leave empty for all types."
                    },
                    "minValue": {
                        "title": "Minimum cash value (USD)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only return properties with a current cash balance of at least this amount. Also speeds runs up dramatically: minValue >= 500 lets the actor scan only the state's 155 MB high-value file instead of 3+ GB of records. Share-only securities records (zero cash, shares on deposit) are always kept within the scanned tiers.",
                        "default": 0
                    },
                    "maxRecords": {
                        "title": "Max records",
                        "minimum": 1,
                        "maximum": 100000,
                        "type": "integer",
                        "description": "Stop after this many matching records (each pushed record is one billable event). Higher-value tiers are scanned first, so the cap keeps the most valuable matches.",
                        "default": 100
                    },
                    "browseMode": {
                        "title": "Browse mode (no name required)",
                        "type": "boolean",
                        "description": "Scan without an owner name — e.g. every $10,000+ property in one ZIP code, or all safe-deposit-box properties in a city. Requires at least one narrowing filter (city, ZIP, property type, or minValue >= 100).",
                        "default": 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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
