Business Entity List Export: LLCs & Corporations by State

Design notes for filtered bulk exports of state business registries: every active LLC in a state, new LLC filings by formation date, or the companies registered in a city or ZIP code, in one row shape for every state.

Design notes for Business Entity List Export (bulk-business-entity-list), an Apify Actor that exports filtered lists of LLCs, corporations, nonprofits and partnerships from official state business registries. You name the states and the filters; it counts the matches, then delivers one flat row per company, from a handful of rows up to a million per run. It is built for the people and AI agents who need a list of companies rather than a lookup of one company: lead lists of new filings, market maps of a city or ZIP code, and state-wide company databases.

What this is

The question this Actor answers is which companies does the state registry list that match these filters? For example: every active LLC in Florida formed since January, every corporation and LLC with a principal office in ZIP 80202, or every nonprofit in Illinois. The usual ways of getting that list are a public-records request, a bulk file whose layout and status codes differ from state to state, a search page that returns 25 results at a time, or a lead database that only knows the businesses that advertise online.

The filters are state, status (active or inactive), entity type (LLC, corporation, nonprofit, partnership, other), a formation-date range, city, ZIP, county, words in the company name (nameKeyword, whole words, all must match) and home state (homeState, the state of formation, e.g. DE for Delaware companies registered elsewhere). County is the one the state publishes where it has one (New York, Pennsylvania, Texas, Mississippi), otherwise the county of the principal-office ZIP code; Connecticut’s ZIP-based counties are its planning regions, so a historic county name such as Hartford finds nothing there. Iowa, Pennsylvania and Texas publish no home state, so homeState returns a free notice for them. Rows carry county, county_source and home_state. Every run counts first: the status message says how many companies match in each state before any row is delivered, and the run summary repeats the count beside what was delivered and charged.

Each delivered row is one company as the registry records it: legal name, the state’s own entity or file number, entity type, status, formation date, home jurisdiction for foreign entities, principal, mailing and registered-agent addresses (one-line and split into line 1, line 2, city, state and ZIP), registered agent name, and officers where the state publishes them. Every key is present on every row, null when the state doesn’t publish that field, so a CSV or Excel export keeps the same columns whichever states you combine. Every row also carries a source credit, the licence where the state’s data has one, and the date of the registry copy it was read from.

Rows come newest-formed first by default (order: "newest"), or oldest first with order: "oldest", as one order across the whole state. Companies with no formation date on file come last in either order. This applies to batch exports and over HTTP.

registeredAgent finds every company whose registered agent has that name and combines with every other filter. Matching ignores case, punctuation and trailing legal-form words (LLC, INC, CORP, CO, COMPANY and similar): “Northwest Registered Agent” also finds “NORTHWEST REGISTERED AGENT, LLC”. A longer name is a different agent: “Registered Agents Inc” does not match “National Registered Agents Inc”. This is a name match, not proof that two filings name the same firm. Not available for MS, PA or TX: their registers as held here carry no agent names, so each gets a free notice row and is skipped, with nothing charged. In NY it matches the registered agent or the name designated to receive service of process. There is no officer or person-name filter.

Coverage

Fourteen registries are covered. What each one publishes differs, and the Actor says so instead of filling gaps:

State Source Status Officers Registered agent
AK Alaska Division of Corporations, Business and Professional Licensing active only yes yes
CO Colorado Secretary of State active and inactive no yes
CT Connecticut Secretary of the State active and inactive yes, business addresses only yes
DC DC Department of Licensing and Consumer Protection active and inactive no yes
FL Florida Department of State, Division of Corporations active and inactive yes yes
IA Iowa Secretary of State active only no yes
IL Illinois Secretary of State active and inactive yes yes
MS Mississippi Secretary of State active and inactive no no
NY New York Department of State active only chief executive where filed yes
OR Oregon Secretary of State active only authorized representatives yes
PA Pennsylvania Department of State active only yes no
RI Rhode Island Department of State not published no yes
TX Texas Comptroller of Public Accounts active franchise taxpayers, with a Secretary of State status code no no
VA Virginia State Corporation Commission active and inactive yes yes

