# NY Corporation Registry - Companies & Filing History (`j0401/ny-corporation-registry`) Actor

New York's corporation register (4.28M companies) and its complete Department of State filing history (20.9M documents): entity type, county, CEO, registered agent and address, plus every filed document, the status trail, the name trail and every address of record - joined on the exact DOS id.

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

## Pricing

from $0.06 / 1,000 ny corporation 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

## NY Corporation Registry - Companies & Filing History

New York's **corporation register**, its **complete filing history**, its **status trail**, its **name trail** and its **address-of-record trail** - all on one exact key.

Every corporation in New York has a DOS id. That id is the same in the register and in the 20.9-million-document filing history, so a company's current record and every document it ever filed line up exactly - no name matching, no fuzzy joins.

### Low cost

**From $0.0001 per record, down to $0.00006 at Gold** Pay-per-event: you are charged per record delivered, and nothing for the query.

### What you get

| Corpus | Rows | Row is |
|---|---|---|
| `entities` | **4,280,630** | one corporation on the register |
| `filings` | **20,946,484** | one document filed against a corporation |
| `statuses` | **20,946,484** | a filing carrying the corporation's **status at that time** |
| `names` | **7,493,463** | one recorded name, in use or superseded |
| `addresses` | **18,395,004** | one address of record on a filing |

The history covers **7,188,809** distinct DOS ids against the register's 4,280,630 - it reaches corporations that have since been **dissolved, merged or administratively removed**. Ask for an id and you get the entire filing chain of a business that no longer appears on the register at all.

#### The register (`entities`)

- **Status** - the corporation's standing, stamped on every entity record from the most recent filing that states one: `Active` (17.4M filings), `Inactive` (2.86M), `Suspended` (12,108), `Discontinued` (3,956). The register itself carries no status column, so this is the only place a suspended corporation is visible.
- **Entity type** - across both corpora the source publishes 84 exact values (54 on the register, 84 on filings - 30 exist only as filing types): `DOMESTIC LIMITED LIABILITY COMPANY` (2,052,152), `DOMESTIC BUSINESS CORPORATION` (1,450,043), `DOMESTIC NOT-FOR-PROFIT CORPORATION` (287,453), foreign corporations and LLCs, professional service corporations, housing development fund companies, fire corporations, land banks, and the rest. Exact match - these types are long enough that one is often a prefix of another.
- **County** - 64 values, `New York` 830,064, `Kings` 599,227, `Queens` 440,991, `Nassau` 407,154, `Suffolk` 343,718.
- **Jurisdiction of formation** - 82 values: `New York` 3,931,262, `Delaware` 197,574, `New Jersey` 28,995, `Florida` 11,757, `California` 11,453.
- **Registration date** back to 1800.
- **Four address blocks** - the DOS process (service of process) address, the principal **location** address, the **CEO** block and the **registered agent** block, each a full address.
- **Last status** - the corporation's current standing (`lastStatus`), the date the filing that stated it was filed (`lastStatusDate`), and the date of the newest filing of any kind (`lastFilingDate`).

#### The filing history (`filings`)

Every document ever recorded, with the law it was filed under, its filing / approval / effective dates, the entity type at the time, and the corporation's name as of that filing:

- `BIENNIAL STATEMENT` (7,089,058) - the biennial filings NY corporations owe
- `CERTIFICATE OF INCORPORATION` (4,066,695) - formations
- `ARTICLES OF ORGANIZATION` (2,347,995) - LLC formations
- `DISSOLUTION BY PROCLAMATION` (1,622,585) - dissolution for non-payment, where **1.6M corporations quietly went out of business**
- `CERTIFICATE OF PUBLICATION` (1,089,923)
- `CERTIFICATE OF AMENDMENT` (703,642), `CERTIFICATE OF DISSOLUTION` (585,418), `APPLICATION OF AUTHORITY` (540,521 - foreign corporations entering NY), `ASSUMED NAME CORP INITIAL FILING` (444,010), and more

