# Business Entity List Export: LLCs & Corporations by State (`shelvick/bulk-business-entity-list`) Actor

Bulk lists of registered companies from official state business registries: every active LLC in a state, new LLC filings by formation date, or corporations and nonprofits by city or ZIP. Status, formation date, addresses, registered agent and officers where published. Up to 1M rows per run.

- **URL**: https://apify.com/shelvick/bulk-business-entity-list.md
- **Developed by:** [Scott Helvick](https://apify.com/shelvick) (community)
- **Categories:** Business, Lead generation, Developer tools
- **Security:** Limited permissions
- **Stats:** 1 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.70 / 1,000 company row delivered (first 10,000 per run)s

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

A list of every active LLC in a state, or every company formed there since a given date, is usually
a records request, a bulk file in a different layout per state, or a lead database that only knows
businesses with a website. This Actor exports filtered lists straight from official state business
registries, in one flat row shape for every state, filtered by entity type, status, formation date,
city or ZIP, from a few rows up to a million per run.

### What this does

- **Filters:** state, status (active / inactive), entity type (LLC, corporation, nonprofit,
  partnership, other), formation date range, city, ZIP.
- **Count first:** each run counts how many companies match in each state, reports it in the status
  message and the run summary, then delivers up to `maxResults` rows.
- **Registry rows, not web leads:** each row is a company as the state registry records it,
  including businesses with no website, listing or online presence.
- **One row shape:** the same columns for every state (name, entity number, type, status, formation
  date, principal, mailing and registered-agent addresses, officers where published), ready for CSV,
  Excel or a database load.
- **Opt-in UCC lien summary:** `includeUcc` adds lien fields in Florida, Connecticut, Colorado and Vermont;
  `hasActiveLien` keeps only companies with at least one active filing and includes the summary.
- **A source credit on every row**, with the licence where the state's data carries one.

Typical uses:

- New LLC filings for outreach: every LLC formed in Virginia in the last 30 days (`formedFrom`).
- A market map: every active corporation and LLC in one ZIP or city.
- Building or refreshing a company database for a state, split into date ranges.
- Registered-agent and officer research across all active entities of one type.
- Matching your customer or vendor list against the registry to find dissolved or inactive companies.

### Why complete registry lists matter

Business lists built from web listings, maps or social profiles cover the businesses that advertise.
A large share of LLCs and corporations never do: holding companies, property LLCs, new filings,
contractors without a website. The state registry lists every entity the state publishes, with a
formation date in every state but New Hampshire and, in most states, a legal status (see Coverage for what each state publishes).

Getting that list yourself means a different download, layout and status vocabulary in every state,
and some states publish only a search page. This Actor maps every covered state onto the same
columns and the same filter classes: `status_class` (active / inactive / unknown) and
`entity_type_class` (llc / corp / nonprofit / lp / other) read the same in Colorado as in Virginia,
while the state's own wording stays in `status` and `entity_type`.

Large exports stay predictable: the count comes before the rows, every stop (row limit, cost limit,
time limit) ends with one free row that says how many matching companies were not delivered, and
date-range splits never overlap, so nothing is paid for twice.

### 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)** |

Use this Actor when the list should come from the official registry; use a contact database when you need
emails and phone numbers more than completeness.

### Coverage

| State | Source | Status | Officers | Registered agent |
|---|---|---|---|---|
| AK | Alaska Division of Corporations, Business and Professional Licensing | active only | yes | yes |
| CO | Colorado Secretary of State (public domain) | 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 (Sunbiz) | active and inactive | yes | yes |
| IA | Iowa Secretary of State (Iowa Data Hub) | active only | no | yes |
| IL | Illinois Secretary of State (corporations and LLCs) | active and inactive | yes | yes |
| MS | Mississippi Secretary of State | active and inactive | no | no |
| MT | Montana Secretary of State | active and inactive | no | no |
| NH | New Hampshire Department of State | active and inactive | no | name only |
| NY | New York Department of State (OPEN-NY) | 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: use `entityStatus: "any"` | no | yes |
| TX | Texas Comptroller of Public Accounts | active franchise taxpayers; Secretary of State status code per row | no | no |
| VA | Virginia State Corporation Commission | active and inactive | yes | yes |
| VT | Vermont Secretary of State | active and inactive | yes | yes |

Texas rows come from the Comptroller's list of businesses set up for franchise tax, so they carry
the taxpayer's mailing address but no officers or registered agent. For officers or agents of
specific companies in any state, see Related Actors below.

Any other state returns one free notice row naming the covered states, so you always know why a
state is missing.

### Input

| Field | Type | Required | Default | Description |
|---|---|---|---|---|
| `states` | array of strings | yes | -- | Two-letter codes, e.g. `["CO"]` or `["FL", "NY"]`. Exported one after another. |
| `entityStatus` | string | | `any` | `any`, `active` or `inactive`. `any` also includes entities whose standing is unclear. |
| `entityTypes` | array of strings | | all | Any of `llc`, `corp`, `nonprofit`, `lp`, `other`. |
| `formedFrom` | string | | -- | Formed or registered on or after this date, `YYYY-MM-DD`. |
| `formedTo` | string | | -- | Formed or registered on or before this date, `YYYY-MM-DD`. |
| `city` | string | | -- | Principal-office city (falls back to the mailing city), e.g. `Denver`. |
| `zip` | string | | -- | 5-digit principal-office ZIP (falls back to the mailing ZIP), e.g. `80202`. |
| `nameKeyword` | string | | -- | Words that must all appear in the company name (whole words, any order, up to 6), e.g. `plumbing`. A legal-form word alone (LLC, INC) or a word too common to filter on returns a free notice. |
| `county` | string | | -- | County name, case-insensitive, e.g. `Denver`. |
| `homeState` | string | | -- | Two-letter state of formation, e.g. `DE` for Delaware companies registered in the exported states. |
| `includeUcc` | boolean | | `false` | Add a UCC lien summary in FL, CT, CO and VT; other states export without lien data and get a free notice. |
| `hasActiveLien` | boolean | | `false` | Only companies with at least one active UCC filing; implies the summary. States without lien data are skipped with a free notice. |
| `order` | string | | `newest` | `newest` (newest-formed first) or `oldest`, across the whole state. Companies with no formation date come last in either order. |
| `registeredAgent` | string | | -- | Every company whose registered agent has this name; combines with every other filter. See matching rules below. |
| `countOnly` | boolean | | `false` | Free count preview: one notice row per state, no companies exported and no row charges. |
| `maxResults` | integer | | `1000` | Most company rows to deliver across all states, up to 1,000,000. |

A date filter excludes entities with no formation date on file. `maxResults` is shared across the
states in `states`.

`county` uses the county the state publishes where it has one (New York, Pennsylvania, Texas,
Mississippi); elsewhere it is the county of the principal-office ZIP code, when that ZIP is in the
exported state. Connecticut's ZIP-based counties are its planning regions (for example
"Connecticut Metropolitan"), not its historic counties, so `county: "Hartford"` finds nothing there.
Iowa, Montana, New Hampshire, Pennsylvania and Texas publish no home state, so `homeState` returns a free notice for them.