Texas is the one that needs a sentence of its own. Its rows come from the Comptroller’s list of businesses set up for franchise tax, so they are active taxpayers with the taxpayer’s mailing address and a Secretary of State status code, but no officers and no registered agent. Alaska, Iowa, New York, Oregon and Pennsylvania publish active entities only, so an inactive-only filter returns nothing there. Rhode Island publishes no status at all; its rows read status_class: "unknown", so a Rhode Island export should use entityStatus: "any". Any state outside the table gets one free notice row naming the covered states.

Optional UCC lien overlay

Set includeUcc: true to add a UCC lien summary in Florida (FL), Connecticut (CT) and Colorado (CO). It adds ucc_active_filings (0 means checked, none active), ucc_latest_filing_date, ucc_latest_secured_party (the first secured party or lender on the newest filing), ucc_next_lapse_date and ucc_as_of. The Liens dataset view groups these columns together. Set hasActiveLien: true to keep only companies with at least one active filing; this also includes the summary.

The summary uses each state’s public UCC filing data, refreshed periodically; ucc_as_of gives the data date. Matching uses the company’s exact registered name and organization debtors only. Former names and DBAs are not consulted, so filings under another name will not match. A zero active count is not a search across every name the company has used.

Both options default to false. Lien fields are null when not requested or when the state has no lien data. Other covered states get a free lien_not_covered notice: includeUcc still exports their company rows without lien data, while hasActiveLien skips those states. If covered lien data cannot be read, a free records_unavailable notice points to a rerun or a run without the lien flags.

Lien-data credits: Florida Secured Transaction Registry data via the Florida Department of State; Connecticut Secretary of the State UCC lien filings; Colorado Secretary of State UCC filings (public domain).

Why I built it this way

Registry rows, not web leads

Most business-list tools start from maps, directories or websites, which means they list the businesses that advertise. A large share of registered companies never do: holding companies, property LLCs, contractors without a site, and almost every company in the first weeks after it files. The registry is the only list that includes them, and it is the only one with a formation date and a legal status. That is the whole reason to go to the registry, so the Actor keeps the registry fields as published, with an optional public UCC lien summary alongside them. There are no scraped emails or phone numbers and no guessed websites. Registry fields are exactly what the state published, reformatted into common columns.

One row shape, two kinds of status

Every state has its own vocabulary. Colorado says “Good Standing”, Virginia says “Active”, Florida uses its own codes, and entity types range from “DLLC” to “Domestic Limited Liability Company”. Throwing that wording away loses information, and keeping only it makes cross-state filters impossible. So each row carries both: status and entity_type exactly as filed, and status_class (active / inactive / unknown) and entity_type_class (llc / corp / nonprofit / lp / other) as normalized classes. The filters work on the classes, so entityStatus: "active" means the same thing in Colorado as in Virginia, while anyone who needs the state’s precise wording still has it.

“Unknown” is a real class, not a fallback for errors. Some standings are qualified or unclear, and Rhode Island publishes none. Those rows are included under entityStatus: "any" and excluded from “active” and “inactive”, because forcing them into either would make a filtered list claim something the state never said.

Count before rows

A bulk export that turns out to be ten times larger than expected is the main way such a job goes wrong. Each run therefore counts the matches in every requested state first and reports the number in the status message before the first row arrives. An agent or a person can see that “every active LLC in Florida” is a very large list and narrow the filters or split the work, instead of discovering it from the bill.

For a count preview, use countOnly: true (default false). Each state gets one free notice row with error_class: "count_only" and matched_count; the OUTPUT summary carries the counts. Nothing is exported and no rows are charged. The only cost of the run is the platform’s small start charge. Run again with countOnly: false and maxResults at least the count to export the matches.

Every stop is explained by one row

A large export can stop for three reasons before it is complete: the row limit (maxResults), the caller’s Max cost per run, or the run’s time limit. Each ends the same way: one free notice row with an error_class (max_results, budget_exhausted or deadline) and a withheld_count saying how many matching companies were not delivered.

