Secretary of State Business Search + UCC Liens

Verify a US company and see the liens against it in one call. Search official state business registries by company name for the normalized entity record — legal name, ID, type, status, formation date, registered agent, officers — and get each entity joined to its UCC / lien filings where covered. Built for KYB, lending, and diligence agents that need to answer "is this company real, in good standing, and does it already have liens against its assets?" without stitching two systems together.

What this does

• Business entity search by company name across 44 US states in one call — the lookup you'd otherwise run on each state's Secretary of State business search, returned as a single normalized record per matched entity (company-registration lookup / business-entity verification).
• Entity → UCC lien join. Where lien-join coverage is available, each resolved entity is joined to the Uniform Commercial Code (secured-transaction) filings recorded against it as debtor — filing number, type, status, filed/lapse dates, secured party (lender), and collateral. This is the differentiator: entity search and lien search, connected, keyed by the debtor's legal name.
• Normalized fields per entity: legal name, state entity/registration ID, entity type, registration status (e.g. Good Standing, Active, Forfeited, Dissolved), formation/registration date, jurisdiction of formation, registered agent, principal / mailing address, and officers where the state publishes them.
• Registered agent lookup and company officers search, included. Every completed record carries the registered agent's name (and address where the state publishes it) plus the officer / director roster where published — a registered agent search or corporate officers lookup by company name is the same single call, with no separate enrichment charge.
• Multi-state in one request — pass a company name, optionally scope to a list of states, and get one record per matched entity across every covered state.
• KYB / diligence use cases: confirm a counterparty is registered and in good standing, check whether a borrower's assets are already encumbered before lending, enrich a CRM/onboarding record with the legal entity + lien picture, screen an acquisition target, or resolve which state(s) a company is registered in.
• Deterministic and agent-callable. Every result carries a machine-readable status (completed / no_match / not_covered / failed), an explicit lien_coverage outcome, and structured field_notes explaining any field that is structurally absent, so an agent can reason about coverage instead of guessing.

Entity search covers 44 states; lien joins cover 28.

State	Entity search	UCC lien join
Alaska (AK)	clean	clean
Alabama (AL)	clean	clean
Arkansas (AR)	clean	clean
California (CA)	extended	extended
Colorado (CO)	clean	clean
Connecticut (CT)	clean	clean
District of Columbia (DC)	clean	none
Delaware (DE)	extended	none
Florida (FL)	clean	clean
Georgia (GA)	extended	none
Hawaii (HI)	clean	none
Iowa (IA)	clean	extended
Idaho (ID)	clean	clean
Kentucky (KY)	clean	clean
Louisiana (LA)	extended	none
Massachusetts (MA)	extended	none
Maryland (MD)	extended	extended
Maine (ME)	clean	none
Michigan (MI)	extended	extended
Minnesota (MN)	clean	none
Missouri (MO)	extended	none
Mississippi (MS)	clean	clean
Montana (MT)	extended	extended
North Carolina (NC)	extended	extended
North Dakota (ND)	clean	none
New Hampshire (NH)	on request	none
New Jersey (NJ)	clean	extended
New Mexico (NM)	clean	clean
Nevada (NV)	extended	none
New York (NY)	clean	extended
Ohio (OH)	extended	extended
Oklahoma (OK)	extended	clean
Oregon (OR)	clean	extended
Pennsylvania (PA)	clean	extended
Rhode Island (RI)	clean	clean
South Carolina (SC)	clean	clean
Tennessee (TN)	extended	extended
Texas (TX)	clean	none
Utah (UT)	extended	none
Virginia (VA)	extended	extended
Vermont (VT)	clean	none
Washington (WA)	extended	extended
Wisconsin (WI)	clean	clean
West Virginia (WV)	clean	none

Don't see your target? Run the lookup anyway — lookups outside coverage are never charged, return an explicit not-covered result, and tell us where to expand next.

Why the entity → lien join matters

Anyone can look up whether a company is registered. The expensive, manual part of KYB and lending diligence is the second question — are there already liens against the company's assets? Answering it normally means finding the entity in one system, then searching a separate UCC/secured-transactions registry by hand, matching names, and hoping you found the same legal entity.

This Actor does both and connects them. It resolves the entity from the state business register, then searches that state's UCC filings by the entity's core legal name and attaches only the filings whose debtor name actually matches — precise, so a lien against a similarly-named company never gets misattributed. One call returns the entity plus its lien exposure, ready for a risk decision.