#### The status, name and address trails

- **`statuses`** - a parallel view of the filing stream (the same 20,946,484 filing rows), each row carrying the corporation's status **as of that filing** (`Active` 17,439,274 / `Inactive` 2,861,951 / `Suspended` 12,108 / `Discontinued` 3,956) and a blank where the source recorded none. This is the standing trail: filter by status to find every suspended or discontinued filing on record.
- **`names`** - every name recorded on a filing, with `name_type` and a `name_status` of `A` (in use) or `I` (superseded): 4,313,513 in use against 3,179,950 superseded. The rename trail a current-name-only lookup loses entirely.
- **`addresses`** - 18,395,004 addresses of record, each with the party the address belonged to, a numeric address type, and the full address including the ZIP+4 split across its own columns.

### Modes

- **`rows`** (default) - records matching your filters. Provide a DOS id for one corporation, a name substring to search, or a document type and a date window to sweep the filing stream.
- **`aggregate`** - one count row per group. Roll the register up by entity type, county or jurisdiction; the filings by document type, entity type, county or law; the statuses by status; the names by name status; the addresses by address type.
- **`profile`** - one DOS id in, the corporation's register row plus its full status, filing, name and address history out, up to your `maxResults` budget.

### Inputs

The filter set follows the corpus you pick. The `entities` corpus takes `entityId`, `name`, `entityType`, `county`, `jurisdiction`, `city`, `zip`, `agentName` and a `filedFrom` / `filedTo` date window. The `filings` corpus takes `entityId`, `entityType`, `documentType`, `filingName`, `law`, `filingNum`, `county`, plus date windows on the filed and effective dates. The `statuses` corpus takes `status` and a date window; `names` takes `filingName` and `nameStatus`; `addresses` takes `addressName`, `addressCity`, `addressState`, `addressZip` and `addressType`.

A filter that belongs to the other corpus is rejected outright rather than silently ignored - so a query you narrowed never comes back unnarrowed.

### Example inputs

**Every active LLC named "Contracting" in New York**

```json
{ "corpus": "entities", "name": "CONTRACTING",
  "entityType": "DOMESTIC LIMITED LIABILITY COMPANY", "maxResults": 200 }
```

**The full filing chain of one corporation**

```json
{ "mode": "profile", "entityId": "1000013", "maxResults": 500 }
```

**Every dissolution filed this year**

```json
{ "corpus": "filings", "documentType": "CERTIFICATE OF DISSOLUTION",
  "filedFrom": "2026-01-01", "maxResults": 500 }
```

**How many corporations by entity type**

```json
{ "mode": "aggregate", "corpus": "entities", "groupBy": "entityType" }
```

### Notes on the data

- **The register carries no status column - but the status does exist.** New York records a corporation's standing per filing, not on the register, so it lives in the `statuses` corpus. Every entity record is stamped with the newest **stated** status (`lastStatus`), with `lastStatusDate` recording the filing that stated it and `lastFilingDate` the newest filing of any kind - a suspended corporation is visible without a second query.
- **The register is the narrower side.** 2.9M DOS ids appear only in the history. If a lookup returns filings but no register row, the corporation was removed from the register - the documents are the surviving record.
- **A handful of values contain non-ASCII characters** that come straight from the source (one entity type uses an en dash, another a non-breaking space). Matching is exact on what the source stores.
- **County and jurisdiction counts include a blank bucket.** New York's register has 64 county values of which one is blank (16,315 rows), and 82 jurisdiction values of which one is blank (12,770 rows).
- **The register stores ZIP+4 as nine digits with no dash** (`122072543` for 12207-2543) on 102,961 rows. A `zip` filter matches the 5-digit prefix, so both that and a plain `12207` are returned.

### Output

One JSON record per row, with the same key set whichever corpus produced it - so the rows load cleanly into a table or a dataframe without a schema union step.

