# US New Business Registrations - New LLC & Corp Leads (`datadeltas/us-new-business-registrations`) Actor

Daily feed of NEWLY registered LLCs and corporations from official state business registers (open data, no scraping). Filter by state, entity type, name keyword or NAICS industry. Emits only entities it has never seen - schedule it and feed your B2B lead pipeline.

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

## Pricing

from $3.00 / 1,000 new registration detecteds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.
Actors are written with capital "A".

## 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.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

## US New Business Registrations Feed — New LLC & Corp Leads

Every business that registered with **Colorado, New York, Connecticut or
Oregon** in the last few days, pulled from each state's own official open-data
business register and normalised into one schema. Run it on a schedule and each
run gives you **only the entities it has never seen before** — a clean daily
list of brand-new companies, not a re-download of the whole register.

No API keys. No login-walled Secretary-of-State search portals. Every source is
the state's own published open data.

### What makes this different from a business-entity search scraper

Most "Secretary of State" actors are **lookup** tools: you type a company name,
they return that company. Useful for KYB, useless for prospecting. This is a
**monitor**: it remembers what it has already delivered (per-state watermark +
seen entity ids in a named key-value store) and emits the delta. Schedule it
daily and you pay only for genuinely new registrations.

### Example output (one real record, trimmed)

```json
{
  "state": "ct",
  "entityId": "3507270",
  "name": "Rapid Northeast Transport LLC",
  "entityType": "llc",
  "entityTypeRaw": "LLC",
  "registrationDate": "2026-08-30",
  "status": "Active",
  "principalCity": "Stonington",
  "principalState": "CT",
  "zipCode": "06379",
  "naicsCode": "484110",
  "naicsDescription": "General Freight Trucking, Local",
  "sourceUrl": "https://data.ct.gov/resource/n7gp-d28j.json?accountnumber=3507270",
  "detectedAt": "2026-09-01T06:58:12Z"
}
```

### State coverage (honest version)

Measured live on 1 September 2026. "New per week" is entities with a
registration date in the previous 7 days.

| State | Register | New/week | Refresh | Status | Industry code (NAICS) |
|---|---|---|---|---|---|
| Colorado | Business Entities in Colorado | ~3,400 | Daily | ✅ published | ✗ |
| New York | Active Corporations (DOS) | ~4,000 | Daily | — not published | ✗ |
| Connecticut | CT Business Registry — Business Master | ~875 | Daily | ✅ published | ✅ ~99% of records |
| Oregon | Active Businesses — ALL | ~1,800 | **Weekly** | — not published | ✗ |

**Read this before you schedule it:** Oregon's register refreshes about once a
week and lands with a few days' lag, so at the default `sinceDays=7` an Oregon
refresh can fall outside the window. **If you want reliable Oregon coverage,
set `sinceDays` to 14.** Colorado, New York and Connecticut are same-day
reliable at the default.