I considered one notice row per company that wasn’t delivered, which is how some of my other Actors report a cost cap. Here a unit is a single company, so a capped million-row export would bury the data under up to a million notice rows that say nothing a single row with a count doesn’t. One summary row per stop is the honest and usable version.

The same idea applies to states. A state that isn’t covered, a state with no matches (no_match), and a state whose data couldn’t be read in this run (records_unavailable) are three different answers, each with its own free row, so an agent can decide whether to widen the filters, try another state, or run that state again. The message never tells a caller to come back later as a substitute for an answer.

Split by formation date, not by resume token

Exports that are too big for one run need a way to be split. A resume cursor would work, but registry copies are rebuilt as states publish new data, and a cursor into an old copy is a source of silent gaps and duplicates. Formation-date ranges don’t have that problem: formedFrom/formedTo ranges that don’t overlap never deliver the same company twice, each slice is counted before it runs, and each slice can be re-run on its own. A whole state becomes one run per decade or per year.

Within a run, the Actor delivers each company at most once. If the registry copy is replaced while an export is in progress, the export restarts that state from the beginning and skips every company it already delivered, so nothing is delivered or charged twice.

states is required, and empty is not “all”

It is tempting to treat an empty state list as “every state”. With one shared maxResults and states exported in order, that would silently return only the first state’s rows and look like a complete answer. A run with no state gets a free correction row instead. Unknown codes (a typo, a territory) get their own free malformed_input row, and the correct codes in the same run still export.

Credit travels with the data

Some registries license their data (DC and Iowa under CC BY 4.0, which requires attribution); others ask for a credit line. Rather than a footnote somewhere in the documentation, every row carries source, source_license and source_register, so the attribution survives a CSV export, a database load or a merge with other lists.

Counties derived from ZIP codes use GeoNames postal-code data, licensed under CC BY 4.0.

Delivered, then charged

Rows are delivered in pages, and each page is charged only after it is in the caller’s dataset. A run that stops, for whatever reason, keeps everything it delivered, and nothing undelivered is ever billed. Notice rows, duplicates and uncovered states are never charged.

How to use it

A typical outreach job: every active LLC formed in Virginia since the start of a quarter, for a new-business mailing.

{
  "states": ["VA"],
  "entityStatus": "active",
  "entityTypes": ["llc"],
  "formedFrom": "2026-07-01",
  "maxResults": 10000
}

For lien data, add includeUcc: true to a FL, CT or CO request, or hasActiveLien: true to export only companies with active filings and their summaries. Both are optional booleans defaulting to false. Over HTTP, POST /list_entities accepts these same two fields per request. It also accepts registeredAgent, order (default newest) and countOnly. A cursor belongs to the order it was started with; changing order means starting again without the cursor. countOnly: true is a free request returning the count notice row, no companies and no cursor.

From Python with the Apify client:

from apify_client import ApifyClient

client = ApifyClient("<APIFY_TOKEN>")
run = client.actor("shelvick/bulk-business-entity-list").call(
    run_input={"states": ["VA"], "entityStatus": "active", "entityTypes": ["llc"],
               "formedFrom": "2026-07-01", "maxResults": 10000}
)
for row in client.dataset(run["defaultDatasetId"]).iterate_items():
    if row["record_type"] == "entity":
        print(row["name"], row["formation_date"], row["principal_city"])
    else:
        print("notice:", row["error_class"], row["message"], row.get("withheld_count"))

Or over REST:

curl -X POST "https://api.apify.com/v2/acts/shelvick~bulk-business-entity-list/runs?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"states":["VA"],"entityStatus":"active","entityTypes":["llc"],"formedFrom":"2026-07-01","maxResults":10000}'

A company row looks like this:

{
  "record_type": "entity",
  "state": "CO",
  "entity_id": "20241234567",
  "name": "Mile High Widgets LLC",
  "entity_type": "DLLC",
  "entity_type_class": "llc",
  "status": "Good Standing",
  "status_class": "active",
  "formation_date": "2024-03-05",
  "state_of_formation": "CO",
  "principal_address": "1600 Blake St, Ste 200, Denver, CO 80202",
  "mailing_address": "1600 Blake St, Ste 200, Denver, CO 80202",
  "registered_agent_name": "Example Agent Services LLC",
  "registered_agent_address": "1600 Blake St, Ste 200, Denver, CO 80202",
  "officers": [],
  "officers_truncated": false,
  "source": "Colorado Secretary of State, Business Entities (public domain)",
  "source_license": null,
  "source_register": "Colorado Secretary of State (Business Entities)",
  "source_as_of": "2026-10-20",
  "status_as_of": null
}

The split address columns (principal_city, principal_zip, registered_agent_state and so on) are omitted above for length; they are present on every row. Notice rows have record_type: "notice", an error_class, a plain-language message and, where it applies, matched_count and withheld_count. The run summary in the key-value store record OUTPUT lists matched, delivered and charged counts per state and why the run stopped.

Other filter shapes follow the same pattern. A market map of one ZIP code is {"states": ["CO"], "entityStatus": "active", "entityTypes": ["llc", "corp"], "zip": "80202"}. A state-wide company database is one run per formation-date range, each with formedFrom and formedTo.

If you’re calling from an MCP-enabled agent, add shelvick/bulk-business-entity-list as a tool on the Apify MCP server. The input schema advertises every field with an example, so a request such as “all active LLCs in Iowa formed this year” maps directly onto states, entityStatus, entityTypes and formedFrom. The agent should branch on record_type and error_class, never on the wording of message: no_match means widen the filters, records_unavailable means run that state again, and max_results, budget_exhausted and deadline mean more companies matched than were delivered.

How it compares to other ways of getting a business list

Approach Companies without a web presence Formation date and status Same columns across states Contact details (email/phone)
Map and directory lead scrapers no no yes often
B2B contact databases partly rarely yes yes
New-filing feeds new filings only yes varies sometimes
State bulk files and records requests yes yes no, one layout per state no
This Actor yes yes yes no (registries don’t publish them)

The trade-off is completeness against contact details. If you need emails and phone numbers more than you need every registered company, a contact database is the better tool. If the list has to be the official one, including the companies that never advertise and with a formation date and legal status on every row, the registry is the source, and this Actor is a way to get it without learning fourteen file formats. The two combine well: export the registry list, then enrich only the companies you care about. For one company at a time by name, in any state and with its UCC lien filings, use business-entity-lien-search instead.

Pricing model

Pay per company row delivered, with lower per-row rates for larger runs: within one run, rows beyond set volumes are billed at volume rates. A row is charged only after it is in your dataset. Notice rows, duplicate rows and uncovered states are never charged, and nothing is charged for a failed run. The run stops when your Max cost per run can’t pay for another row and adds one free row saying how many matching companies were not delivered, so a capped export never overruns your limit. Apify subscribers get their plan’s discount automatically.

The lien overlay is an opt-in add-on charged per delivered row with at least one active matched lien filing, on top of the company row price; rows whose matched filings have all lapsed or been terminated keep the lien fields without the charge, and rows without lien data and notice rows have no lien charge, both prices count toward the run cap, and the Store Pricing tab shows the add-on rate.

Current per-row rates for each volume band are on the Apify Store Pricing tab.

Open questions / future work

  • More states. Coverage follows what each state publishes in bulk and on what terms. States outside the table return a free notice row, and those requests are how I decide which state to add next, so asking for a state is worth doing even though the answer is a notice row.
  • A resume cursor for very large exports. Formation-date splits handle state-wide exports today. If real exports regularly hit the run’s time limit, a resume token tied to one registry copy may be worth its complexity.
  • Change lists. Many list jobs are really “what is new or newly dissolved since my last export”. Formation-date filters cover new filings; status changes since a date are a different question that status_as_of only partly answers.
  • Officer and agent completeness. Where a state publishes officers or registered agents only on per-company pages rather than in its bulk data, those columns stay empty. Filling them per company is what the single-company lookup is for; whether a bulk path is worth it depends on demand.