How it compares to standalone registry tools

	This Actor	Standalone entity-search tools	Single-state UCC scrapers
Entity search by name	Yes, multi-state	Usually yes	No
Normalized schema across states	Yes	Varies	N/A
UCC / lien filings	Joined to each entity	No	Yes, but not linked to an entity
One call for entity + liens	Yes	No	No
Machine-readable status + coverage notes	Yes	Rarely	Rarely

The design bet: multi-jurisdiction assembly behind one schema, plus the entity-to-lien join, is worth more to a diligence workflow than any single registry scraped in isolation.

Input

Field	Type	Required	Default	Description
companyName	string	one of these	—	The company name to search, e.g. Tesla or Acme Holdings LLC.
companyNames	array of strings	one of these	[]	Up to 20 company names to verify in one run; names are deduplicated case-insensitively before processing.
states	array of strings	no	all covered	Two-letter US state codes to scope the entity search. Lien joins cover a subset; the run's COVERAGE key-value record is authoritative.
includeLiens	boolean	no	true	Join UCC / lien filings where available. A state we cover for entity search but don't join liens for still returns the full entity record (with liens_checked=false, lien_coverage="no_lien_source", and a note) — you still get the entity. Set false to skip the lien join entirely.
matchMode	string	no	contains	contains (broad — find all entities sharing a name), exact (legal name equals the query), or starts (name begins with the query). In exact, punctuation and spacing are ignored, but the legal-form suffix must match — LLC, Inc and Corp are different entities.
maxRecordsPerCompany	integer	no	25	Cap on entity records returned (and billed) per company name, across states. Bounds broad-name searches.

Provide companyName and/or companyNames — at least one is required.

Output

One dataset record per matched entity. Example (completed, with a lien join):

{
  "query": "Tesla Electric Company",
  "input_index": 0,
  "status": "completed",
  "state": "CO",
  "legal_name": "Tesla Electric Company LLC",
  "entity_id": "20141524018",
  "entity_type": "DLLC",
  "entity_status": "Good Standing",
  "formation_date": "2014-08-27",
  "jurisdiction": "CO",
  "registered_agent_name": "Felix Keil",
  "principal_address": "9750 Hilldale Dr, Morrison, CO, 80465",
  "officers": [],
  "liens_checked": true,
  "lien_coverage": "joined",
  "ucc_filings": [
    {
      "filing_number": "20192017103",
      "filing_type": "UCC financing statement",
      "status": "active",
      "filed_date": "2019-03-01",
      "lapse_date": "2024-03-01",
      "secured_party": "US BANK NA",
      "collateral": "All equipment now owned or hereafter acquired",
      "debtor_name": "TESLA ELECTRIC COMPANY LLC"
    }
  ],
  "ucc_summary": { "total": 6, "active": 6, "filings_truncated": false },
  "results_truncated": false,
  "source": "Colorado Secretary of State (Business Entities)",
  "source_url": "https://www.coloradosos.gov/biz/BusinessEntityCriteriaExt.do",
  "fetched_at": "2026-07-09T14:03:11Z",
  "field_notes": []
}

Key fields: status (resolution outcome), error_class (machine-routable failure class on non-completed rows — see the failure taxonomy below), entity_status (registration standing, verbatim from the state), liens_checked (whether a covered lien source was queried), lien_coverage (joined, no_lien_source, unavailable, or not_requested), ucc_filings (the join), ucc_summary ({total, active, filings_truncated}), results_truncated (whether the entity cap dropped matches), and field_notes (why any field is structurally absent). Entity coverage is broader than lien-join coverage: an uncovered-for-liens state still returns the entity with liens_checked=false and a coverage note. A run also writes a COVERAGE key-value record listing the authoritative live entity-search and lien-join state sets.

Batch API Quickstart

The synchronous endpoint returns dataset items directly. These examples submit the same three-company batch and branch on both the entity outcome and the independent lien outcome.

curl -X POST "https://api.apify.com/v2/acts/shelvick~business-entity-lien-search/run-sync-get-dataset-items?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"companyNames":["Acme Holdings LLC","Northstar Freight LLC","Riverbend Manufacturing LLC"],"states":["CO","CT"],"includeLiens":true}'

import requests

