# New Business Registrations Scraper: Secretary of State NY CO CT (`neverempty/us-new-business-registrations-monitor`) Actor

New business registrations from Secretary of State open data for New York, Colorado and Connecticut: name, registration number, entity type, date, status, address and registered agent. Filter by state, date, type, name or city, look up numbers, or monitor and get only new businesses.

- **URL**: https://apify.com/neverempty/us-new-business-registrations-monitor.md
- **Developed by:** [NeverEmpty](https://apify.com/neverempty) (community)
- **Categories:** Lead generation, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.80 / 1,000 business returneds

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

## New Business Registrations Scraper: Secretary of State NY, CO, CT

Get **new business registrations** from the **Secretary of State** open data of **New York, Colorado and Connecticut**: one row per business with name, registration number, entity type, registration date, status, addresses and registered agent. Filter by state, date, kind of business, words in the name, or city. Look businesses up by registration number. Or **monitor** a search and get only the businesses that were not there at the last run.

No API key, no login, no browser. The Actor reads the open data portals the three states publish themselves.

**States covered: NY, CO, CT only.** Other states are not in this Actor. Florida is in our separate Actor [Florida Sunbiz Scraper](https://apify.com/neverempty/florida-sunbiz-scraper).

### What you can do with it

- **Sales leads from newly formed companies**: every LLC registered in Colorado last week, with principal address and registered agent.
- **KYB and onboarding checks**: look up a list of registration numbers and get the current registry record for each.
- **Daily feed**: schedule a monitoring run once a day; each run returns only businesses that are new since the previous one.
- **Name watch**: monitor names containing a word (a brand, an industry term) in one or more states.

### The data, state by state

Measured on 2026-10-05.

| | New York | Colorado | Connecticut |
|---|---|---|---|
| Source | Department of State, Division of Corporations (`data.ny.gov`, dataset `n9v6-gdp6`) | Secretary of State (`data.colorado.gov`, dataset `4ykn-tg5h`) | Secretary of the State (`data.ct.gov`, dataset `n7gp-d28j`) |
| Update schedule stated by the state | "Monthly" in the dataset description | "Every day after midnight" | "Daily" |
| Last update we saw | 2026-10-04, with registrations dated 2026-10-03 already in it | 2026-10-04 | 2026-10-05 |
| Registration number | DOS ID | Entity ID | Account number |
| Which businesses | **Active businesses only** (dissolved ones are not listed) | All statuses | All statuses. Filings the state **rejected** (status Rejected) are left out unless you set `includeRejected` |
| Status in the row | none (`entityStatus` is null) | Good Standing, Delinquent, Voluntarily Dissolved ... | Active, Rejected, Dissolved ... |
| Address | Address for service of process (not always where the business is), county | Principal and mailing address | Business address, mailing address as one text |
| Registered agent | Name and address when the business has one (about 30% of new filings) | Person or organization, with address | Not in this data |
| Extras | | State of formation | Business email, NAICS description, state of formation |

Every row carries `dataUpdatedAt` (when the state last changed its data, from the portal's `Last-Modified` header) so you can see how fresh it is.

Things worth knowing:

- **The newest one or two days are incomplete.** A state adds registrations to a date for a few days. Monitoring handles this: it compares registration numbers of the last 30 days, not a date, so a business added late is still returned.
- **New York describes its dataset as posted monthly.** When we looked on 2026-10-05 it had been updated the day before and held registrations up to 2026-10-03, so in practice it was fresher than monthly, but the state does not promise that. Check `dataUpdatedAt` in the rows.
- **Connecticut publishes rejected filings** in the same data (42 of 772 rows registered 2026-09-29 to 2026-10-02). Searches and monitoring leave them out by default. Set `includeRejected: true`, or name `Rejected` in `statuses`, to get them. A lookup by registration number returns the record whatever its status.
- Colorado has a few records with a registration date in the future. They are returned as the state publishes them.
- A value that the state does not publish is `null`. Nothing is filled in or guessed.

### Kind of business

Each state names entity types its own way. `entityType` is always the state's own value. `entityKind` is our grouping, used by the "Kind of business" filter:

| Kind | New York (type contains) | Colorado (type is) | Connecticut (type is) |
|---|---|---|---|
| `llc` | LIMITED LIABILITY COMPANY | DLLC, FLLC | LLC |
| `corporation` | BUSINESS CORPORATION, SERVICE CORPORATION | DPC, FPC, DPC-PBC | Stock, B Corp |
| `nonprofit` | NOT-FOR-PROFIT | DNC, FNC | Non-Stock, Religious |
| `partnership` | PARTNERSHIP | DLLP, DLP, FLP, DLLLP, FLLP, FLLLP, GP | LLP, Limited Partnership, General Partnerships |

Types outside this table (cooperatives, trusts, name reservations and others) have `entityKind: null` and are returned only when the kind filter is empty. The grouping of Colorado's abbreviations is ours; check `entityType` if the exact legal form matters to you.

### Input

| Field | What it does |
|---|---|
| `states` | `NY`, `CO`, `CT`. Empty means all three. |
| `registeredInLastDays` | Registered within this many days before today (UTC). |
| `registeredFrom`, `registeredTo` | Registration date range, `YYYY-MM-DD`. |
| `entityKinds` | `llc`, `corporation`, `nonprofit`, `partnership` (table above). |
| `nameContains` | Words or phrases; the name must contain any of them. With no date filter this searches the whole registry data of the state. |
| `cities` | Exact city names. For New York this is the city of the service-of-process address. |
| `statuses` | Exact statuses, e.g. `Active` (CT) or `Good Standing` (CO). Not applied to New York, which has no status. |
| `includeRejected` | Connecticut only: also return filings with status Rejected. Default off. |
| `maxBusinesses` | Total rows; shared evenly between the states. Default 200. Not used in monitoring mode. |
| `registrationNumbers` | Look up these numbers in the states set in `states` instead of searching. |
| `monitoringMode` | Return only businesses that are new since the previous monitoring run with the same states and filters. |
| `resetMonitoringState` | Forget what monitoring remembered for these states and filters. |
| `includePeople` | Include registered agent and (CT) business email. Default on. |

Search example - LLCs registered in New York in the last 7 days:

```json
{ "states": ["NY"], "registeredInLastDays": 7, "entityKinds": ["llc"], "maxBusinesses": 500 }
```

Monitoring example - schedule once a day:

```json
{ "states": ["CO", "CT"], "entityKinds": ["llc", "corporation"], "monitoringMode": true }
```

### Monitoring mode

- The **first** run with a given set of states and filters remembers the matching businesses registered in the last 30 days and returns no business row (status `baseline-saved`, not charged).
- **Later** runs return only businesses whose registration number was not remembered, each with `change: "new-business"`. All of them are returned; `maxBusinesses` does not cut a monitoring run.
- A run that finds nothing new returns one row with status `no-new-businesses` and is charged one `search-checked` event.
- A business is remembered only after its row was delivered. If a run stops at your maximum total charge or a state cannot be read, the businesses not delivered still count as new next time.
- Memory is kept per state and per filter set. The date inputs are not part of it (monitoring always looks at the last 30 days).
- If one state cannot be read, the other states are still compared and the unreadable state gets its own row saying so.
- Do not run two monitoring runs with the same states and filters at the same moment; both could return the same business.
- The states publish about once a day, so a daily schedule is enough.

### Output

```json
{
  "status": "ok",
  "state": "CO",
  "registrationNumber": "20268238992",
  "businessName": "CG & Co. House of Bridal LLC",
  "entityType": "DLLC",
  "entityKind": "llc",
  "registeredDate": "2026-10-03",
  "entityStatus": "Good Standing",
  "jurisdiction": "CO",
  "county": null,
  "principalAddress": { "street": "4117 Main Street, Suite C", "street2": null, "city": "Timnath", "state": "CO", "zip": "80547", "country": "US" },
  "mailingAddress": null,
  "registeredAgent": { "name": "…", "organization": null, "address": { "street": "4117 Main Street", "street2": "Suite C", "city": "Timnath", "state": "CO", "zip": "80547", "country": "US" } },
  "email": null,
  "naics": null,
  "officialSearchUrl": "https://www.sos.state.co.us/biz/BusinessEntityCriteriaExt.do",
  "sourceDataset": "https://data.colorado.gov/d/4ykn-tg5h",
  "dataUpdatedAt": "2026-10-04T11:15:34.000Z",
  "scrapedAt": "2026-10-05T10:00:04.438Z",
  "searchedWhere": "entityid is not null AND entityformdate >= '2026-09-28T00:00:00'"
}
```

`officialSearchUrl` is the state's own search page, where you can enter the registration number to see the official record. `searchedWhere` is the exact query sent to the state portal.

Rows that are not a business have another `status` and a `note` in plain words, and are never charged: `no-businesses`, `no-new-businesses`, `baseline-saved`, `registration-number-not-found`, `limit-reached`, `budget-reached`, `not-read`, `search-too-broad`, `source-unreadable`, `source-blocked`, `invalid-input`.

### Pricing

Pay per event: you pay for each business row returned (`business-returned`), and one small `search-checked` event for a monitoring run that found nothing new. Notes, errors and first monitoring runs are free. There is no start fee. Set a maximum total charge on the run to cap the spend; the Actor stops inside it and says what was left out.

### Personal data

Business registrations are public records, and they name people: registered agents are often private individuals with a home address, and Connecticut publishes a business email address. `includePeople: false` leaves these out. If you keep them, you are responsible for using them lawfully (for example CAN-SPAM and state privacy laws for outreach).

### Limits

- Three states only. No officers, filing history or documents: the states do not publish them in these datasets.
- New York lists active businesses only, so a looked-up number that has been dissolved comes back as not found.
- The Actor sends at most one request per second, one at a time, as the portals' robots.txt asks.
- This Actor is not affiliated with any state agency.

### Thanks for using this Actor

We build these tools for people who run them every day, and we improve them from what users tell us.

- **Missing a field, or need another filter?** Tell us in the **Issues** tab. If the data is there, we add it.
- **Found a bug or a wrong value?** Post the run ID in the **Issues** tab. Wrong data is the thing we fix first.

If this Actor saved you time, a short review helps other people find it.

# Actor input Schema

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

States to read: NY (New York), CO (Colorado), CT (Connecticut). One per line. Leave empty for all three. New York describes its dataset as posted monthly; on 2026-10-05 it held registrations up to the day before. Other states are not covered; Florida is in the separate Actor neverempty/florida-sunbiz-scraper.

## `registeredInLastDays` (type: `integer`):

Keep businesses whose registration date is within this many days before today (UTC). The states publish about once a day and the newest one or two dates are still filling in. Leave empty for no lower date. Not used in monitoring mode.

## `registeredFrom` (type: `string`):

Keep businesses registered on or after this date (YYYY-MM-DD). If "Registered in the last N days" is also set, the later of the two dates is used. Not used in monitoring mode.

## `registeredTo` (type: `string`):

Keep businesses registered on or before this date (YYYY-MM-DD). Not used in monitoring mode.

## `entityKinds` (type: `array`):

Keep these kinds. Each state names its entity types differently; the README lists which state types fall under each kind. The state's own type is always in the row as entityType. Leave empty for every kind.

## `nameContains` (type: `array`):

Keep businesses whose name contains any of these words or phrases (not case-sensitive). One per line. With no date filter this is a name search across the whole registry data of the state.

## `cities` (type: `array`):

Keep businesses in these cities (exact city name, not case-sensitive). Colorado: principal address city. Connecticut: business address city. New York: city of the address for service of process, which is not always where the business is.

## `statuses` (type: `array`):

Keep businesses with these statuses (exact, not case-sensitive), for example Active for Connecticut or Good Standing for Colorado. New York data has no status: it lists active businesses only, so this filter is not applied to New York.

## `includeRejected` (type: `boolean`):

Connecticut data includes filings the state rejected (status Rejected, about 5% of recent rows). They are left out unless you turn this on or name Rejected in "Statuses". Lookups by registration number always return the record as it is.

## `maxBusinesses` (type: `integer`):

Stop after this many business rows in total. With several states the number is shared evenly between them. Not used in monitoring mode, which returns every new business.

## `registrationNumbers` (type: `array`):

Look up businesses by registration number instead of searching: Colorado entity ID, New York DOS ID, Connecticut account number. Each number is looked up in the states set above. The search filters are not used.

## `monitoringMode` (type: `boolean`):

Return only businesses that were not there at the previous monitoring run with the same states and filters. The first run remembers what is listed and returns no business row. Compares the registration numbers of the last 30 days, so businesses added late under an earlier date are still returned.

## `resetMonitoringState` (type: `boolean`):

Forget what earlier monitoring runs with these states and filters remembered, and start again with a first run.

## `includePeople` (type: `boolean`):

Include the registered agent (often a private person, with address) and, for Connecticut, the business email address. These are public registry records; you are responsible for how you use personal data. Turn off to leave them out.

## Actor input object example

```json
{
  "states": [
    "NY"
  ],
  "registeredInLastDays": 7,
  "includeRejected": false,
  "maxBusinesses": 200,
  "monitoringMode": false,
  "resetMonitoringState": false,
  "includePeople": true
}
```

# Actor output Schema

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

One row per business from the state registry data: state, registration number, business name, entity type, registration date, status, addresses, registered agent and the date the state last updated its data. Runs that could not read a registry, found no business or no new business, or hit a limit return a row that says so and is not charged.

# 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": [
        "NY"
    ],
    "registeredInLastDays": 7
};

// Run the Actor and wait for it to finish
const run = await client.actor("neverempty/us-new-business-registrations-monitor").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": ["NY"],
    "registeredInLastDays": 7,
}

# Run the Actor and wait for it to finish
run = client.actor("neverempty/us-new-business-registrations-monitor").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": [
    "NY"
  ],
  "registeredInLastDays": 7
}' |
apify call neverempty/us-new-business-registrations-monitor --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,neverempty/us-new-business-registrations-monitor"
        }
    }
}
```

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/1oY3Q1eWhuOKJphCk/builds/gFKYQcTWFWTVv8NB2/openapi.json