# UCC Lien Filings: New UCC-1s, Lapsing & Lien Check (CO, CT, OR) (`cpt_engineering/ucc-lien-filings`) Actor

New UCC-1 feed, lapsing-soon list and bulk lien check from official CO, CT and OR data. Tested Oct 17, 2026: lien counts matched official records; expired liens and amendments not counted; you pay only for exact-name filings. Business debtors, lender names.

- **URL**: https://apify.com/cpt_engineering/ucc-lien-filings.md
- **Developed by:** [Christopher Tolentino](https://apify.com/cpt_engineering) (community)
- **Categories:** Lead generation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.20 / 1,000 ucc filings

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

## UCC Lien Filings: New UCC-1s, Lapsing & Lien Check (CO, CT, OR)

Get **new UCC-1 financing statements every day**, a **"lapsing soon" list** of active UCC liens about to expire, and a **bulk UCC lien search by company name**, straight from the official **Colorado, Connecticut and Oregon** filing-office open data. Every filing comes back in **one normalized schema** (JSON, CSV, Excel): filing number, type, filing and lapse dates, status, **business debtor**, **secured party (lender)** and, for Colorado, the **collateral description**.

**Last verified:** 2026-10-16 (daily automated self-test against the live state sources).

### Tested accuracy (Oct 17, 2026, live build)

| | |
|---|---|
| Active lien counts | **Matched the official CO and CT records for 6 of 6 lien debtors** (e.g. 19 of 19 active filings for a brewer with 58 filings on record) |
| Expired or closed liens | **Not counted**: with *Active filings only* (the default) lapsed, terminated and released filings are excluded |
| Amendments | **Not double-counted**: amendments and continuations are attached to the original filing (one company with 30 state rows = 9 active liens) |
| Exact-match-only billing | 51 charged filings = the 51 exact-name filings returned; 21 similar-name filings returned free (`charged: false`). A run with a spend limit stopped cleanly at the limit |
| Rows | **One row per input**: companies with no filings get a `NO_FILINGS_FOUND` row |
| Speed | **~4.8 s per company** in a lien check of 20 companies |
| Billing | **Free when a source fails**: `SEARCH_FAILED`, and `NO_FILINGS_FOUND` when any state failed, are not charged |

### What to check in any KYB or lien tool

1. **Expired liens counted as active**: a UCC filing lapses after 5 years unless continued, and can be terminated earlier. "Active" should mean not terminated *and* not lapsed.
2. **Amendments double-counted**: amendments and continuations are separate rows in state data; they belong to the original lien, not on top of it.
3. **Wrong-company matches**: short and common names ("M & C Concrete", "Star Group") easily match another company. Look for a match score, the matched legal name, and similar names kept apart.
4. **Charged for failed rows**: check whether you pay when a state source fails or nothing is found. Every input should get a row that says found, not found or failed.

Built for teams that run it **on a schedule** and feed the results into a CRM, a credit workflow or a data pipeline.

**Who it's for**

- **Equipment finance, commercial lenders, MCA and factoring companies**: see which businesses just financed equipment or pledged receivables, who their lender is, and which liens lapse soon (refinance and renewal windows).
- **Credit, underwriting and collections teams**: check a list of customers or borrowers for existing UCC liens (blanket liens, competing lenders, recent new debt) before you extend credit or file your own UCC-1.
- **KYB, due-diligence and M\&A teams**: a lien check alongside the company registry check, with a link to the official record for every row.
- **B2B sales and lead-generation teams** selling to businesses that are actively investing: new equipment loans and leases are a buying signal for services such as payroll, fleet, IT, accounting and equipment maintenance.

**Why this Actor**

- **Three jobs in one Actor**: new-filings feed, lapsing-soon list, and lien check by company name.
- **Made for schedules**: *Only new since last run* returns each filing once across daily or weekly runs, including filings the state publishes late.
- **Official state open-data APIs only**: no scraping, no logins, no proxies, no CAPTCHAs. Each row links to the official record.
- **Business debtors only, ordinary UCC financing statements only**: tax liens, judgment, hospital, labor, municipal, child-support/statutory liens, fixture filings and manufactured-home filings are left out by design, and so are individual (person) debtors. See [Privacy](#privacy-and-what-is-excluded).
- **Pay per filing**, no start fee, and **NO_FILINGS_FOUND** answers in lien checks cost less than a filing.
- **Exact-match billing in lien checks**: you pay only for filings under your company's exact name (after normalizing punctuation, spacing and word order; Inc = Corp = Co and LLC = L.L.C. count as the same). A filing under the same words with a conflicting legal form ("Star Group LP" for "Star Group LLC"; LLC vs LP vs Inc/Corp vs LLP) is a similar name: free, flagged and not counted. Similar-name filings (a typo, or extra words such as "Gold Star Trucking Group" for "Star Group") are returned free with `name_match: SIMILAR_NAME` and `charged: false`, and are never counted.
- **Agent-ready**: plain, machine-readable input descriptions, so it works as a tool through the Apify MCP server and API.

**Why choose this Actor**
| | |
|---|---|
| Reliability | 20 of 20 runs succeeded since launch (Oct 16, 2026); 107 sampled rows matched the state records field by field; timeouts, 429 and 5xx errors retried with exponential backoff (up to 5 attempts); if every portal is down you get a free SEARCH_FAILED row; any state that failed is listed in `states_failed`, and a NO_FILINGS_FOUND with a failed state is free |
| Jobs | New-filings feed, lapsing-soon list and lien check by company name in one Actor |
| Repeat use | *Only new since last run* returns each filing once across daily or weekly runs |
| Lender view | *Secured party contains* filter in every mode; Colorado collateral text included |
| Lapsing soon | Active financing statements expiring in the next N days (Colorado, Connecticut) |
| Batch lien checks | A list of companies in one run, newest filing first, plus a NO_FILINGS_FOUND row per clean company |
| Compliance | Business debtors and ordinary UCC financing statements only; no tax, judgment, hospital or individual records; no phones or emails |
| Price | $4.00 per 1,000 filings, $1.00 per 1,000 NO_FILINGS_FOUND answers, no start fee |
| Speed | One-company lien check across 3 states: about 5 s end to end by API, measured Oct 16, 2026 |

### Quick start

**New UCC-1 filings from the last 7 days (all three states):**

```json
{ "mode": "newFilings", "lastNDays": 7, "maxItems": 500 }
```

**Daily scheduled feed (returns only filings you have not received yet):**

```json
{ "mode": "newFilings", "states": ["CO", "CT"], "lastNDays": 3, "onlyNewSinceLastRun": true, "maxItems": 2000 }
```

**Only filings by certain lenders** (e.g. equipment finance captives):

```json
{ "mode": "newFilings", "lastNDays": 30, "securedPartyNames": ["John Deere", "Caterpillar", "Kubota"], "maxItems": 1000 }
```

**UCC liens lapsing in the next 90 days (refinance / renewal list):**

```json
{ "mode": "lapsingSoon", "states": ["CO", "CT"], "lapsingWithinDays": 90, "maxItems": 1000 }
```

**Lien check for a list of companies:**

```json
{ "mode": "lienCheck", "debtorNames": ["New Belgium Brewing", "Specialty Saw Inc", "Rickabaugh Construction"] }
```

**Track payoffs and renewals** (Colorado terminations and continuations):

```json
{ "mode": "newFilings", "states": ["CO"], "lastNDays": 7, "filingTypes": ["TERMINATION", "CONTINUATION"], "maxItems": 1000 }
```

### What you get (one row per filing)

| Field | Description |
|---|---|
| `state`, `filing_number`, `original_filing_number` | Filing office, this record's number, and the original UCC-1 it belongs to |
| `filing_type`, `filing_type_raw` | `INITIAL`, `AMENDMENT`, `CONTINUATION`, `ASSIGNMENT`, `TERMINATION`, and the state's own label |
| `lien_type` | `UCC`, or `UCC (agricultural)` for Colorado farm-products financing statements |
| `filing_date`, `lapse_date`, `days_until_lapse` | When it was filed and when it expires (after any continuation) |
| `status` | `ACTIVE`, `LAPSED`, `TERMINATED`, `RELEASED`, or `FILED` (Oregon, see below) |
| `debtor_name`, `debtor_city`, `debtor_state`, `debtor_zip` | First business debtor as filed (street line only with *Include debtor street line*) |
| `debtors`, `debtor_count` | All business debtors on the filing |
| `secured_party_name`, `secured_party_city`, `secured_party_state` | First secured party: the lender or lessor, or its filing service ("... as Representative") |
| `secured_parties`, `secured_party_count` | All organization secured parties |
| `collateral` | Collateral text as filed (Colorado only), e.g. an equipment list or "all assets" |
| `query`, `match_score`, `matched_debtor_name`, `result` | Lien check only: your input, the match, or `NO_FILINGS_FOUND` / `SEARCH_FAILED` |
| `name_match`, `charged` | Lien check only: `EXACT` (score 95+, charged) or `SIMILAR_NAME` (85-94, incl. conflicting legal forms at 90; free, for review; up to 10 per company, not counted against *Max items*). `NO_FILINGS_FOUND` rows carry `similar_name_filings` = how many free similar-name rows follow |
| `source_record_url`, `source_dataset_url`, `official_search_url` | Official open-data record, dataset page and the state's own UCC search |
| `retrieved_at` | When the row was read |

Sample row:

```json
{
  "state": "CT", "filing_number": "0005415943", "filing_type": "INITIAL", "filing_date": "2026-10-15",
  "lapse_date": "2031-10-15", "status": "ACTIVE", "debtor_name": "SPECIALTY SAW INC.", "debtor_city": "Simsbury",
  "debtor_state": "CT", "secured_party_name": "OLD SECOND NATIONAL BANK",
  "source_record_url": "https://data.ct.gov/resource/xfev-8smz.json?id_ucc_flng_nbr=0005415943&..."
}
```

A run summary (`RUN_SUMMARY` in the key-value store) lists results per state, the newest filing date each state has published, how many records were excluded for privacy, and any errors.

### Modes

**newFilings**: filings in a date window (*Filed in the last N days*, or *Filed on or after / before*), newest first. Default type is `INITIAL` (new UCC-1s); add UCC-3 types to track amendments, continuations, assignments and terminations. *Debtor company names* and *Secured party contains* work as keyword filters.

**lapsingSoon**: active original financing statements whose current lapse date falls between today and today + *Lapsing within N days*, soonest first (Colorado and Connecticut). A UCC-1 lapses five years after filing unless continued; a lapsing lien is often a loan that is ending or being refinanced.

**lienCheck**: each company in *Debtor company names* is searched in the full UCC index of each state (fuzzy name match: legal-form words, punctuation and "&" vs "and" are ignored; *Minimum name match score* 85 by default). You get one row per matching financing statement, newest first, or one `NO_FILINGS_FOUND` row. *Active filings only* is on by default.

### Run it on a schedule

1. Save your input as a **task** (e.g. "CO+CT new UCC-1s, daily").
2. Turn on **Only new since last run** and use a window a bit longer than the schedule (e.g. `lastNDays: 3` for a daily run) so late-published filings are still caught; already-returned filings are skipped.
3. Add a **schedule** in Apify Console (Schedules > Create) for the task, e.g. every weekday at 7:00.
4. Deliver the results:
   - **Webhooks**: add a webhook on the task for `ACTOR.RUN.SUCCEEDED` and point it at your endpoint (or Zapier / Make / n8n); fetch rows from `resource.defaultDatasetId`.
   - **Integrations**: Apify's built-in Google Sheets, Slack, email, Airbyte and Zapier / Make integrations work with the dataset as is.
   - **API**: `GET https://api.apify.com/v2/actor-tasks/<TASK_ID>/runs/last/dataset/items?format=csv&status=SUCCEEDED`.
5. Set **Max cost per run** (maxTotalChargeUsd) on the task if you want a hard spending cap; the run stops cleanly at the cap and only saved rows are charged.

The seen-filings memory lives in a named key-value store on your own account (`ucc-lien-filings-state`). Delete that store to start fresh.

**Oregon cadence**: Oregon publishes one list per month (the previous month's new filings, around the 1st). Schedule Oregon monthly, or use `lastNDays: 45`.

### Coverage and freshness

| State | Source (official open data) | Updated | Notes |
|---|---|---|---|
| Colorado | Colorado Department of State UCC filings, debtors, secured parties and collateral (data.colorado.gov `wffy-3uut`, `8upq-58vz`, `ap62-sav4`, `4am6-w6u4`) | Daily | Full history; collateral text included; status from termination records and lapse date |
| Connecticut | Office of the Secretary of the State, UCC Lien Filings (data.ct.gov `xfev-8smz`) | Daily | Active liens plus those lapsed less than 1 year; recent UCC-3 records (continuations, terminations) are published as `AMENDMENT` |
| Oregon | Secretary of State, UCC List of Filings Entered Last Month (data.oregon.gov `snfi-f79b`) | Monthly | Previous month only, initial filings and amendments; status shown as `FILED` because later changes are not published; no lapsing-soon list |

Volume (Sep 16 to Oct 15, 2026): about 2,200 Connecticut and 4,400 Colorado new UCC-1s a month, and 2,200 in Oregon's monthly list, before the business-debtor filter.

### Privacy and what is excluded

This Actor returns **business-to-business secured-transaction records only**:

- **Only UCC financing statements** (and their amendments). Not returned: federal and state tax liens, judgment liens, hospital liens, child-support and other statutory liens, labor and municipal liens, utility and public-finance filings, vessel and aircraft liens, effective financing statements (farm products), fixture filings and manufactured-home filings.
- **Only organization debtors and secured parties.** Individual debtors, sole proprietors filed under a person's name, personal and family trusts, estates and self-filed "sovereign" filings are excluded. Filings with only individual debtors, or with only an individual as secured party, are skipped entirely. Person-name columns are never downloaded.
- **No phone numbers or emails**, and no contact enrichment. Debtor street lines are off by default.
- The person filter works on the name text the state publishes; a small number of business names that look like a person's name are skipped too.

Use the data lawfully. If you contact businesses from this list, follow the rules that apply to you (for example CAN-SPAM and TCPA in the US).

### Pricing

Pay per event, no start fee:

| Event | No discount | Bronze | Silver | Gold+ |
|---|---|---|---|---|
| Filing row (per 1,000); in lien checks only filings under the exact company name | **$4.00** | $3.72 | $3.48 | $3.20 |
| Lien check, similar-name filing (`name_match: SIMILAR_NAME`) | free | | | |
| Lien check, NO_FILINGS_FOUND (per 1,000 companies) | **$1.00** | $0.93 | $0.87 | $0.80 |
| NO_FILINGS_FOUND while any searched state portal failed (`states_failed` not empty) | free | | | |
| SEARCH_FAILED (every searched state portal was down) | free | | | |

Example: Colorado + Connecticut produced 648 business-debtor UCC-1s in 7 days (Oct 9-16, 2026), so a daily feed of both states costs about $0.37 per day. Set *Max results* or a run spend limit (*Max cost per run*) to cap a run; the run stops cleanly at the limit and only saved rows are charged.

Filters (*Secured party contains*, *Debtor company names* in feed mode) are applied after download, so narrow filters over long windows take longer, but you are only charged for rows returned.

### Use it from your app (one company per call)

```bash
curl -X POST "https://api.apify.com/v2/acts/cpt_engineering~ucc-lien-filings/run-sync-get-dataset-items?token=<YOUR_APIFY_TOKEN>" \
  -H "Content-Type: application/json" \
  -d '{"mode": "lienCheck", "debtorNames": ["Specialty Saw Inc"]}'
```

### Related Actors (same publisher)

- [**Company Due Diligence Check**](https://apify.com/cpt_engineering/company-due-diligence-check): registry status, UCC liens, OFAC sanctions and SAM.gov exclusions screens for a company in one row, with risk flags.
- [**US Company Lookup & KYB Verification**](https://apify.com/cpt_engineering/us-company-lookup-kyb): check that each debtor is a registered company in good standing (CO, CT, NY, OR, PA, TX) before or after a lien check.
- [**US New Business Registrations**](https://apify.com/cpt_engineering/us-business-registrations-open-data): daily list of newly formed companies in six states.

### FAQ

**Is this a certified UCC search?** No. It is built from the states' open data, which can lag the filing office by a day or more. For a certified search (e.g. for closing a loan), use the state's official search page linked in each row.

**Why are some filings missing compared to the state's own search?** Filings with only individual debtors, non-UCC liens and the other excluded types are left out by design (see Privacy). Connecticut's open data also drops liens more than one year past lapse.

**Which secured party is "Corporation Service Company, as Representative"?** Filing services (CSC, Middesk, TAH Services, ...) often file on behalf of the real lender. The collateral text (Colorado) or the official record usually names the lender.

**Can I search by lender?** Yes: *Secured party contains* works in every mode, e.g. all new John Deere filings in the last 30 days.

### Support

Open an issue on this Actor or email **cpt-datatools@mail.grokbot.com**. We reply to issues and support emails within 1 business day.

### Changelog

- **Oct 17, 2026 (afternoon):** lien checks treat conflicting legal forms (LLC vs LP vs Inc/Corp vs LLP, when both names have one) as `SIMILAR_NAME`: free, flagged, not counted. Equivalent forms (Inc / Incorporated / Corp / Corporation / Co; LLC / L.L.C. / Limited Liability Company) still match exactly.
- **Oct 17, 2026 (midday):** added the *Tested accuracy* results (20-company test on the live build) and a buyer's checklist.
- **Oct 17, 2026:** exact-match billing in lien checks: only filings under the company's exact (normalized) name are charged and counted; similar-name filings are returned free with `name_match: SIMILAR_NAME`.
- **Oct 17, 2026:** lien check: short names such as "M & C Concrete LLC" now run an extra 'starts with' search so their own filings can't be cut off, and a more generic debtor name ("The Concrete Company") no longer matches a more specific company.
- **Oct 16, 2026 (night):** `NO_FILINGS_FOUND` is now free when any searched state portal failed (listed in `states_failed`); daily automated self-test with source schema-change detection; *Last verified* line; support response promise.
- **Oct 16, 2026 (midday):** NO_FILINGS_FOUND answers priced at $1.00 per 1,000 (tiers $0.93 / $0.87 / $0.80); run summary now reports `companies_cut_by_limit` separately when a spend limit stops a run.
- **Oct 16, 2026:** launched: CO, CT, OR; new-filings feed, lapsing soon, lien check, *Only new since last run*.

### Source data disclaimer

The data made available here has been modified for use from its original source, which is the State of Colorado. THE STATE OF COLORADO MAKES NO REPRESENTATIONS OR WARRANTY AS TO THE COMPLETENESS, ACCURACY, TIMELINESS, OR CONTENT OF ANY DATA MADE AVAILABLE THROUGH THIS SITE. THE STATE OF COLORADO EXPRESSLY DISCLAIMS ALL WARRANTIES, WHETHER EXPRESS OR IMPLIED, INCLUDING ANY IMPLIED WARRANTIES OF MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE. The data is subject to change as modifications and updates are complete. It is understood that the information contained in the Web feed is being used at one's own risk.

Connecticut data: Connecticut Office of the Secretary of the State, via data.ct.gov. Oregon data: Oregon Secretary of State, via data.oregon.gov. Both are provided "as is", without warranty of accuracy, completeness or timeliness. This Actor is not affiliated with or endorsed by any state.

# Actor input Schema

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

newFilings: UCC filings filed in a date window, newest first (schedule it daily or weekly with 'Only new since last run'). lapsingSoon: active original financing statements whose lapse date falls in the next 'Lapsing within N days' (CO and CT). lienCheck: search each company in 'Debtor company names' and return its UCC financing statements (one row per filing, plus a NO_FILINGS_FOUND row for companies without any).

## `states` (type: `array`):

Two-letter codes of the state UCC filing offices to query. Supported: CO, CT, OR. Empty = all three. Colorado and Connecticut update daily; Oregon publishes the previous month's new filings around the 1st of each month.

## `lastNDays` (type: `integer`):

newFilings only. Window counted back from today, e.g. 1 = since yesterday (daily schedule), 7 = this week, 45 = includes Oregon's latest monthly list. Ignored when 'Filed on or after' is set.

## `sinceDate` (type: `string`):

newFilings only. Exact start date, e.g. 2026-09-01. Overrides 'Filed in the last N days'.

## `untilDate` (type: `string`):

newFilings only. Optional end date, e.g. 2026-09-30. Empty = today.

## `onlyNewSinceLastRun` (type: `boolean`):

newFilings only. true: remember which filings this Actor already returned to you (in a named key-value store on your account, 'ucc-lien-filings-state') and skip them, so a daily or weekly schedule returns each filing once, including filings the state publishes late. Use it for scheduled runs and tasks. false (default): always return the full window, so test runs are repeatable.

## `filingTypes` (type: `array`):

newFilings only. INITIAL = new UCC-1 financing statements (new lending relationships, the usual lead list). Add AMENDMENT, CONTINUATION, ASSIGNMENT or TERMINATION (UCC-3 records) to track changes, e.g. TERMINATION = a loan was paid off. Oregon reports only INITIAL and AMENDMENT. lapsingSoon and lienCheck always use original financing statements.

## `lapsingWithinDays` (type: `integer`):

lapsingSoon only. Return active financing statements whose lapse date is between today and today + N days, soonest first, e.g. 90 or 180.

## `debtorNames` (type: `array`):

lienCheck: the companies to search, one per line, e.g. 'New Belgium Brewing'. Fuzzy match on the debtor organization name (legal-form words and punctuation ignored). newFilings / lapsingSoon: optional filter, keep only filings whose debtor name contains any of these words (case-insensitive).

## `securedPartyNames` (type: `array`):

Optional, all modes. Keep only filings where a secured party name contains any of these words (case-insensitive), e.g. \['John Deere', 'Wells Fargo', 'Corporation Service Company']. Empty = all lenders.

## `minMatchScore` (type: `integer`):

lienCheck only. 0-100 similarity between your company name and the debtor name. Filings scoring 95+ (same name after normalizing punctuation, legal form and word order) are EXACT and charged; filings between this minimum and 94 are returned free as SIMILAR_NAME for review. 85 (default) shows similar names; set 95 to return exact names only.

## `maxFilingsPerCompany` (type: `integer`):

lienCheck only. Maximum filing rows returned for one company.

## `activeOnly` (type: `boolean`):

true (default): skip financing statements that are terminated, released or past their lapse date. false: also return them (lienCheck history; Connecticut keeps lapsed filings for only one year).

## `includeCollateral` (type: `boolean`):

Colorado only: add the collateral text as filed (e.g. equipment list, 'all assets'), cut at 1,500 characters.

## `includeStreetAddress` (type: `boolean`):

false (default): debtor city, state and ZIP only. true: also the street line as filed (organization debtors only).

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

Maximum rows returned (and charged) in total. Feeds split it evenly across the selected states, e.g. 300 with 3 states = up to 100 per state. Raise it for full daily or weekly lists (about 200 new filings per day across CO and CT).

## `socrataAppToken` (type: `string`):

Optional free app token from a state open-data portal. Only useful for very large pulls; not required.

## Actor input object example

```json
{
  "mode": "newFilings",
  "states": [
    "CO",
    "CT",
    "OR"
  ],
  "lastNDays": 7,
  "onlyNewSinceLastRun": false,
  "filingTypes": [
    "INITIAL"
  ],
  "lapsingWithinDays": 90,
  "debtorNames": [],
  "securedPartyNames": [],
  "minMatchScore": 85,
  "maxFilingsPerCompany": 50,
  "activeOnly": true,
  "includeCollateral": true,
  "includeStreetAddress": false,
  "maxItems": 100
}
```

# Actor output Schema

## `results` (type: `string`):

Dataset items: one UCC filing per item (state, filing number, type, dates, organization debtor, secured party, status, source link).

## `summary` (type: `string`):

JSON record RUN_SUMMARY: results per state, privacy exclusions, newest filing date each state has published, errors, requests and duration.

# 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 = {
    "states": [
        "CO",
        "CT",
        "OR"
    ],
    "lastNDays": 7,
    "lapsingWithinDays": 90,
    "maxItems": 100
};

// Run the Actor and wait for it to finish
const run = await client.actor("cpt_engineering/ucc-lien-filings").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 = {
    "states": [
        "CO",
        "CT",
        "OR",
    ],
    "lastNDays": 7,
    "lapsingWithinDays": 90,
    "maxItems": 100,
}

# Run the Actor and wait for it to finish
run = client.actor("cpt_engineering/ucc-lien-filings").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 '{
  "states": [
    "CO",
    "CT",
    "OR"
  ],
  "lastNDays": 7,
  "lapsingWithinDays": 90,
  "maxItems": 100
}' |
apify call cpt_engineering/ucc-lien-filings --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,cpt_engineering/ucc-lien-filings"
        }
    }
}
```

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/tb0w256RQNjb7Jwlo/builds/GuuANiL5S7XP8l3C4/openapi.json