**Pay-per-event** - you are charged per record delivered (`entity-record`), never for the query itself. The run stops cleanly if you set a spend limit on your Apify account.

### Example output

**One corporation** - `entityId=8024194` on the `entities` corpus, one record:

```json
{
  "platform": "ny-corporation-registry",
  "source": "new-york-dos-corporations",
  "corpus": "entities",
  "mode": "rows",
  "recordType": "entities",
  "groupKey": "", "groupCount": "", "groupBy": "",
  "entityId": "8024194",
  "entityName": "UNDERWOOD PROPCO LLC",
  "entityType": "DOMESTIC LIMITED LIABILITY COMPANY",
  "county": "Nassau",
  "jurisdiction": "New York",
  "filingDate": "2026-09-17T00:00:00.000",
  "lastFilingDate": "", "lastStatus": "", "lastStatusDate": "",
  "processName": "Charles Hartman",
  "processAddress1": "1212 Seagirt BLVD",
  "processAddress2": "",
  "processCity": "Far Rockaway",
  "processState": "NY",
  "processZip": "11619",
  "agentName": "", "agentAddress1": "", "agentAddress2": "", "agentCity": "", "agentState": "", "agentZip": "",
  "locationName": "", "locationAddress1": "", "locationAddress2": "", "locationCity": "", "locationState": "", "locationZip": "",
  "chairmanName": "", "chairmanAddress1": "", "chairmanAddress2": "", "chairmanCity": "", "chairmanState": "", "chairmanZip": "",
  "address1": "", "address2": "", "addressCity": "", "addressState": "", "addressZip5": "", "addressZip4": "", "addressCountry": "", "addressType": "",
  "documentType": "", "law": "", "filingNum": "", "nameStatus": "", "nameType": "",
  "effectiveDate": "", "approvedDate": "", "durationDate": "", "modCertCode": "", "nfpType": "",
  "status": "",
  "sourceUpdatedAt": "2026-09-18"
}
```

**`mode=aggregate`, `corpus=entities`, `groupBy=entityType`** - one row per type; every group is returned, and the group lands in `groupKey` with its count in `groupCount`:

```
DOMESTIC LIMITED LIABILITY COMPANY     2,052,152
DOMESTIC BUSINESS CORPORATION          1,450,043
DOMESTIC NOT-FOR-PROFIT CORPORATION      287,453
```

# Actor input Schema

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

rows = records matching your filters (default). aggregate = one count row per group (see groupBy). profile = one corporation's register row plus its entire filing history - requires entityId.

## `corpus` (type: `string`):

entities = the register (4,280,630 corporations, default). filings = filed documents (20,946,484). statuses = the same filings carrying the corporation's status at that time (20,946,484) - where Active / Inactive / Suspended / Discontinued lives. names = recorded names, in use or superseded (7,493,463). addresses = addresses of record on each filing (18,395,004). Filters below apply to the corpus you pick.

## `entityId` (type: `string`):

Exact New York DOS id (numeric), e.g. '1000013'. The one key that ties a corporation to its whole history. Also the mode=profile input. Entity records carry lastStatus / lastStatusDate (newest stated standing) and lastFilingDate (newest filing of any kind).

## `name` (type: `string`):

Entity name substring, e.g. 'CONTRACTING', 'TRUCKING'. Matches the current name on the register. (entities corpus)

## `entityType` (type: `string`):

Exact New York entity type - all 84 values the source publishes, across both corpora (54 appear on the register, 84 on filings; 30 exist only as filing types). Domestic limited liability company 2.05M, domestic business corporation 1.45M. Blank = any. (both corpora)

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

County substring, e.g. 'New York' (830,064), 'Kings', 'Queens'. Blank = any. (both corpora)

## `jurisdiction` (type: `string`):

Jurisdiction of formation, e.g. 'New York' (3.93M), 'Delaware' (197,574). Substring match. Blank = any. (entities corpus)

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

City substring - matches the DOS process address, the principal location or the CEO address. Blank = any. (entities corpus)

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

