# New York DOS Business Entity Registry Lookup (`xyrelith-data/new-york-dos-business-entity-registry-lookup`) Actor

Search New York's free public business entity registry by name, DOS ID number, registered agent, county, entity type, jurisdiction, city, or officer name, with formation date and address details.

- **URL**: https://apify.com/xyrelith-data/new-york-dos-business-entity-registry-lookup.md
- **Developed by:** [Xyrelith Data](https://apify.com/xyrelith-data) (community)
- **Categories:** Automation, Lead generation, Developer tools
- **Security:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.49 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
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

## New York Business Entity Search & Filing History

Search the **New York Department of State** business registry by legal name, DOS ID number or assumed name (DBA). The actor returns live active, inactive and suspended entities with their registration details, registered agent, CEO and addresses, stock information, and optional name, filing, merger and assumed-name history. No login, account or proxy is required.

### What this actor does

- **12 search modes:** entity name, DOS ID, assumed name, assumed name ID, registered agent, county, entity type, jurisdiction of formation, city, officer/CEO, ZIP code and service-of-process state
- **Live status:** active, inactive and suspended entities, with status dates and the reason recorded by the Department of State
- **Full detail:** section of law, statement status and next due date, service-of-process and principal-office addresses, CEO, registered agent, e-service status, foreign formation details and stock/share information
- **Optional history:** name changes, filing timeline, mergers and assumed names for every record
- **Agency and location coverage:** registered agent, officer and business-location fields are merged in for active entities when the state's open-data feed carries them
- **Filtering and ordering:** entity-type categories, formation-date range, multiple search terms and newest / oldest / name sorting
- **Empty fields are omitted** — records never contain nulls or placeholder values

### Data source and limitations

The records come from the New York Department of State's public business-entity registry and its official open-data publication of active corporations. Entity names, DOS IDs and statuses are informational, not certified. For a certified Certificate of Status or certified copies, order them from the Department of State.

- **300-row search cap:** each name search returns at most 300 rows. Broad terms are automatically split by status, entity-type category and name prefix, but an extremely broad term can still be partial. Narrow the term or use a longer prefix for complete coverage.
- **Active-only browse modes:** registered agent, county, exact entity type, jurisdiction, city, officer, ZIP and state browsing cover active entities only. Use name, assumed-name or DOS-ID search to reach inactive and suspended entities.
- **Sparse fields:** CEO, registered agent and business-location information are on file for a minority of entities, and the open-data feed covers active entities only, so those fields are less common on inactive records. They are omitted when absent rather than shown as blank.
- **No documents:** filing history lists document type, date, file number, page count and amendment notes. The actor does not download filing PDFs or images.

### Output per entity

**Identity and status**

- `entityName` — legal entity name
- `idNumber` — New York DOS ID number
- `entityType` — exact entity type, e.g. `DOMESTIC LIMITED LIABILITY COMPANY`
- `entityTypeCategory` — `CORPORATION`, `LIMITED LIABILITY COMPANY`, `LIMITED PARTNERSHIP` or `LIMITED LIABILITY PARTNERSHIP` (derived from the exact entity type when the source omits it)
- `nameType` — `ACTUAL` or `ASSUMED NAME`
- `status` — `Active`, `Inactive` or `Suspended`
- `formationDate` — original DOS filing date (`YYYY-MM-DD`)
- `effectiveFilingDate` — effective date of the initial filing
- `county`, `counties` — county (or counties, for a multi-county assumed name)
- `jurisdiction` — state, province or country of formation
- `assumedName`, `assumedNameId` — DBA name and its ID
- `publicUrl` — a public company-registry page for the DOS ID (OpenCorporates)

**Registration detail** *(with `includeDetails`)*

- `sectionOfLaw` — section of law the entity is registered under
- `statementStatus`, `nextStatementDueDate` — biennial-statement status and due date
- `inactiveDate`, `reasonForStatus` — when and why the entity became inactive
- `foreignFormationDate`, `foreignLegalName`, `fictitiousName`
- `durationDate`, `latestDissolutionDate`, `nfpCategory`, `farmCorpFlag`
- `serviceOfProcessName`, `serviceOfProcessAddress` — who receives legal process, with a structured address
- `principalAddress`, `principalCity`, `principalState`, `principalZip`
- `principalExecutiveAddress` — principal executive office, structured
- `ceoName`, `ceoAddress` — chief executive officer on file
- `registeredAgentName`, `registeredAgentAddress` — registered agent
- `officerName`, `officerAddress` — chairman/CEO on file
- `businessLocationName`, `businessLocationAddress`, `locationName`, `locationAddress`
- `electronicServiceOfProcessStatus`, `electronicServiceOfProcessEmail`
- `stockShares[]` — `{stockType, parValue, quantity}`

**History** *(with `includeHistory`)*

- `nameHistory[]` — `{entityName, documentType, fileDate, fileNumber}`
- `filingHistory[]` — `{documentType, amendmentDescription, fileDate, fileNumber, pageCount}`
- `mergerHistory[]` — `{documentType, survivorResultEntity, constituents, fileDate, fileNumber}`
- `assumedNames[]` — `{assumedName, assumedNameId, status, fileDate}`

**Metadata**

- `sourceUrl` — the entity's record in the state's open-data feed (active entities)
- `recordType: "entity"`, `scrapedAt`

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `mode` | string | `byEntityName` | One of the 12 search modes |
| `entityName` | string | `AMAZON` | Legal name (mode=byEntityName) |
| `entityNameMatchType` | string | `startsWith` | `startsWith` / `contains` / `exact` |
| `idNumbers` | array | – | DOS ID numbers; entity-page URLs accepted |
| `assumedName` | string | – | DBA name (mode=byAssumedName) |
| `assumedNameMatchType` | string | `contains` | `startsWith` / `contains` |
| `assumedNameId` | string | – | Exact DBA ID (mode=byAssumedNameId) |
| `agentName` | string | – | Registered agent (mode=byRegisteredAgent, active only) |
| `agentMatchType` | string | `contains` | `startsWith` / `contains` |
| `county` | string | `New York` | One of the 62 NY counties (mode=byCounty, active only) |
| `entityType` | string | `DOMESTIC LIMITED LIABILITY COMPANY` | Exact entity type (mode=byEntityType, active only) |
| `jurisdiction` | string | `Delaware` | Formation jurisdiction (mode=byJurisdiction, active only) |
| `city` | string | `BROOKLYN` | Service-of-process city (mode=byCity, active only) |
| `cityMatchType` | string | `startsWith` | `startsWith` / `contains` |
| `officerName` | string | – | Officer/CEO (mode=byOfficerName, active only) |
| `officerMatchType` | string | `contains` | `startsWith` / `contains` |
| `zipCode` | string | `10001` | Service-of-process ZIP (mode=byZipCode, active only) |
| `state` | string | `NY` | Service-of-process state code (mode=byState, active only) |
| `entityStatus` | string | `Active` | `AllStatuses` / `Active` / `Inactive` / `Suspended` (official name and assumed-name modes) |
| `entityTypeCategories` | array | all | Any of the four DOS categories |
| `includeDetails` | boolean | `true` | Fetch the full registration detail |
| `includeHistory` | boolean | `false` | Fetch name, filing, merger and assumed-name history |
| `sortBy` | string | `source` | `source` / `newest` / `oldest` / `name` |
| `searchTerms` | array | – | Extra names or DOS IDs searched in the same run |
| `formationDateFrom` | string | – | `YYYY-MM-DD`, all modes |
| `formationDateTo` | string | – | `YYYY-MM-DD`, all modes |
| `maxItems` | int | `25` | Hard cap (1–5000) |

#### Example: inactive entities with full history

```json
{
  "mode": "byEntityName",
  "entityName": "AMAZON",
  "entityNameMatchType": "contains",
  "entityStatus": "Inactive",
  "includeDetails": true,
  "includeHistory": true,
  "maxItems": 25
}
```

#### Example: find every business using a DBA

```json
{
  "mode": "byAssumedName",
  "assumedName": "AMAZON FRESH",
  "assumedNameMatchType": "contains",
  "entityStatus": "AllStatuses",
  "includeDetails": true,
  "maxItems": 25
}
```

#### Example: look up specific DOS IDs

```json
{
  "mode": "byIdentificationNumber",
  "idNumbers": ["4809335", "4282851", "5561845"],
  "includeDetails": true,
  "includeHistory": true
}
```

#### Example: browse active entities by county and date

```json
{
  "mode": "byCounty",
  "county": "Kings",
  "formationDateFrom": "2024-01-01",
  "formationDateTo": "2024-12-31",
  "sortBy": "newest",
  "maxItems": 100
}
```

#### Example: foreign entities formed in England

```json
{
  "mode": "byJurisdiction",
  "jurisdiction": "ENGLAND",
  "maxItems": 50
}
```

### Use cases

- **Due diligence and KYC** — confirm legal name, DOS ID, formation date and current status before signing or onboarding a vendor
- **Compliance and litigation research** — trace prior names, mergers and filing history for a New York entity
- **Registered-agent research** — find the active entities a specific agent represents in New York
- **DBA and brand research** — find the legal entity behind a storefront, brand or trade name
- **Lead lists** — build active-business lists by county, ZIP code, entity type or formation date
- **Name availability** — check existing names and DBAs before forming a new entity

### FAQ

**Where does the data come from?** The New York Department of State's public business-entity registry, plus its official open-data publication of active corporations. This is an independent tool and is not affiliated with the State of New York.

**Is this data official or legally binding?** No. It is the same free informational data the Department of State publishes. For a certified Certificate of Status or certified copies, order them from the Department of State.

**What do the statuses mean?** `Active` means the entity is current with the Department of State. `Inactive` means it was dissolved, terminated or otherwise ended, and `Suspended` means it is not in good standing. The `reasonForStatus` and `inactiveDate` fields explain an inactive record.

**Why did my broad name search stop at 300 rows?** The state search returns at most 300 rows per query. The actor automatically splits broad searches by status, entity-type category and name prefix, but a very broad term can still be partial. Use a longer prefix or a narrower term.

**Why are agent, CEO or business-location fields missing on some records?** Those fields are on file for only a minority of entities. The active-only open-data feed adds them for some active entities; inactive records usually only carry the official registration detail. Missing fields are omitted, never shown as blank.

**Why does `exact` return fewer results than expected?** Exact mode filters the candidates returned by the state search. If the prefix itself is capped at 300 rows, the exact entity may not be among the returned candidates; use a full name with `startsWith` or reset the status filter.

**How fresh is the data?** Status, detail and history come from the live registry. The supplementary agent/location feed is refreshed periodically by the state, so those fields can lag the live record.

**Does history include filing documents?** No. History lists document type, date, file number, page count and amendment notes. Filing PDFs and images are ordered separately from the Department of State.

**Do I need an API key or proxy?** No. The actor works out of the box with no account, key, cookie or proxy configuration.

# Actor input Schema

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

What to search by. Fields labelled with a mode are only used by that mode.

## `entityName` (type: `string`):

Legal business name to search for, e.g. `AMAZON` or `GOOGLE ACCESS`.

## `entityNameMatchType` (type: `string`):

How the entity name is matched. `Exact match` is applied after the search returns.

## `idNumbers` (type: `array`):

Exact New York DOS ID numbers. Pasted entity-page URLs are accepted.

## `assumedName` (type: `string`):

Doing-business-as name to search for, e.g. `AMAZON FRESH`.

## `assumedNameMatchType` (type: `string`):

How the assumed name is matched.

## `assumedNameId` (type: `string`):

Exact New York assumed-name (DBA) ID, e.g. `6502000`.

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

Registered agent name to search for, e.g. `CT CORPORATION SYSTEM`. Active entities only.

## `agentMatchType` (type: `string`):

How the registered agent name is matched.

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

New York county of the entity's service-of-process address. Active entities only.

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

Exact entity type recorded by NY DOS. Active entities only. For the broader official categories use `entityTypeCategories`.

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

State, territory, province or country where the entity was originally formed. Active entities only.

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

City of the service-of-process address, e.g. `BROOKLYN`. Active entities only.

## `cityMatchType` (type: `string`):

How the city is matched.

## `officerName` (type: `string`):

Officer, chairman or CEO name on file. Active entities only. Populated for a minority of entities.

## `officerMatchType` (type: `string`):

How the officer name is matched.

## `zipCode` (type: `string`):

5-digit ZIP of the service-of-process address, e.g. `10001`. ZIP+4 is accepted and truncated. Active entities only.

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

2-letter state/territory code of the service-of-process address (not the formation jurisdiction). Active entities only.

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

Filter by live DOS status: active, inactive or suspended. Applies to name, assumed-name and assumed-name ID searches. DOS-ID lookups always return the entity's real status. Legacy active-only browse modes ignore it.

## `entityTypeCategories` (type: `array`):

Limit official name/assumed-name searches to one or more of the four DOS categories. Leave empty for all.

## `includeDetails` (type: `boolean`):

Fetch each entity's detail record (section of law, CEO, stock, statement status, addresses, e-service). Adds one request per record.

## `includeHistory` (type: `boolean`):

Fetch name, filing, merger and assumed-name history for each record. Adds up to four requests per record.

## `sortBy` (type: `string`):

Order of the emitted records. `Source order` keeps the order returned by the registry.

## `searchTerms` (type: `array`):

Extra names or DOS IDs searched in the same run and merged with the main term. Applies to name, assumed-name and DOS-ID modes.

## `formationDateFrom` (type: `string`):

Only include entities formed/registered on or after this date (`YYYY-MM-DD`).

## `formationDateTo` (type: `string`):

Only include entities formed/registered on or before this date (`YYYY-MM-DD`).

## `maxItems` (type: `integer`):

Hard cap on emitted records (1-5000).

## Actor input object example

```json
{
  "mode": "byEntityName",
  "entityName": "AMAZON",
  "entityNameMatchType": "startsWith",
  "idNumbers": [
    "4087072"
  ],
  "assumedNameMatchType": "contains",
  "agentMatchType": "contains",
  "county": "New York",
  "entityType": "DOMESTIC LIMITED LIABILITY COMPANY",
  "jurisdiction": "Delaware",
  "city": "BROOKLYN",
  "cityMatchType": "startsWith",
  "officerMatchType": "contains",
  "zipCode": "10001",
  "state": "NY",
  "entityStatus": "Active",
  "entityTypeCategories": [],
  "includeDetails": false,
  "includeHistory": false,
  "sortBy": "source",
  "maxItems": 1
}
```

# Actor output Schema

## `entities` (type: `string`):

Dataset containing all scraped New York business entity records.

# 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 = {
    "mode": "byEntityName",
    "entityName": "AMAZON",
    "entityNameMatchType": "startsWith",
    "idNumbers": [
        "4087072"
    ],
    "assumedNameMatchType": "contains",
    "agentMatchType": "contains",
    "county": "New York",
    "entityType": "DOMESTIC LIMITED LIABILITY COMPANY",
    "jurisdiction": "Delaware",
    "city": "BROOKLYN",
    "cityMatchType": "startsWith",
    "officerMatchType": "contains",
    "zipCode": "10001",
    "state": "NY",
    "entityStatus": "Active",
    "entityTypeCategories": [],
    "includeDetails": false,
    "includeHistory": false,
    "sortBy": "source",
    "maxItems": 1
};

