# CT UCC Filings - Secured Lien & Debtor Search (`j0401/ct-ucc-filings`) Actor

Connecticut UCC financing-statement index (public open data, 846k debtor records): the public record of secured claims on a business or person - both debtor and secured party with names and addresses, the filing type, the lien class (OFS / MUNICIPAL / IRS / LABOR) and the acceptance and lapse dates.

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

## Pricing

from $0.06 / 1,000 ct ucc debtor 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

## CT UCC Filings - Secured Lien & Debtor Search

When a lender takes a security interest in a business - equipment financing, inventory, receivables - it files a **UCC financing statement** with the Connecticut Secretary of the State. Those filings are public, and they are published as open data. This actor turns that index into a **charged-per-record search, filter and aggregate tool**: find a debtor by name, find everything a given lender has filed, pull the filings on a single statement, 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 lien record on a Connecticut business** without paging a state portal one name at a time.

### What it covers

**846,538 debtor records** - the state's UCC filing index, across **437,080 financing statements** (a filing names as many debtors as it likes - one statement in this corpus carries 492 separate debtor rows - so one filing can return more than one row).

Both sides of the transaction, not just one name:

- the **debtor** - an **organization** (name) or a **natural person** (prefix / first / middle / last / suffix), with its street, city, state and zip to address 2
- the **secured party** - the lender, lessor or tax authority holding the claim, with its own full name parts and address
- the **filing type** - 29 values: `ORIG FIN STMT` (**519,137**), `AMENDMENT` (**306,985**), `RELEASE ORIG` (**6,850**), `CONTINUATION`, `ASSIGNMENT`, `TERMINATION`, `VESSEL LIEN`, `AIRCRAFT LIEN`, `JUDGMENT LIEN`
- the **lien class** - 15 values: `OFS` (**503,677**), `MUNICIPAL` (**220,461**), `IRS` (**81,204**), `LABOR` (**21,828**), `DEPT REV SERVS`, `TRANS UTILITY`, `PUBLIC-FINANCE`, `VESSEL`
- the **lien status** - `Active` (**844,000**) / `Released` (**2,361**) / `Terminated` (**177**)
- both the **acceptance date** and the **lapse date**, plus the record volume, start page and page count

### The fine print that matters

A **filing number is not a debtor**. The number identifies the statement; the index lists every debtor named on it, so `filingNo` can legitimately return more than one record - and the rows differ by debtor, not by duplication, so nothing is merged away.

The register carries **two filings numbers, and they mean different things**: the original filing number, and the subsequent filing number. They are identical on the **523,821** filings that were never amended and differ on the **322,705** that were - so an amendment sits on the same statement but not on the same column, and both are returned.

A debtor is either an organization or a natural person, never both, and the two sides are populated very differently: **569,318** rows carry a debtor business name against **273,859** with a debtor surname, while the secured-party side is overwhelmingly organizational (**843,927** business names against **8,296** surnames). Every record keeps both key sets (empty-filled), so the output shape never shifts, and a name search matches either form rather than assuming one.

This is a **historical archive**, not a rolling window - acceptance dates run from **1888** to today. A date filter is honoured exactly as given, with no floor silently applied.

One column needs reading carefully. **112,182 records (13.2%) carry `9999-12-31` in the lapse date** - the publisher's way of writing "no lapse date of record", not a filing that outlives its collateral by eight millennia. Those are cleared on output and excluded from every lapse filter, so a "liens expiring before 2030" query returns liens that really do expire, not a wall of perpetual filings. The lapse column holds genuine dates out to **2056**, and a further two rows carry a plainly bogus `2201` that is cleared the same way, so no lapse filter ever returns a date past the sentinel. **90,837** filings carry a lapse date inside the next twelve months.

### Typical questions

- "Every UCC filing naming **a given Connecticut business**."
- "Everything a given **lender** has a secured claim on in Connecticut."
- "The debtors on **one financing statement**."
- "**IRS** or **municipal** liens filed against a business."
- "Filings **accepting to lapse** in a window - the liens about to expire."
- "Aggregate the index by **lien class**, **filing type** or **debtor state**."

### Inputs

| Input | What it does |
|---|---|
| `mode` | `rows` (default) / `aggregate` |
| `debtor` | debtor name substring - organization or any person name part |
| `securedParty` | secured-party name substring - organization or any person name part |
| `debtorName` | organization-name column only |
| `filingNo` / `subsequentNo` | exact filing numbers |
| `filingType` / `lienType` / `lienStatus` | original/amendment/release; OFS/IRS/municipal; active/released/terminated |
| `city` / `state` | debtor location |
| `acceptedFrom` / `acceptedTo` | acceptance-date window |
| `lapseFrom` / `lapseTo` | lapse-date window |
| `groupBy` | aggregate over lien class / filing type / status / debtor state / secured-party state |
| `maxResults` | cap records (default 50) |

**Default run = the 50 most recent debtor 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 index, and each record is metered individually - a full named-debtor pull costs a fraction of a cent.

# Actor input Schema

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

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

## `debtor` (type: `string`):

Debtor name substring - matches the organization name or any natural-person name part. Blank = any.

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

The lender / lessor / tax authority holding the claim - matches the organization name or any natural-person name part. Blank = any.

## `debtorName` (type: `string`):

Organization name only (the business-name column), when you want to exclude natural-person debtors. Blank = any.

## `filingNo` (type: `string`):

Exact original filing number (the source's 10-digit zero-padded form, e.g. '0005229652'). One filing can name several debtors, so a filing number can return more than one row.

## `subsequentNo` (type: `string`):

Exact subsequent filing number - equals the original number on un-amended filings. Blank = any.

## `filingType` (type: `string`):

The filing's type. ORIG FIN STMT (519k) and AMENDMENT (307k) dominate. Blank = any.

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

The lien class. OFS (503k, ordinary file statements) and MUNICIPAL (220k) dominate; IRS (81k) and LABOR (21k) are the targeted classes. Blank = any.

## `lienStatus` (type: `string`):

Active (844k) / Released (2,361) / Terminated (177). Blank = any.

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

Debtor city substring. Blank = any.

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

Two-letter debtor state, e.g. 'CT' (791k), 'NY' (14k), 'MA' (5.2k). Blank = any.

## `acceptedFrom` (type: `string`):

Earliest acceptance (filing) date, YYYY-MM-DD. Blank = any. The index reaches back to the 19th century.

## `acceptedTo` (type: `string`):

Latest acceptance 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.

## `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",
  "debtor": "",
  "securedParty": "",
  "debtorName": "",
  "filingNo": "",
  "subsequentNo": "",
  "filingType": "",
  "lienType": "",
  "lienStatus": "",
  "city": "",
  "state": "",
  "acceptedFrom": "",
  "acceptedTo": "",
  "lapseFrom": "",
  "lapseTo": "",
  "groupBy": "lienType",
  "maxResults": 50
}
```

# Actor output Schema

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

Connecticut UCC debtor 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/ct-ucc-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 = {}

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

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,j0401/ct-ucc-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/k927cFERcbSIn5avf/builds/B1IcWSEOWubFEHwJk/openapi.json