ZIP - matches the 5-digit prefix on the DOS process, location, CEO or registered-agent address, so both '10550' and the ZIP+4 form the source stores ('105503001') are returned. Digits and dashes only. Blank = any. (entities corpus)

## `agentName` (type: `string`):

Registered-agent name substring. Blank = any. (entities corpus)

## `documentType` (type: `string`):

Filing document type substring, e.g. 'BIENNIAL STATEMENT' (7.09M), 'CERTIFICATE OF INCORPORATION' (4.07M), 'ARTICLES OF ORGANIZATION' (2.35M), 'DISSOLUTION'. Blank = any. (filings corpus)

## `filingName` (type: `string`):

The corporation name as recorded on the filing - for a name-change filing this is the name at that time. Blank = any. (filings corpus)

## `law` (type: `string`):

The law the document was filed under, substring match, e.g. 'LIMITED LIABILITY COMPANY LAW'. Blank = any. (filings corpus)

## `filingNum` (type: `string`):

Exact filing (film) number, e.g. '210621000105'. Blank = any. (filings corpus)

## `filedFrom` (type: `string`):

Filings with a date on or after this (YYYY-MM-DD). Rows with no date are kept, not dropped. Blank = any. (both corpora)

## `filedTo` (type: `string`):

Filings with a date on or before this (YYYY-MM-DD). Blank = any. (both corpora)

## `effectiveFrom` (type: `string`):

Filings taking effect on or after this date (YYYY-MM-DD). Blank = any. (filings corpus)

## `effectiveTo` (type: `string`):

Filings taking effect on or before this date (YYYY-MM-DD). Blank = any. (filings corpus)

## `groupBy` (type: `string`):

Which dimension to aggregate over (mode=aggregate). entityType / county / jurisdiction belong to entities; documentType and law to filings; status to statuses; nameStatus to names; addressType to addresses. Blank = a sensible default for the selected table - do not leave it set when switching corpus.

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

Cap the number of records pushed in rows / profile 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.

## `status` (type: `string`):

Exact corporation status as recorded on the filing: Active, Inactive, Suspended, Discontinued. Blank = any. (statuses corpus)

## `nameStatus` (type: `string`):

Whether the name on that filing was in use ('A') or superseded ('I'). Blank = any. (names corpus)

## `addressType` (type: `string`):

Numeric address-type code the source assigns (1, 2, 3, 4, ...). Blank = any. (addresses corpus)

## `addressName` (type: `string`):

Name of the party the address belonged to, substring match. Blank = any. (addresses corpus)

## `addressCity` (type: `string`):

City substring on the address of record. Blank = any. (addresses corpus)

## `addressState` (type: `string`):

Two-letter state on the address of record. Blank = any. (addresses corpus)

## `addressZip` (type: `string`):

ZIP on the address of record - matches the 5-digit part or the full ZIP+4. Blank = any. (addresses corpus)

## Actor input object example

```json
{
  "mode": "rows",
  "corpus": "entities",
  "entityId": "",
  "name": "",
  "entityType": "",
  "county": "",
  "jurisdiction": "",
  "city": "",
  "zip": "",
  "agentName": "",
  "documentType": "",
  "filingName": "",
  "law": "",
  "filingNum": "",
  "filedFrom": "",
  "filedTo": "",
  "effectiveFrom": "",
  "effectiveTo": "",
  "groupBy": "",
  "maxResults": 50,
  "status": "",
  "nameStatus": "",
  "addressType": "",
  "addressName": "",
  "addressCity": "",
  "addressState": "",
  "addressZip": ""
}
```

# Actor output Schema

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

New York corporation records, filings 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/ny-corporation-registry").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/ny-corporation-registry").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/ny-corporation-registry --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,j0401/ny-corporation-registry"
        }
    }
}
```

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/hj4kdQqa7Aa8UPHeM/builds/Gx7fsT2b15i2NSoT9/openapi.json