// Run the Actor and wait for it to finish
const run = await client.actor("xyrelith-data/new-york-dos-business-entity-registry-lookup").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 = {
    "mode": "byEntityName",
    "entityName": "AMAZON",
    "entityNameMatchType": "startsWith",
    "idNumbers": ["4087072"],
    "assumedNameMatchType": "contains",
    "agentMatchType": "contains",
    "county": "New York",
    "entityType": "DOMESTIC LIMITED LIABILITY COMPANY",
    "jurisdiction": "Delaware",
    "city": "BROOKLYN",
    "cityMatchType": "startsWith",
    "officerMatchType": "contains",
    "zipCode": "10001",
    "state": "NY",
    "entityStatus": "Active",
    "entityTypeCategories": [],
    "includeDetails": False,
    "includeHistory": False,
    "sortBy": "source",
    "maxItems": 1,
}

# Run the Actor and wait for it to finish
run = client.actor("xyrelith-data/new-york-dos-business-entity-registry-lookup").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 '{
  "mode": "byEntityName",
  "entityName": "AMAZON",
  "entityNameMatchType": "startsWith",
  "idNumbers": [
    "4087072"
  ],
  "assumedNameMatchType": "contains",
  "agentMatchType": "contains",
  "county": "New York",
  "entityType": "DOMESTIC LIMITED LIABILITY COMPANY",
  "jurisdiction": "Delaware",
  "city": "BROOKLYN",
  "cityMatchType": "startsWith",
  "officerMatchType": "contains",
  "zipCode": "10001",
  "state": "NY",
  "entityStatus": "Active",
  "entityTypeCategories": [],
  "includeDetails": false,
  "includeHistory": false,
  "sortBy": "source",
  "maxItems": 1
}' |
apify call xyrelith-data/new-york-dos-business-entity-registry-lookup --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,xyrelith-data/new-york-dos-business-entity-registry-lookup"
        }
    }
}
```

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/z5kjwPgX5t6AcMwCj/builds/KYrNb7RXr86YGAESj/openapi.json