`registeredAgent` matches by name, ignoring 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, so "Registered Agents Inc"
does not match "National Registered Agents Inc". A name match is not proof that two filings name
the same firm. Not available for MS, MT, 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.

With `countOnly: true`, each state gets one free notice row with `error_class: "count_only"` and
`matched_count`, and 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.

### Output

One row per company (`record_type: "entity"`):

```json
{
  "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
}
```

| Field | Meaning |
|---|---|
| `name`, `entity_id` | Legal name and the state's own entity or file number. |
| `entity_type`, `entity_type_class` | Type as filed, and the normalized class the `entityTypes` filter uses. |
| `status`, `status_class` | Status as filed, and `active` / `inactive` / `unknown`. |
| `formation_date`, `state_of_formation` | Formation or registration date (may be a future date when the filer chose a delayed effective date; kept as filed); home jurisdiction for foreign entities. |
| `home_state` | Two-letter state of formation; null where the state publishes none (IA, MT, NH, PA, TX). |
| `county`, `county_source` | County, and where it came from: `source` (the state's register) or `zip` (the principal-office ZIP). |
| `principal_address`, `mailing_address`, `registered_agent_address` | One line each, plus separate line 1, line 2, city, state and ZIP columns (e.g. `principal_city`, `registered_agent_zip`). |
| `registered_agent_name` | As filed, where the state publishes it. |
| `officers` | `[{name, title, address}]` where the state publishes officers; `officers_truncated` marks a cut list. |
| `source`, `source_license`, `source_register` | Credit line, licence (where one applies) and the register file the row came from. |
| `source_as_of` | Date of the registry copy the row was read from. |
| `status_as_of` | Date of the filing that last set the status, where the state publishes it. |
| `ucc_active_filings` | Number of active UCC filings matched to the registered name; `0` means checked, none active. |
| `ucc_latest_filing_date` | Date of the newest matched UCC filing. |
| `ucc_latest_secured_party` | First secured party (lender) on the newest matched filing. |
| `ucc_next_lapse_date` | Next lapse date in the matched lien summary, where available. |
| `ucc_as_of` | Date of the public UCC data used for the summary. |

Every key is present on every row (null, or an empty `officers` list, when the state doesn't publish it), so CSV and Excel exports
keep stable columns.

Lien fields are null when not requested or the state has no lien data. The **Liens** dataset
view groups these columns together. A checked name with no active filings has
`ucc_active_filings: 0`; it may still have an older, inactive filing.

Free notice rows (`record_type: "notice"`) carry `error_class`, a plain-language `message` and,
where it applies, `matched_count` and `withheld_count`. The run summary (key-value store record
`OUTPUT`) lists matched, delivered and charged counts per state and why the run stopped.
It also includes `lien_rows` (delivered rows carrying matched lien data), `lien_charged` (rows
charged for the add-on), `include_ucc` (the `includeUcc` input) and `lien_not_covered` (states
requested without lien coverage).

### Example

Every active LLC formed in Colorado since 2024 with a downtown Denver ZIP, with a lien summary:

```json
{
  "states": ["CO"],
  "entityStatus": "active",
  "entityTypes": ["llc"],
  "formedFrom": "2024-01-01",
  "zip": "80202",
  "includeUcc": true,
  "maxResults": 5000
}
```

```bash
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":["CO"],"entityStatus":"active","entityTypes":["llc"],"formedFrom":"2024-01-01","zip":"80202","includeUcc":true,"maxResults":5000}'
```

To keep only companies with active liens, use `hasActiveLien: true` instead; it also includes
the lien summary.

Preview the count of active LLCs in Colorado without exporting companies:

```json
{
  "states": ["CO"],
  "entityStatus": "active",
  "entityTypes": ["llc"],
  "countOnly": true
}
```

Companies in Colorado with a given registered-agent name:

```json
{
  "states": ["CO"],
  "registeredAgent": "Northwest Registered Agent",
  "maxResults": 5000
}
```

### Calling from an AI agent

**Tell us what's missing.** If a run doesn't give you what you need, add a `feedback` note to your next run: what was missing or wrong, or which tool you're switching to and why. A run with only a note isn't charged for results, and the maintainers read every note.

- **Apify MCP server** (`mcp.apify.com`): add `shelvick/bulk-business-entity-list` as a tool. The
  input schema and per-field descriptions are advertised to the model; a user request such as "all
  active LLCs in Iowa formed this year" maps directly onto `states`, `entityStatus`, `entityTypes`
  and `formedFrom`.

- **Apify Python SDK:**

  ```python
  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-01-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"])
  ```

- **REST:** `POST /v2/acts/shelvick~bulk-business-entity-list/runs` and poll the run, then read the
  dataset. `run-sync-get-dataset-items` suits small lists that finish within the synchronous limit.

**Over HTTP:** `POST /list_entities` accepts `includeUcc` and `hasActiveLien` per request,
with the same defaults, lien coverage and add-on pricing rules as a batch run.
It also accepts `registeredAgent`, `order` (default `newest`) and `countOnly`. The formation-date
order applies across the whole state, with undated companies last in either order. A cursor belongs
to the order it was started with; to change order, start again without the cursor.
`countOnly: true` is a free request returning the count notice row, no companies and no cursor.

**Agent decision guide:** branch on `record_type` and `error_class`, not on `message` wording.
`no_match` means the state answered and nothing matched the filters (widen them; don't retry
unchanged). `records_unavailable` means that state's data could not be read in this run (run that
state again). `max_results`, `budget_exhausted` and `deadline` mean more companies match than were
delivered; `withheld_count` says how many.

### Pricing

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. 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 with its own per-row price, on top of the company row
price. It is billed only for delivered rows with at least one active matched lien filing. Rows
whose matched filings have all lapsed or been terminated still get the lien fields, without the
lien charge; rows without matched lien data and notice rows never receive it.
The cost limit includes both the company row and any lien add-on.

See the **Pricing** tab on this Store page for the per-row lien add-on price, rates per volume
band and subscriber discounts.

### Behavior

| `error_class` | Meaning | What to do |
|---|---|---|
| `lien_not_covered` | Lien data is available only in FL, CT, CO and VT | With `includeUcc`, other covered states export without lien data; with `hasActiveLien`, they are skipped. The notice is free |
| `not_covered` | The state isn't available for bulk lists | Use a covered state |
| `malformed_input` | An input value couldn't be used (e.g. an unknown state code) | Fix the named field; correct codes in the same run still export |
| `records_unavailable` | That state's data couldn't be read in this run | Run that state again |
| `count_only` | Count preview; `matched_count` gives the matches in that state, with no row charges | Run again with `countOnly: false` and `maxResults` at least the count to export |
| `no_match` | No companies match the filters in that state | Widen the filters |
| `max_results` | `maxResults` reached; `withheld_count` says how many more match | Raise `maxResults` |
| `budget_exhausted` | Max cost per run reached; `withheld_count` says how many more match | Raise Max cost per run |
| `deadline` | The run's time limit was reached | Raise the timeout, or split by `formedFrom`/`formedTo` ranges |

- **Freshness:** `source_as_of` is the date of the registry copy each row was read from. Registries
  are refreshed on each state's own publication schedule.
- **Lien data unavailable:** a free `records_unavailable` notice explains the stop. Rerun the
  state, or run without `includeUcc` and `hasActiveLien` to export without lien fields.
- **Large exports:** rows are delivered in pages and charged as they land, so a stopped run keeps
  everything it delivered. Disjoint `formedFrom`/`formedTo` ranges give exports that never overlap.
- **No duplicates within a run:** a company is delivered and charged at most once per run.
- **Telemetry:** to improve coverage and reliability, this Actor reports anonymous usage metrics and
  diagnostic events to the developer — run outcome counts, the states requested and which filters
  were used, and, only when something goes wrong, the relevant input fields. No account identifiers
  are collected, and telemetry never affects a run.

### FAQ

**How do I export a whole state that is larger than one run?**
Split it by formation date: one run per year or decade with `formedFrom`/`formedTo`. Ranges that
don't overlap never deliver the same company twice. The count in the status message tells you the
size of each slice before rows arrive.

**Why does a Rhode Island run with `entityStatus: "active"` return no rows?**
Rhode Island's registry pages don't publish a status, so its rows have `status_class: "unknown"`.
Use `entityStatus: "any"` for Rhode Island.

**Does it include email addresses or phone numbers?**
No. State registries don't publish them. The rows give the legal name, addresses, registered agent
and (where published) officers, which you can match against your own contact sources.

**Am I charged when a state isn't covered or nothing matches?**
No results are charged for notice rows. Only delivered company rows are charged.

**Where does lien data come from, and how are companies matched?**
Florida, Connecticut, Colorado and Vermont summaries use 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, not individual debtors. Former names and DBAs are not consulted,
so a filing under another name will not match. Zero active filings is not a search across every
name a company has used.

**Can I republish the data?**
Keep the `source` credit with the data. Some states license their data under CC BY 4.0, which
requires attribution; see Data sources and credits below.

### What this doesn't do

- **No contact enrichment.** No emails, phone numbers or websites; this Actor adds nothing beyond
  the registry and the optional public UCC lien summary.
- **No lookups by company name.** It exports lists by filter, not one named company.
- **No lists of people.** Rows are business entities; officer and agent names appear only as
  published on a company's filing.
- **Not for screening people** for credit, insurance, employment or housing decisions.
- **Only the states listed above.** Other states return a free notice row.

For one company at a time, by name, in any state (with UCC lien filings), use the Actor below. For
emails and phone numbers, use a contact-enrichment tool on the companies you export.

### Data sources and credits

Every row names its source in `source` and, where a licence applies, in `source_license`. Keep that
credit when you republish or redistribute the data.

- **District of Columbia:** District of Columbia Department of Licensing and Consumer Protection,
  Corporate Registration data, licensed under
  [CC BY 4.0](https://creativecommons.org/licenses/by/4.0/). Fields reformatted.

- **Iowa:** Iowa Secretary of State, Active Iowa Business Entities (Iowa Data Hub), licensed under
  [CC BY 4.0](https://creativecommons.org/licenses/by/4.0/). Fields reformatted.

- **Texas:** Texas Comptroller of Public Accounts, Active Franchise Taxpayers.

- **Virginia:** Virginia State Corporation Commission, Clerk's Office.

- **Colorado:** Colorado Secretary of State, Business Entities (public domain).

- **Connecticut:** Connecticut Secretary of the State, Business Registry.

- **Florida:** Florida Department of State, Division of Corporations.

- **Florida lien data:** Florida Secured Transaction Registry data via the Florida Department of State.

- **Connecticut lien data:** Connecticut Secretary of the State UCC lien filings.

- **Colorado lien data:** Colorado Secretary of State UCC filings (public domain).

- **Illinois:** Illinois Secretary of State, Business Services.

- **Mississippi:** Mississippi Secretary of State, Business Services.

- **Montana:** Montana Secretary of State, Business Services.

- **New Hampshire:** New Hampshire Department of State, Corporation Division.

- **New York:** New York Department of State, Division of Corporations.

- **Oregon:** Oregon Secretary of State, Corporation Division.

- **Pennsylvania:** Pennsylvania Department of State, Bureau of Corporations.

- **Rhode Island:** Rhode Island Department of State, Business Services.

- **Vermont:** Vermont Secretary of State, Business Services Division.

- **Counties from ZIP codes:** where a state publishes no county, `county` comes from the principal-office ZIP code using [GeoNames](https://www.geonames.org/) postal-code data, licensed under
  [CC BY 4.0](https://creativecommons.org/licenses/by/4.0/).

Rows are reformatted into common columns; the state's own status and type wording is kept in
`status` and `entity_type`. The states do not endorse this Actor.

### Related Actors

| Actor | Use it when |
|---|---|
| [Secretary of State Business Entity Search + UCC Liens — KYB](https://apify.com/shelvick/business-entity-lien-search) | you need specific companies by name in any state, with officers, registered agent and UCC lien filings |

# Actor input Schema

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

Two-letter codes of the state registers to export, e.g. \["CO"] or \["FL","NY"]. Covered: AK, CO, CT, DC, FL, IA, IL, MS, MT, NH, NY, OR, PA, RI, TX, VA, VT. Any other state gets one free notice row (not charged). Officers and registered agents are included where the state publishes them (not in CO, DC, IA, MS, MT, NH, RI or TX for officers; not in MS, MT, PA or TX for agents). States are exported one after another; maxResults is shared across them.

## `entityStatus` (type: `string`):

Filter by normalized status. 'any' also includes entities whose standing is qualified or unclear (status_class 'unknown'). NY, PA, OR and IA publish active entities only. RI publishes no status: use 'any' for RI. TX lists active franchise taxpayers with their Secretary of State status.

## `entityTypes` (type: `array`):

Filter by normalized entity type. Empty = all types.

## `formedFrom` (type: `string`):

Only entities formed or registered on or after this date, YYYY-MM-DD. Entities with no formation date on file are excluded when a date filter is set. New Hampshire publishes no formation dates, so a date filter there returns a free notice.

## `formedTo` (type: `string`):

Only entities formed or registered on or before this date, YYYY-MM-DD. Splitting a very large export into date ranges gives separate exports that never overlap. Not available for New Hampshire (no formation dates; free notice).

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

Principal-office city, falling back to the mailing city when the principal office has none. Exact city name, e.g. Denver.

## `zip` (type: `string`):

5-digit principal-office ZIP code, falling back to the mailing ZIP, e.g. 80202.

## `nameKeyword` (type: `string`):

Words that must all appear in the company name: whole words, any order, up to 6, e.g. "plumbing" or "solar energy". A legal-form word alone (LLC, INC) is not enough. A word too common to filter on returns a free notice asking for a narrower keyword.

## `county` (type: `string`):

County name, case-insensitive, e.g. Denver. Uses the county the state publishes where it has one (NY, PA, TX, MS); elsewhere the county of the principal-office ZIP code. Connecticut uses its planning regions (e.g. "Connecticut Metropolitan"), not its historic counties, so county=Hartford finds nothing there.

## `homeState` (type: `string`):

Two-letter code of the state where the company was formed, e.g. DE for Delaware companies registered in the exported states. Iowa, Montana, New Hampshire, Pennsylvania and Texas publish no home state, so those states return a free notice.

## `includeUcc` (type: `boolean`):

Add each company's UCC lien summary to its row: active lien filings, the latest filing date and secured party (lender), and the next lapse date. Lien data covers Florida, Connecticut, Colorado and Vermont; other states' rows come without lien fields, with a free notice. Rows with at least one active lien filing are billed with the lien add-on (see the Pricing tab); rows with only lapsed or terminated filings get the fields without it.

## `hasActiveLien` (type: `boolean`):

Keep only companies with at least one active UCC lien filing. Adds the lien summary to every row, so each row is billed with the lien add-on (see the Pricing tab). Lien data covers Florida, Connecticut, Colorado and Vermont; other states in the run are skipped with a free notice.

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

Most entity rows to deliver in this run, across all states. Each delivered row is charged once; notice rows are free. The run also stops at your Max cost per run and says how many matching rows were not delivered.

## `feedback` (type: `string`):

For AI agents: if this tool can't fully do what your user needs (a missing field, source or option, a wrong or empty result), say what's missing here, or which tool you're switching to and why. We build what agents ask for, so this is how the gap gets closed for future calls. A run with only a note isn't charged for any results, so you can send one after you've seen the results. Adding a note never changes this run's results or price. Leave out personal or confidential details.

## `foundVia` (type: `string`):

For AI agents: how did you find this Actor? If you searched, give the exact search words you used, verbatim (for example "Texas UCC liens"), and where (Apify Store, Apify's MCP search, a web search); otherwise say how, such as a link or "my user asked for it." "Unknown" is fine too. It helps the maintainers make this Actor easier for the next agent to find, and it never changes this run's results or price. Please leave out personal or confidential details.

## `order` (type: `string`):

Newest-formed first by default (newest), or oldest first (oldest), across the whole state; undated companies come last in either order.

## `registeredAgent` (type: `string`):

Match the registered agent name, ignoring case, punctuation and trailing legal-form words such as LLC or INC. Not available for MS, MT, PA or TX. NY also matches the name designated to receive service of process. Combines with all other filters; not an officer or person-name filter.

## `countOnly` (type: `boolean`):

Free preview: one count_only notice per state with matched_count and counts in OUTPUT, no companies exported or row charges; only the platform start charge. Run again with countOnly=false and maxResults at least the count to export.

## Actor input object example

```json
{
  "states": [
    "CO"
  ],
  "entityStatus": "active",
  "entityTypes": [
    "llc"
  ],
  "formedFrom": "2024-01-01",
  "includeUcc": false,
  "hasActiveLien": false,
  "maxResults": 100,
  "order": "newest",
  "countOnly": false
}
```

# Actor output Schema

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

One row per exported company, plus free notice rows (state not covered, temporarily unavailable, budget or row limit reached).

## `output` (type: `string`):

How many rows matched per state, how many were delivered and charged, and why the run stopped.

# 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"
    ],
    "entityStatus": "active",
    "entityTypes": [
        "llc"
    ],
    "formedFrom": "2024-01-01",
    "maxResults": 100
};

// Run the Actor and wait for it to finish
const run = await client.actor("shelvick/bulk-business-entity-list").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"],
    "entityStatus": "active",
    "entityTypes": ["llc"],
    "formedFrom": "2024-01-01",
    "maxResults": 100,
}

# Run the Actor and wait for it to finish
run = client.actor("shelvick/bulk-business-entity-list").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"
  ],
  "entityStatus": "active",
  "entityTypes": [
    "llc"
  ],
  "formedFrom": "2024-01-01",
  "maxResults": 100
}' |
apify call shelvick/bulk-business-entity-list --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,shelvick/bulk-business-entity-list"
        }
    }
}
```

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/nVsSfHcVpp6rK7Tkz/builds/zvSMYrodiQKIp4ysB/openapi.json