# OR UCC Secured Parties - Lien Holder Search (`j0401/or-ucc-secured-parties`) Actor

Oregon UCC financing-statement register by secured party (public open data, 220k records): who holds a secured claim on an Oregon debtor - lender, lessor, trustee or tax authority with its address, the lien type, filing and lapse dates and the filing image link.

- **URL**: https://apify.com/j0401/or-ucc-secured-parties.md
- **Developed by:** [Wenhao Yang](https://apify.com/j0401) (community)
- **Categories:** Business
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.06 / 1,000 or ucc secured-party records

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

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

## OR UCC Secured Parties - Lien Holder Search

When a lender takes a security interest in a business - equipment financing, inventory, receivables - it files a **UCC financing statement** with the Oregon Secretary of State. Those filings are public, and they are published as open data. This actor turns that register into a **charged-per-record search, filter and aggregate tool**: find everything a given lender has filed, pull the parties on a single statement, filter by lien type or date window, or aggregate the register.

**Built for:** lenders and credit analysts checking who else has a claim on a debtor, M\&A and asset-based diligence, judgment and tax-lien recovery work, and anyone who wants **the public record of a lien holder in Oregon** without paging a state portal one name at a time.

### What it covers

**220,136 secured-party records** - the state's current UCC register, across **214,875 filings** (a statement names as many parties as it likes - one filing in this corpus carries 17 separate secured-party rows - so one filing number can return more than one row).

Each record carries:

- the **secured party** - the lender, lessor, trustee or tax authority holding the claim, with its street, city, state, postal code and country
- the **lien type** - `UCC` (**194,722**), `EFS` farm-products (**7,604**), `IRS` (**7,323**), `CW` construction (**5,076**), `RW` (**2,477**), `TU` transmitting utility (**1,360**), `PF` public finance (**850**), `IRS-X` released (**603**), `ASL` (**97**), `APL` (**24**) - each with a plain-English label alongside the source code
- the **filing date** and the **lapse date**
- a **link to the filing image** on the Secretary of State's record viewer

### The fine print that matters

This table is the **secured-party side only** - it carries no debtor name or debtor address. It answers "who holds the claim", not "who owes it". (For the debtor side, see the Connecticut UCC actor, which is the mirror image.)

A **filing number is not a party**. The number identifies the statement; the register lists every secured party named on it, so a filing number can legitimately return more than one record - and the rows are genuinely different parties, not duplicates, so nothing is merged away. Numbers come in two shapes: a bare 8-digit form, and a suffixed form (`-1`, `-2`, `-3`) for the Nth party on the same statement.

Two date notes that will otherwise mislead you. **1,285 records carry no lapse date** - filings with no lapse date of record - so a lapse-window query matches only filings that actually carry a date in that window; those rows are not dropped from an unfiltered pull. And **76 records carry a lapse date past 2100** (out to 2109, with one at 3030). Those are real, not junk: 75 are transmitting-utility filings, held by Wilmington Trust National Association (19), UBS AG Stamford Branch (7), Wilmington Savings Fund Society (6) and similar collateral agents, which run on long or indefinite terms. They are served exactly as the state publishes them, and because a lapse filter is bounded to plausible dates they surface on an unfiltered or near-term pull rather than through a year range.

The register is a **historical archive** reaching back to **1963**, refreshed monthly.

### Typical questions

- "Everything a given **lender** holds a secured claim on in Oregon."
- "**IRS** or **construction** liens by a given filer."
- "The parties on **one financing statement**."
- "Filings **about to lapse** - the liens expiring in a window."
- "Aggregate the register by **lien type**, **state** or **country**."

### Inputs

| Input | What it does |
|---|---|
| `mode` | `rows` (default) / `aggregate` |
| `securedParty` | lien-holder name substring |
| `fileNumber` | exact filing number (bare or suffixed form) |
| `lienType` | UCC / EFS / IRS / CW / RW / TU / PF / IRS-X / ASL / APL |
| `city` / `state` / `country` | secured-party location |
| `filedFrom` / `filedTo` | filing-date window |
| `lapseFrom` / `lapseTo` | lapse-date window |
| `groupBy` | aggregate over lien type / state / country |
| `maxResults` | cap records (default 50) |

**Default run = the 50 most recent secured-party records** - fast for the daily auto-test. For a targeted query add a filter; for a broad view use `aggregate`.

### Low cost

**From $0.00006 per record** Pay-per-event: you are charged per record delivered, and nothing for the query. Cost scales with what you pull, not with the size of the register, and each record is metered individually - a full lender pull costs a fraction of a cent.

# Actor input Schema

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

rows = secured-party records matching your filters (default). aggregate = one count row per group (see groupBy).

## `securedParty` (type: `string`):

The lender / lessor / trustee / tax authority holding the claim - name substring, e.g. 'BANK OF EASTERN OREGON'. Blank = any.

## `fileNumber` (type: `string`):

Exact filing number. Either the bare 8-digit form (e.g. '94585876') or the suffixed form for the Nth party on the same statement (e.g. '94490029-1'). One statement can name several parties, so a filing number can return more than one row.

## `lienType` (type: `string`):

UCC (194,722), EFS = farm-products effective financing (7,604), IRS (7,323), CW = construction (5,076), RW (2,477), TU = transmitting utility (1,360), PF = public finance (850), IRS-X = released (603), ASL (97), APL (24). Blank = any.

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

Secured party city substring. Blank = any.

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

Two-letter secured-party state, e.g. 'OR' (48,482), 'TX' (28,784), 'CA' (24,504), 'IL' (21,130). Blank = any.

## `country` (type: `string`):

Secured party country, e.g. 'USA'. Blank = any.

## `filedFrom` (type: `string`):

Earliest filing date, YYYY-MM-DD. Blank = any. The register reaches back to 1963.

## `filedTo` (type: `string`):

Latest filing date, YYYY-MM-DD. Blank = any.

## `lapseFrom` (type: `string`):

Earliest lapse date, YYYY-MM-DD - use this to surface filings expiring in a window. Blank = any. Note: 1,285 rows carry no lapse date and are matched by no lapse window.

## `lapseTo` (type: `string`):

Latest lapse date, YYYY-MM-DD. Blank = any.

## `groupBy` (type: `string`):

Which dimension to aggregate over.

## `maxResults` (type: `integer`):

Cap the number of records pushed in rows mode (0 = up to ~10k per run; each record is metered individually, so there is no per-run charge cap). Aggregate mode returns every group.

## Actor input object example

```json
{
  "mode": "rows",
  "securedParty": "",
  "fileNumber": "",
  "lienType": "",
  "city": "",
  "state": "",
  "country": "",
  "filedFrom": "",
  "filedTo": "",
  "lapseFrom": "",
  "lapseTo": "",
  "groupBy": "lienType",
  "maxResults": 50
}
```

# Actor output Schema

## `recordsUrl` (type: `string`):

Oregon UCC secured-party records or aggregates - as JSON

## `datasetUrl` (type: `string`):

No description

## `runUrl` (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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("j0401/or-ucc-secured-parties").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 = {}

# Run the Actor and wait for it to finish
run = client.actor("j0401/or-ucc-secured-parties").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 '{}' |
apify call j0401/or-ucc-secured-parties --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,j0401/or-ucc-secured-parties"
        }
    }
}
```

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/Rwr7rqzytwYy0WZ3P/builds/WTxd8HM1544NCKDdI/openapi.json