# US County & City Unclaimed Funds Scraper (`vexaloom-labs/us-county-and-city-unclaimed-funds-scraper`) Actor

Search unclaimed money and uncashed checks published by US county and city treasuries across six states. Search by owner name or browse by state, with amount, holder, property type and dates where disclosed.

- **URL**: https://apify.com/vexaloom-labs/us-county-and-city-unclaimed-funds-scraper.md
- **Developed by:** [vexaloom-labs](https://apify.com/vexaloom-labs) (community)
- **Categories:** Automation, Lead generation, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.49 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
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?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## 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.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## US Unclaimed Property & Funds Scraper

Search unclaimed money and uncashed checks across 12 public US registers in one run. The actor reads statewide bulk files from California and Iowa plus municipal open-data registers, then returns owner, amount, holder, property type, dates and property IDs where the source discloses them.

### What it does

- **Three modes:** `search` by owner name, `browse` a register, and `byPropertyId` for an exact property, warrant or check lookup.
- **12 sources in 7 states:** California, Iowa, Massachusetts, Maryland, Minnesota, Rhode Island and Texas.
- **Up to 50,000 records per run** — the old 1,000-row ceiling is gone, and every source is paginated or streamed to its own limit.
- **Useful filters:** amount range, include/exclude records with no disclosed amount, date range, broad property-type groups, raw type text and property ID.
- **Seven sort orders:** amount, date, owner name and source order.
- **Empty fields are omitted** — the actor never invents a value for a field a source does not publish.

### Services covered

| State | Source | What it publishes |
|---|---|---|
| CA | California State Controller (SCO) | Statewide unclaimed property, weekly ZIP/CSV archive |
| CA | Marin County | Uncashed county checks |
| CA | City of Roseville | Stale-dated municipal checks |
| CA | Sonoma County | Stale-dated county checks |
| IA | Iowa Department of Administrative Services | Outdated state warrants by fiscal year |
| MA | Town of Framingham | Unclaimed payroll checks |
| MA | Town of Framingham | Unclaimed resident/vendor/AP checks |
| MD | Montgomery County | Unclaimed vendor payments |
| MN | Ramsey County | Unclaimed money |
| RI | City of Providence | Uncashed municipal checks |
| TX | City of Austin | Unclaimed property |
| TX | City of Corpus Christi | Unclaimed property |

### How it works

Municipal registers are queried through their public Socrata (SODA) JSON APIs with `$limit`, `$offset`, deterministic `$order` and server-side filters. California publishes four value-range ZIP archives (plus an all-records archive the actor does not download); the actor streams the selected range file to a temporary file with HTTP Range resume, scans the CSV parts line by line, and deletes the file. Iowa publishes one XLSX per fiscal year, read in openpyxl's read-only mode and deleted after the scan. All sources are anonymous: no account, cookie, API key or proxy setup is required.

The California statewide file has no date field. When a date filter is set, California statewide and the other date-less registers are skipped and the status message says so. The default California range is `$500 and above` (about 163 MB); choosing all value ranges scans four files one at a time, which takes much longer. A property-ID lookup always checks every California range, smallest archive first, and stops once the bucket containing the ID has been scanned, so an ID below `$500` is never hidden by the default.

### Input

| Field | Type | Default | Notes |
|---|---|---|---|
| `mode` | select | `search` | `search`, `browse` or `byPropertyId` |
| `state` | select | `MN` | `ALL`, `CA`, `IA`, `MA`, `MD`, `MN`, `RI`, `TX` |
| `jurisdiction` | select | `ALL` | Narrow to one of the 12 sources |
| `ownerName` | text | — | Case-insensitive; word order and commas do not matter |
| `propertyId` | text | — | Exact property ID, warrant or check number |
| `minAmountUsd` | number | `0` | Amount floor; `0` means no floor |
| `maxAmountUsd` | number | — | Amount ceiling |
| `includeUnknownAmount` | boolean | `false` | Keep records with no amount when an amount filter is active |
| `dateFrom` | text | — | Earliest date, `YYYY-MM-DD` |
| `dateTo` | text | — | Latest date, inclusive, `YYYY-MM-DD` |
| `propertyType` | select | `ALL` | 10 broad groups over raw NAUPA codes and source categories |
| `propertyTypeContains` | text | — | Raw type substring filter, e.g. `Dividend` |
| `sortBy` | select | `amountDesc` | Amount, date, owner name or source order |
| `maxItems` | integer | `20` | `1`–`50,000` |
| `valueRange` | select | `500plus` | California archive range; ignored for property-ID lookups, which scan all ranges |
| `iaFiscalYear` | select | `latest` | Iowa fiscal year, `all`, or a specific year |

#### Examples

Search one name across every state:

```json
{"mode": "search", "state": "ALL", "ownerName": "Smith", "maxItems": 50}
```

Browse California's largest balances:

```json
{"mode": "browse", "state": "CA", "jurisdiction": "ca_sco", "minAmountUsd": 1000, "maxItems": 100}
```

Look up a California property ID:

```json
{"mode": "byPropertyId", "state": "CA", "propertyId": "13755891"}
```

Browse Iowa warrants from FY2026 with dates:

```json
{"mode": "browse", "state": "IA", "iaFiscalYear": "2026", "dateFrom": "2025-07-01", "sortBy": "dateDesc", "maxItems": 100}
```

### Output

Every record contains the fields the source actually discloses. Existing fields are unchanged; the revamp adds richer fields beside them.

| Field | Description |
|---|---|
| `ownerName` | Owner/payee name |
| `amountUsd` | Current cash balance or warrant/check amount |
| `reportedDate` | Check, warrant or payment date (`YYYY-MM-DD`) |
| `address`, `city`, `postalCode` | Owner last-known address, where disclosed |
| `ownerState`, `ownerCountry` | Owner state/country, where disclosed (California) |
| `recordId` | Source record/check/warrant ID |
| `propertyId` | California property ID |
| `checkNumber`, `warrantNumber` | Source check or warrant number |
| `departmentCode` | Issuing Iowa department |
| `vendorId`, `invoiceDate`, `paymentStatus` | Montgomery County vendor-payment fields |
| `holderName` | Entity holding the funds |
| `holderAddress`, `holderCity`, `holderState`, `holderZip` | Holder location, where disclosed (California) |
| `propertyType` | Raw source category or NAUPA property-type string |
| `cashReported`, `sharesReported` | Reported cash and share counts (California) |
| `securitiesName`, `cusip` | Security description and CUSIP (California) |
| `numberOfOwners`, `pendingClaims`, `paidClaims` | Ownership and claim counts (California) |
| `valueRange` | California archive range the row came from |
| `state`, `jurisdiction` | Two-letter state and source name |
| `sourceKey`, `sourceName`, `sourceType` | Source traceability |
| `sourceUpdatedAt` | Source file date (California/Iowa) |
| `sourceUrl`, `claimUrl` | Public dataset page and official claim/search page |
| `recordType` | Always `unclaimedProperty` |
| `scrapedAt` | UTC scrape timestamp |

### Usage cost

The actor runs on Apify's standard compute pricing. It uses no paid proxy and no external API key, so the only cost is the run's memory and compute time plus Apify's usual dataset/result charges. The default 2 GB memory is sized for the California ZIP streaming path. Start with a small `maxItems` and the default `$500+` range for browsing; a full California `all` scan is intentionally expensive in time because it reads four multi-hundred-megabyte archives.

### FAQ

**Does this search every US state?** No. It covers the 7 states listed above. Most other states publish their live search only through CAPTCHA- or WAF-gated portals, and this actor does not attempt to bypass those. The official state claim portals remain the right place to file a claim.

**Why are some records missing an amount?** A few registers publish names without a dollar value. When an amount filter is active, those records are excluded unless `includeUnknownAmount` is enabled.

**Why does a date filter drop California results?** The California statewide file has 25 columns but no date field. Date filters therefore skip it rather than guessing a date.

**What is the difference between `search` and `byPropertyId`?** `search` treats the name as words in any order. `byPropertyId` performs an exact match against property IDs, warrants and check numbers. Both accept the other field as an additional filter. A California property-ID lookup scans all four value-range archives because an ID lives in only one of them; this can take several minutes.

**How fresh is the data?** Municipal Socrata registers refresh on their own schedules, California posts new archives weekly (usually Thursday), and Iowa adds fiscal-year files as warrants are cancelled. The actor always reads the currently published source.

**Can I get more than 5,000 rows from multiple sources at once?** Yes, up to 50,000, but a multi-source run keeps at most 5,000 candidates per source so memory stays bounded. To take a single source deeper, select that jurisdiction alone.

**How do I claim money I find?** This actor only reports public records. Contact the `jurisdiction`/`holderName` office or use the `claimUrl` on the record.

**Are the addresses and names personal data?** Yes — they are public-record claimant data. Use them only with a lawful basis, and do not combine them with other datasets to re-identify people.

### Notes

- Public-record data only: owner names and last-known addresses as published by government offices. No SSN, phone, email or claimant identity is collected.
- No CAPTCHA solving, no login, no credentials, and no proxy configuration are required or supported.
- California and Iowa archives are streamed and deleted per run; rows are never materialised in memory all at once.
- Duplicate rows are removed by source + record identity, while legitimate co-owners on one property ID are preserved.
- Invalid dates and inverted ranges produce a clear status message and a clean zero-record run rather than a crash.

### Limitations

- **7 states, not 50.** MissingMoney.com and most state live-search portals are behind CloudFront/WAF/Turnstile blocks. The actor links users to the official portals instead of bypassing them.
- **No date for California statewide records.** The source does not publish one.
- **California property-ID lookups are slower.** They must check every value-range archive (smallest first) and stop only after the matching bucket, because the default `$500+` range would otherwise hide lower balances.
- **The California all-records archive is large.** The default `$500+` file is about 163 MB compressed; the full all-records ZIP is 3.25 GB, which is why the actor scans the four smaller range files instead.
- **Some municipal datasets change schema.** Column names are verified against the live APIs; a renamed column causes that source to be skipped with a status note rather than returning wrong data.
- **Amounts can be stale.** A published balance is the holder's last report, not a live claim valuation.

# Actor input Schema

## `mode` (type: `string`):

search: find records by owner name or property ID. browse: list a register without a name filter. byPropertyId: exact property/warrant/check lookup.

## `state` (type: `string`):

Which state's unclaimed-property source(s) to query. 'All states' fans out to every supported source in one run.

## `jurisdiction` (type: `string`):

Narrow to one specific government source (useful when a state has more than one, e.g. California or Massachusetts). 'All jurisdictions' queries every source in the selected state(s).

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

Full or partial owner/payee name (case-insensitive). Words can be in any order and commas are ignored, so `Smith, John` and `John Smith` both work.

## `propertyId` (type: `string`):

Exact property ID, warrant number or check number. Works in every mode; `byPropertyId` is the dedicated lookup mode.

## `minAmountUsd` (type: `number`):

Only include records worth at least this much. 0 = no minimum. When an amount filter is active, records whose source discloses no amount are excluded unless `includeUnknownAmount` is on.

## `maxAmountUsd` (type: `number`):

Only include records worth at most this much. Leave unset for no maximum.

## `includeUnknownAmount` (type: `boolean`):

When an amount filter is active, also keep records whose source publishes no dollar amount (for example City of Austin, TX).

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

Earliest check/warrant issue date (YYYY-MM-DD). Only sources that disclose dates are searched; California's statewide file has no date field and is skipped.

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

Latest check/warrant issue date, inclusive (YYYY-MM-DD).

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

Broad property-type group. California's 190 raw NAUPA codes are mapped into these groups; use `propertyTypeContains` for an exact raw-string filter.

## `propertyTypeContains` (type: `string`):

Advanced: keep only records whose raw source type contains this text, e.g. `Dividend` or `Endowment`. Combined with the group filter.

## `sortBy` (type: `string`):

How to order results. `relevance` preserves source and file order. Records missing the chosen field sink to the bottom.

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

Hard cap on emitted records (1–50,000).

## `valueRange` (type: `string`):

Which California State Controller archive to scan for browsing and name searches. Exact property-ID lookups scan all four ranges (smallest first) so lower balances are not missed, then stop at the matching range. `All value ranges` scans four range files one at a time and is much heavier than the default.

## `iaFiscalYear` (type: `string`):

Which Iowa DAS outdated-warrant file(s) to read. `Latest` is the newest posted fiscal year.

## Actor input object example

```json
{
  "mode": "search",
  "state": "MN",
  "jurisdiction": "ALL",
  "ownerName": "Johnson",
  "minAmountUsd": 0,
  "includeUnknownAmount": false,
  "propertyType": "ALL",
  "sortBy": "amountDesc",
  "maxItems": 3,
  "valueRange": "500plus",
  "iaFiscalYear": "latest"
}
```

# Actor output Schema

## `unclaimedProperty` (type: `string`):

Dataset containing all scraped unclaimed-property 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 = {
    "mode": "search",
    "state": "MN",
    "jurisdiction": "ALL",
    "ownerName": "Johnson",
    "minAmountUsd": 0,
    "includeUnknownAmount": false,
    "propertyType": "ALL",
    "sortBy": "amountDesc",
    "maxItems": 3,
    "valueRange": "500plus",
    "iaFiscalYear": "latest"
};

// Run the Actor and wait for it to finish
const run = await client.actor("vexaloom-labs/us-county-and-city-unclaimed-funds-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 = {
    "mode": "search",
    "state": "MN",
    "jurisdiction": "ALL",
    "ownerName": "Johnson",
    "minAmountUsd": 0,
    "includeUnknownAmount": False,
    "propertyType": "ALL",
    "sortBy": "amountDesc",
    "maxItems": 3,
    "valueRange": "500plus",
    "iaFiscalYear": "latest",
}

# Run the Actor and wait for it to finish
run = client.actor("vexaloom-labs/us-county-and-city-unclaimed-funds-scraper").call(run_input=run_input)

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

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

```

## CLI example

```bash
echo '{
  "mode": "search",
  "state": "MN",
  "jurisdiction": "ALL",
  "ownerName": "Johnson",
  "minAmountUsd": 0,
  "includeUnknownAmount": false,
  "propertyType": "ALL",
  "sortBy": "amountDesc",
  "maxItems": 3,
  "valueRange": "500plus",
  "iaFiscalYear": "latest"
}' |
apify call vexaloom-labs/us-county-and-city-unclaimed-funds-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,vexaloom-labs/us-county-and-city-unclaimed-funds-scraper"
        }
    }
}
```

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

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/E9Ke5Ax2TNnDP1qfe/builds/5kMa20fol8r9Ve8yA/openapi.json