**Why only four states?** There is no federal register — each of the 50 states
publishes (or doesn't) on its own terms, which is exactly why this data is hard
to buy. These four publish entity-level registrations as a live open-data API.
We deliberately do **not** scrape login-walled or CAPTCHA'd Secretary-of-State
search portals: it breaks constantly and we would rather ship four states that
work every morning. States we checked and could not ship yet: **Pennsylvania**
(publishes, but only as a monthly snapshot ~1 month behind), **Hawaii** (dataset
frozen since 2022), **Washington, Vermont, Maryland, Iowa** (no entity-level
register published at all). More states get added as they publish — see the
changelog.

### Input options

| Field | Type | Default | What it does |
|---|---|---|---|
| `states` | array | all four | Which registers to check. |
| `entityTypes` | array | all | `llc`, `corp` (profit/nonprofit/benefit/stock) or `other` (partnerships, assumed business names, co-ops). The register's own wording is always kept in `entityTypeRaw`. |
| `nameContains` | string | — | Only names containing this text, case-insensitive. `solar`, `dental`, `trucking`, `realty`. |
| `naicsOrPurposeKeywords` | array | — | Only entities whose published industry classification matches a keyword or NAICS code (`trucking`, `484110`). **Only Connecticut publishes an industry code, so setting this excludes every other state.** |
| `sinceDays` | int | 7 | How many days back to scan. Your first run is the backfill; later runs emit only what is new. Use 14+ for Oregon. |
| `maxItems` | int | 1000 | Cap per run, split **fairly** across the states you selected, so a small cap never gives you one state and nothing else. Anything over the cap carries over to the next run. |
| `stateStoreName` | string | `us-new-business-registrations-state` | Named key-value store holding the watermarks and seen ids. Change it to reset the monitor and re-emit the backfill. |

This is a **standing-subscription feed**: set your filters once and schedule
it. An entity your filter rejected is recorded as already inspected, so
broadening the filter later never re-bills you for old registrations — and, by
the same token, running a *different* one-off query against the same
`stateStoreName` will not re-surface entities the earlier one rejected. Give
each standing query its own store name.

Note on your first run: a 7-day backfill across all four states is roughly
8,000 registrations, above the default `maxItems` of 1000. The cap is honoured,
and the remainder carries over run by run in date order — nothing is skipped.
Raise `maxItems` if you want the whole backfill at once.

### Use cases

**"Every new LLC in Colorado this morning, in my CRM by 9am."** Schedule daily
with `states: ["co"]`. New companies need banking, insurance, payroll,
bookkeeping, a website and a phone system — and nobody has called them yet.
Registration day is the highest-intent moment in a B2B funnel.

**"Only new Connecticut trucking and construction companies."** Set
`states: ["ct"]` and `naicsOrPurposeKeywords: ["trucking", "construction"]`.
Connecticut publishes a NAICS code on ~99% of registrations, so you get an
industry-targeted lead list instead of an alphabet soup of new LLCs.

**"Every new solar or HVAC business across all four states."** Set
`nameContains: "solar"` (then a second scheduled run for `hvac`). Suppliers,
franchisors, equipment financiers and trade insurers use this to find new
competitors and new customers the week they form.

**"Feed our KYB/data product with fresh entities."** The record is stable and
documented (`RegistrationV1` in `openapi.yaml`), one schema across four
registers, with `sourceUrl` back to the state's own row for verification.

### What we deliberately do NOT collect

Every one of these registers publishes more than this actor returns. We take
the entity's identity plus a **city/state/zip locality — never a street
address**, because a one-person LLC's principal address is frequently the
founder's home and nothing in the source data flags it. We also never collect
registered-agent or officer **personal names**, and never the **business email
address** Connecticut publishes. If you need agent or officer detail for a
specific entity, `sourceUrl` takes you to the state's own record.

### Maintenance

- Schema checked weekly against all four registers; a portal that changes a
  field name logs one clear warning and keeps the other states running.
- One state's register being down degrades to a warning and leaves that state's
  position untouched — the other states still deliver, and nothing is skipped
  when it comes back. If *every* register fails the run fails loudly rather
  than reporting a quiet day.

### Pricing (pay per event)

| Event | Price |
|---|---|
| Actor start | $0.005 per run |
| New registration detected | $0.003 per entity |
| State register checked | $0.001 per state |

A daily run across all four states at steady state is roughly 1,200
registrations — about **$3.65/day** if you take everything, and much less with
filters, because you are only charged for registrations that pass them.

### Changelog

- **0.1** (1 Sep 2026) — first release: Colorado, New York, Connecticut,
  Oregon. Next up: Pennsylvania (needs a wider window for its monthly
  snapshot), then any state that starts publishing.

# Actor input Schema

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

Which state business registers to check. Default: all of them.

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

Only emit these normalised entity types (the register's own wording is always kept in entityTypeRaw). 'other' covers partnerships, assumed business names, co-operatives and trusts. Leave empty for all.

## `nameContains` (type: `string`):

Only emit entities whose registered name contains this text (case-insensitive). Handy for a vertical: 'solar', 'dental', 'trucking', 'realty'.

## `naicsOrPurposeKeywords` (type: `array`):

Only emit entities whose published industry classification matches one of these keywords or NAICS codes (e.g. 'trucking', '484110'). IMPORTANT: only Connecticut publishes an industry code, so setting this excludes every other state's registrations.

## `sinceDays` (type: `integer`):

How many days of registrations to scan. On the first run this is your backfill; on later runs only entities not seen before are emitted. Oregon's register refreshes weekly, so use 14+ if you want reliable Oregon coverage.

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

Cap on new registrations emitted in a single run (cost control). The cap is split fairly across the states you selected; anything over it is picked up on the next run.

## `stateStoreName` (type: `string`):

Named key-value store holding per-state watermarks and seen entity ids. Change it to reset the monitor and re-emit the backfill. Use a SEPARATE store name per standing filter set: entities that one filter rejected are recorded as already inspected, so a different filter against the same store will not re-surface them.

## Actor input object example

```json
{
  "states": [
    "co",
    "ny",
    "ct",
    "or"
  ],
  "sinceDays": 7,
  "maxItems": 1000,
  "stateStoreName": "us-new-business-registrations-state"
}
```

# Actor output Schema

## `records` (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("datadeltas/us-new-business-registrations").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("datadeltas/us-new-business-registrations").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 datadeltas/us-new-business-registrations --silent --output-dataset

```

## MCP server setup

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

```

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/GzIX2TlaNFCsohgf2/builds/rw2zJcWgberIXTnKo/openapi.json