items = requests.post(
    "https://api.apify.com/v2/acts/shelvick~business-entity-lien-search/run-sync-get-dataset-items",
    params={"token": APIFY_TOKEN},
    json={
        "companyNames": ["Acme Holdings LLC", "Northstar Freight LLC", "Riverbend Manufacturing LLC"],
        "states": ["CO", "CT"],
        "includeLiens": True,
    },
    timeout=900,
).json()
for row in items:
    if row["status"] != "completed":
        print(row["query"], row["status"])
    elif row["lien_coverage"] == "joined":
        print(row["query"], row["ucc_summary"])
    else:
        print(row["query"], "entity delivered; lien outcome:", row["lien_coverage"])

const url = new URL("https://api.apify.com/v2/acts/shelvick~business-entity-lien-search/run-sync-get-dataset-items");
url.searchParams.set("token", process.env.APIFY_TOKEN);
const items = await fetch(url, {
  method: "POST",
  headers: { "content-type": "application/json" },
  body: JSON.stringify({
    companyNames: ["Acme Holdings LLC", "Northstar Freight LLC", "Riverbend Manufacturing LLC"],
    states: ["CO", "CT"],
    includeLiens: true,
  }),
}).then((response) => response.json());
for (const row of items) {
  if (row.status !== "completed") console.log(row.query, row.status);
  else if (row.lien_coverage === "joined") console.log(row.query, row.ucc_summary);
  else console.log(row.query, "entity delivered; lien outcome:", row.lien_coverage);
}

Result and correlation contract

Names from companyName and companyNames are trimmed, deduplicated case-insensitively, and processed in first-seen order. input_index is the zero-based position in that accepted order. One name may produce several entity rows, so group records by query or input_index; results_truncated=true means maxRecordsPerCompany excluded additional entity matches.

Retries are at-least-once. Consumers should deduplicate completed records by query + state + entity_id, and terminal misses by query + state + status.

Entity and lien coverage

Entity-search coverage and lien-join coverage are separate capabilities. A completed entity remains useful when its lien outcome is no_lien_source, unavailable, or not_requested; inspect lien_coverage on every completed row rather than inferring coverage from the entity state. The run's COVERAGE artifact is authoritative.

Records come straight from official state registry and UCC systems, as-is. Registries can lag recent filings and occasionally contain clerk-side errors — for anything with legal weight, verify against the official record at the source.

Clean lien joins cover AK, AL, AR, CO, CT, FL, ID, KY, MS, NM, OK, RI, SC, and WI. Oklahoma's entity search is extended, so its clean-tier join is delivered when Oklahoma is named. Extended joins cover CA, IA, MD, MI, MT, NC, NJ, NY, OH, OR, PA, TN, VA, and WA only when the state is explicitly requested with liens enabled. Extended entity searches cover CA, DE, GA, LA, MA, MD, MI, MO, MT, NC, NV, OH, OK, TN, UT, VA, and WA only when explicitly requested; GA, MO, LA, NV, MA, UT and DE currently have entity coverage but no lien join. NH is searched only when named as well, but it bills the standard per-record rate: it needs a browser, not a metered connection, and you are not charged for a cost the lookup does not incur.

Calling from an AI agent

Agents are the primary customer. Three ways to call it:

• Apify MCP server (mcp.apify.com): expose shelvick/business-entity-lien-search as a tool; the input schema and per-field descriptions are advertised to the model.

• Apify Python SDK:

  from apify_client import ApifyClient
  
  client = ApifyClient("<APIFY_TOKEN>")
  run = client.actor("shelvick/business-entity-lien-search").call(
      run_input={"companyName": "Acme Holdings", "states": ["CO", "CT"], "includeLiens": True}
  )
  for record in client.dataset(run["defaultDatasetId"]).iterate_items():
      print(record["legal_name"], record["entity_status"], record["ucc_summary"])
  

• REST: POST /v2/acts/shelvick~business-entity-lien-search/run-sync-get-dataset-items for a synchronous call, or the async /runs endpoint plus polling for large batches.

Agent decision guide

• completed + joined + ucc_summary.total == 0: the covered source was searched and returned zero matching filings; check filings_truncated before treating the count as exhaustive.
• no_lien_source: the entity was delivered, but this state has no integrated lien source.
• unavailable: the entity was delivered, but the lien search failed at request time; retry later.
• not_requested: the entity was delivered without a lien search because includeLiens=false.
• no_match: covered entity sources were searched but no entity matched; this says nothing about liens.
• failed: the stated search did not complete; never interpret it as no entity or no liens.

Never collapse these outcomes into a single "no liens" result.

