# New Business Filings Feed: CO, NY, CT & OR Registrations Daily (`upward_enterprises/new-business-filings-feed`) Actor

Every newly registered business in Colorado, New York, Connecticut and Oregon from the states' official open-data registries: name, entity type, formation date, address, registered agent (formation services flagged), NAICS and email where published. Only new rows on schedules. From $0.60 per 1,000.

- **URL**: https://apify.com/upward_enterprises/new-business-filings-feed.md
- **Developed by:** [Upward Enterprises](https://apify.com/upward_enterprises) (community)
- **Categories:** Lead generation, Automation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.60 / 1,000 new business filings

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 Filings Feed: CO, NY, CT & OR Registrations Daily

**$1 per 1,000 new businesses ($0.60 on the Gold tier), no start fee, no API key. On a schedule, only businesses you have not received before are billed.**

Every business that registers with a Secretary of State becomes a public record within a day or three, and the states that publish those records as open data are the cleanest source of brand-new companies there is: no portal scraping, no CAPTCHAs, no stale lists. This Actor reads the official open-data registries of Colorado, New York, Connecticut and Oregon, normalizes them into one row per entity, flags whether the registered agent is a formation service (so you can tell a real founder from a LegalZoom order), and keeps the NAICS code and business email that Connecticut publishes with each record. Run it daily and pipe the rows into a CRM, a mailing list, or an agent.

### What you get

**Entity rows** (`kind: "entity"`), one per newly registered business, newest first:

```json
{
  "kind": "entity",
  "state": "CT",
  "stateName": "Connecticut",
  "entityId": "3513698",
  "name": "Dr Elite Construction Group LLC",
  "entityType": "LLC",
  "entityClass": "LLC",
  "domestic": true,
  "jurisdiction": "Connecticut",
  "formationDate": "2026-09-09",
  "status": "Active",
  "address": { "street": "28 Cleveland St", "city": "New London", "state": "CT", "zip": "06320", "country": "United States" },
  "city": "New London",
  "zip": "06320",
  "county": null,
  "naicsCode": "236118",
  "naicsDescription": "Residential Remodelers",
  "businessEmail": "owner@example.com",
  "ownership": { "womanOwned": false, "veteranOwned": false, "minorityOwned": false, "disabilityOwned": false, "lgbtqOwned": false },
  "agentName": null,
  "agentKind": null,
  "sourceUrl": "https://service.ct.gov/business/s/onlinebusinesssearch",
  "publisher": "Connecticut Secretary of the State",
  "dataset": "https://data.ct.gov/resource/n7gp-d28j.json",
  "fetchedAt": "2026-09-10T12:00:00.000Z"
}
```

`entityClass` normalizes each state's labels to LLC, Corporation, Nonprofit, Partnership, Assumed name, or Other; `entityType` keeps the state's own label or code. `domestic` is true for entities formed in the state (the new businesses) and false for out-of-state entities registering there. `agentKind` is `formation-service` (Northwest, LegalZoom, ZenBusiness, CSC, law and accounting firms), `organization`, or `individual`; agent street addresses are not included. What each state publishes:

| State | Formation date lag | Address | Registered agent | Extra fields |
|---|---|---|---|---|
| Colorado | about 3 days | principal office | name and kind | status (Good Standing) |
| New York | 1 day | principal office when given, else city and ZIP of the process address | name and kind | county, service-of-process name and locality |
| Connecticut | 1 day | business address | not published | NAICS code and description, business email, ownership flags, annual report due date |
| Oregon | 1 to 2 days | principal place of business, mailing address | name and kind | assumed business names (DBAs), link to the state record |

**One summary row** (`kind: "summary"`, free) reports, per state, how many rows and entities were read, the newest formation date seen (so you can watch each state's publishing lag), and any state that failed, plus how many rows were skipped as already delivered, out-of-state, or by your filters, and whether the run stopped at your spending cap. A state that fails never fails the run; the others are still delivered.

Filter on `kind` to keep one row type; the Console view **New businesses** shows the useful columns.

### Input

| Field | What it does |
|---|---|
| States | Any of CO, NY, CT, OR. |
| Formed within (days) | Look-back by formation date. Default 4, which with the "only new" memory covers every state's publishing lag (Colorado about three days) without double billing. |
| Entity classes | LLC, Corporation, Nonprofit, Partnership, Assumed name, Other. Empty means all. |
| Domestic entities only | Default on. Off adds out-of-state entities registering to do business. |
| Skip formation-service agents | Default off (they are flagged, not skipped). |
| Name keywords, ZIP prefixes | Any-match filters on the entity name and the principal address ZIP. |
| Counties (NY), NAICS prefixes (CT) | Filters on fields only those states publish; rows from other states pass untouched. |
| Only new since last run | Default on. Remembers what each snapshot name has delivered (90 days) and skips it next time. |
| Snapshot name | Which memory "only new" uses; kept on your account as a key-value store named `new-business-filings-feed-<name>`. Give each schedule its own name. |
| Max entities per run | Default 2,000, newest first. |
| Socrata app token | Optional; a free token from any of the portals raises their request limits. |

Examples:

```json
{ "states": ["CO", "NY", "CT", "OR"] }
```

Every new domestic business in four states, daily: the default.

```json
{ "states": ["CT"], "naicsPrefixes": ["23", "238"], "entityClasses": ["LLC", "Corporation"] }
```

New Connecticut construction companies, with their business email.

```json
{ "states": ["NY"], "counties": ["Kings", "Queens", "New York", "Bronx", "Richmond"], "excludeFormationServiceAgents": true }
```

New York City registrations where the founder, not a formation service, is the agent.

### Pricing

| Event | Free | Bronze | Silver | Gold and above |
|---|---|---|---|---|
| New business filing | $0.001 | $0.0009 | $0.00075 | $0.0006 |

The four states register roughly 1,200 domestic businesses on a business day (New York about 600, Colorado 350, Oregon 150, Connecticut 130), so the full four-state daily feed costs about $1.20 a day, around $25 a month, and a single state or a NAICS-filtered feed a fraction of that. The summary row is free, and so is an empty run. Set a maximum total charge on the run to cap spend; the Actor stops cleanly when it is reached and never delivers rows it could not bill.

### Use cases

- **Local services and B2B onboarding**: banks, insurers, payroll, web design, accounting and signage firms reach a new company in its first week, before anyone else.
- **Lead lists by trade**: Connecticut's NAICS codes and Oregon's assumed names pick out contractors, restaurants, clinics, and shops as they open.
- **Market research**: formation counts by state, county, ZIP, and entity class, day by day.
- **Compliance and KYB**: confirm a counterparty was formed when it says it was, and who its registered agent is.
- **AI agents**: ask "which restaurants incorporated in Connecticut this week" through the Apify MCP server and get rows.

### Data source and limits

- Colorado: Business Entities in Colorado (data.colorado.gov, public domain). New York: Active Corporations (data.ny.gov). Connecticut: Business Registrations (data.ct.gov, public domain). Oregon: Active Businesses (data.oregon.gov). All are the states' official open-data publications of their registries, read through the Socrata API with a declared User-Agent and one request at a time per portal.
- Each state publishes on its own schedule; the summary row's `newestFormationDate` shows where each one stands. Colorado lags about three days.
- Rows carry what the state publishes about the business: name, type, dates, business address, registered agent name and locality. Street addresses of agents and of New York's service-of-process contacts are deliberately omitted. Connecticut's business email is the address the business itself filed for public contact.
- Other states (Florida, Texas, California, Iowa, and most others) do not publish comparable open data or charge for API access; they are not included. Ask if you need one, since some can be added from bulk downloads.
- At the end of each run the Actor reports run counts (rows delivered, events charged, duration, status) to its maintainer's dashboard. It never sends your input, your results, or anything about your account.

### Enjoying this Actor?

If it saved you time, please leave a review on the [Apify Store page](https://apify.com/upward_enterprises/new-business-filings-feed) — it helps other people find it. Bug reports and feature requests are welcome on the Issues tab.

### About

Built and maintained by **Upward Enterprises · AI & API Services** (Iowa, USA). Public-data tools for people and AI agents, with pay-per-record pricing and no keys to manage.

### Changelog

- **0.1** (2026-09-10): first release.

# Actor input Schema

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

Which state registries to read. Each is the state's official open-data dataset of business entities.

## `filedWithinDays` (type: `integer`):

How far back to look by formation or registration date, in calendar days before today, plus today. Default 4: Colorado publishes with a lag of about three days, the others one day, and "Only new since last run" makes overlapping windows safe.

## `entityClasses` (type: `array`):

Keep only these kinds of entity. Empty means all.

## `domesticOnly` (type: `boolean`):

On (default): only entities formed in the state, which is where the new businesses are. Off: also out-of-state entities registering to do business there.

## `excludeFormationServiceAgents` (type: `boolean`):

Off (default): every entity is delivered and the agent is flagged as formation-service, organization, or individual. On: skip entities registered through services such as Northwest Registered Agent, LegalZoom, ZenBusiness, or CSC.

## `nameKeywords` (type: `array`):

Only entities whose name contains any of these words, case-insensitive, e.g. "roofing", "dental", "consulting". Empty means every name.

## `zipPrefixes` (type: `array`):

Only entities whose principal address ZIP starts with one of these, e.g. 802 for Denver, 100 for Manhattan. Empty means anywhere.

## `counties` (type: `array`):

New York publishes the county; other states do not. Case-insensitive, e.g. Kings, Queens, Erie. Empty means all.

## `naicsPrefixes` (type: `array`):

Connecticut publishes each business's NAICS code; other states do not, and their rows pass this filter untouched. E.g. 23 (construction), 541 (professional services).

## `onlyNew` (type: `boolean`):

On (default): remember which entities each snapshot name has delivered (90 days) and skip them next time, so a schedule never bills the same business twice. Off: deliver everything in the window every run.

## `snapshotName` (type: `string`):

Which memory "only new" uses. Kept on your account as a key-value store named new-business-filings-feed-<name>. Give each schedule its own name.

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

Upper limit on delivered rows, newest first. The summary row says whether the limit cut the results.

## `socrataAppToken` (type: `string`):

A free app token from any of the four data portals raises the portals' request limits. Not needed for daily runs.

## Actor input object example

```json
{
  "states": [
    "CO"
  ],
  "filedWithinDays": 4,
  "entityClasses": [],
  "domesticOnly": true,
  "excludeFormationServiceAgents": false,
  "nameKeywords": [],
  "zipPrefixes": [],
  "counties": [],
  "naicsPrefixes": [],
  "onlyNew": true,
  "snapshotName": "default",
  "maxItems": 100
}
```

# Actor output Schema

## `all` (type: `string`):

No description

## `entityColumns` (type: `string`):

No description

## `csv` (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 = {
    "states": [
        "CO",
        "NY",
        "CT",
        "OR"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("upward_enterprises/new-business-filings-feed").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",
        "NY",
        "CT",
        "OR",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("upward_enterprises/new-business-filings-feed").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",
    "NY",
    "CT",
    "OR"
  ]
}' |
apify call upward_enterprises/new-business-filings-feed --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,upward_enterprises/new-business-filings-feed"
        }
    }
}
```

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/hhNQirkrHFCsaWI1c/builds/OwPZ2XFEQYI1geHb7/openapi.json