Failure taxonomy: when to retry

Every non-completed record carries error_class, a stable machine-routable value. Branch on it rather than on the prose in error, which may be reworded at any time.

Retry the same request later, unchanged:

• source_error — the official registry could not be reached. Registries have scheduled maintenance and unplanned outages, sometimes lasting a day; this is the source being unavailable, not a problem with the query.
• source_walled — the registry refused an automated search. Usually temporary.
• budget_exhausted — the run deadline arrived before this company finished.

Do not retry unchanged; the answer will not differ:

• no_match — the registry answered and no entity matched the name.
• not_covered — the requested state is not yet supported.
• lien_join_error — the entity was found, but its lien filings could not be retrieved; the entity fields on other rows for this company are still good.
• internal_error — the search could not be completed.

error_class is null on completed records.

Pricing and billing outcomes

Billing occurs only when a completed entity record has first been delivered to the dataset. no_match, not_covered, and failed rows are never billed. A completed entity remains billable when a lien join was not requested, is not covered, or was temporarily unavailable; the entity result itself was still delivered.

Every attempted charge is clamped to the run budget. Completed rows that exceed the remaining budget can still be delivered uncharged, and OUTPUT.budget_clamped reports how many completed rows had that outcome. The Store Pricing tab is the authoritative source for current rates and discounts.

Batch size, latency, and partial runs

A run accepts at most 20 unique company names and processes up to four companies concurrently. Clean-path lookups generally finish in seconds to under a minute; explicit extended coverage may need a longer startup and can take several minutes. Split larger batches across runs.

Completed records are pushed and charged as each company finishes. If the internal run deadline arrives, completed work remains available, each unfinished company gets an uncharged failed row with error="run_deadline_exceeded", and OUTPUT.partial=true with OUTPUT.pending_companies showing the count.

Schedules and retries

For recurring batch execution, use scheduled asynchronous runs and consume each run's dataset after completion. Retry whole or partial inputs using the correlation keys above. Searches are point-in-time lookups, not monitoring or change alerts.

High-volume needs

Running a large KYB pipeline or planning sustained batch volume? Open a conversation on the Actor's Issues tab with your target states and workload shape. Volume feedback directly drives state-coverage priorities.

Behavior

• Statuses: completed (entity found + normalized), no_match (covered states searched, nothing matched — a clear "not found"), not_covered (a requested state isn't supported yet), failed (a covered state's registry could not be reached; see error). Only completed is billed.
• Graceful degradation: if one state's registry is briefly unavailable, that state yields a failed record while the rest of the run completes — a source hiccup never fails the whole batch or charges you for it.
• Source freshness: lien data is only as current as each state's published index. Florida lien data is indexed from the state's official public UCC data files on a periodic refresh cycle, so a very recently filed Florida lien may not appear until the next refresh; those files publish filing images rather than collateral text. Kentucky's UCC index in particular publishes on roughly a two-week lag, so a very recently filed Kentucky lien may not appear yet. Iowa's and Rhode Island's lien searches cover active filings plus those lapsed within roughly the past year — older lapsed history is not published, so lien totals there describe the current picture rather than all history. Rhode Island publishes no per-filing lapse date; each filing's status is derived from the state's own active/lapsed indexes and its filing history instead.
• South Carolina liens: the free UCC grid publishes filing number, type, filed date and lapse date only; status, secured_party and collateral are not exposed and arrive as null.
• Current-only sources: a few states publish only their currently registered entities — dissolved and withdrawn ones are absent from the source. For those, a no_match means no currently registered entity matched the name, not that it never existed; the record carries a field_notes entry saying so. Iowa reports every returned entity as active (its bulk file has no status column); Alaska keeps each entity's real standing (e.g. Good Standing, Non-Compliant) but still omits dissolved entities. Florida is the opposite: its register includes inactive and dissolved entities with their real status, so an FL record can come back Inactive — useful when you need to know a counterparty was dissolved rather than never registered. Mississippi also includes the full register and preserves state standing values such as Good and Dissolved, but its source does not publish registered-agent or officer data. Rhode Island Department of State — Corporate Database and West Virginia Secretary of State — Business Organization Search also cover the full register, including inactive and dissolved entities. Rhode Island searches match an entity's current legal name, so find a renamed company under its current name or check the state portal at https://business.sos.ri.gov/CorpWeb/CorpSearch/CorpSearch.aspx .
• Rhode Island status: entity_status can be null when the Rhode Island Department of State — Corporate Database does not return a current standing for the entity; the record carries a field_notes entry saying so, and you can verify the entity directly at https://business.sos.ri.gov/CorpWeb/CorpSearch/CorpSearch.aspx .
• Telemetry: to improve coverage and reliability, this Actor reports anonymous usage metrics and diagnostic events to the developer — run outcome counts, the states queried, and, only when something goes wrong, the relevant input fields. No account identifiers are collected, and telemetry never affects a run.

FAQ

• Which states are covered? Entity search covers 44 states: AK, AL, AR, CO, CT, DC, FL, HI, IA, ID, KY, ME, MN, MS, ND, NJ, NM, NY, OR, PA, RI, SC, TX, VT, WI, and WV by default, plus CA, DE, GA, LA, MA, MD, MI, MO, MT, NC, NH, NV, OH, OK, TN, UT, VA, and WA when named in states. Clean lien joins cover AK, AL, AR, CO, CT, FL, ID, KY, MS, NM, OK, RI, SC, and WI; Oklahoma's entity search is extended, so its join is delivered when named. Extended joins cover CA, IA, MD, MI, MT, NC, NJ, NY, OH, OR, PA, TN, VA, and WA only when explicitly requested. Entities from other covered states return without a lien join, clearly flagged with lien_coverage="no_lien_source". The run's COVERAGE record is the authoritative live list as coverage expands.
• Why are CA, DE, GA, LA, MA, MD, MI, MO, MT, NC, NV, OH, OK, TN, UT, VA, and WA only searched when I name them? They are extended-coverage states billed at the extended per-record rate (see the Pricing tab). Keeping them out of the search-everywhere default means you are never charged the extended rate for a state you didn't ask about — naming them in states is the opt-in.
• Why didn't my Massachusetts search find a company I know is registered? Massachusetts matches from the start of the name, so a search for a word in the middle of a company's name will not find it — search the beginning of the legal name instead. Records and empty results from MA both say so.
• Can I use this for a registered agent lookup? Yes — every completed record carries registered_agent_name (and the agent's address where the state publishes it), so a registered agent lookup by company name is a single call.
• Can I look up a company's officers and directors? Where the state publishes them, yes — officers carries the roster (name and title) on the same record, so a corporate officers search costs nothing beyond the entity record. States that don't publish officers say so explicitly in field_notes.
• What if a company has no liens? For a lien-covered state, liens_checked is true, lien_coverage is joined, and ucc_summary.total is 0 with filings_truncated=false — a confident "no liens found," not a gap. If the state lacks a lien join, liens_checked is false, lien_coverage is no_lien_source, and the entity record includes a coverage note instead.
• How precise is the entity→lien match? Filings are attached only when the UCC debtor's core legal name matches the entity's, so a lien against a similarly-named company is not misattributed. Descriptive words (Company, Trust) are kept; only legal-form suffixes (LLC, Inc.) are normalized away for matching.
• Can I verify a list of companies at once? Yes — pass up to 20 names in companyNames; each is resolved independently.
• Is this official / real-time? Data comes from the official state registries — Secretary of State / corporations-division records and state open-data portals; it is as current as those sources publish.

What this doesn't do

• No paywalled or login-gated sources. It uses only free, public registry data; it does not cross any state's paid detail lookup.
• No consumer / personal-PII lookups. Business-entity public records only — not people search, not skip tracing.
• No document images or filed PDFs — structured fields, not scanned filings.
• Not every state yet. Uncovered states return not_covered; it is not a 50-state guarantee.
• Not a monitoring service — it answers a point-in-time query, it does not watch an entity for changes.

Use a dedicated people-search or identity-verification tool for individuals, a document-retrieval service for filed images/PDFs, and a court-records or enforcement tool for litigation history — this Actor is for the business-entity record and its UCC lien exposure.

Data is sourced from public government registries and open-data portals and is provided for lawful business, compliance, and diligence use; verify against the official source of record before relying on it for a regulatory decision, and use it in accordance with the Apify Terms of Service and applicable law.

Related Actors

Actor	Use it when
Enforcement Record Profiler	you've verified the entity and want its enforcement and violation history from official US sources
County Property Records API	the entity owns US real estate and you need owner, assessed value, and tax records
Property Deed & Lien Records Search	you need what the entity recorded at county recorder offices — deeds, mortgages, and real-estate liens by company name