# US New Business Registrations (`cpt_engineering/us-business-registrations-open-data`) Actor

Newly registered LLCs, corporations and nonprofits from Colorado, Connecticut, New York, Oregon, Pennsylvania and Texas, plus Secretary of State business entity search (KYB) by name or ID. Official state open data, one schema, no personal names.

- **URL**: https://apify.com/cpt_engineering/us-business-registrations-open-data.md
- **Developed by:** [Christopher Tolentino](https://apify.com/cpt_engineering) (community)
- **Categories:** Lead generation, Business, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.40 / 1,000 entity 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

## US New Business Registrations (State Open Data)

Get a **daily or weekly list of newly registered US businesses** (new LLCs, corporations, nonprofits and partnerships) and run a **Secretary of State business entity search (KYB lookup) by company name or state ID** across **6 official state registries: Texas, Pennsylvania, New York, Colorado, Connecticut and Oregon**. Every state comes back in **one normalized schema** (JSON, CSV, Excel), ready for spreadsheets, CRMs, data pipelines and AI agents.

**Last verified:** 2026-10-16 (daily automated self-test against the live state sources).

**Who it's for**

- **B2B sales and data teams** that want new companies as soon as the state publishes them.
- **Market research and local-economy analysts** tracking business formation by state, county, ZIP and entity type.
- **KYB, compliance and onboarding** teams checking that a company is registered, with its state ID, type, status and formation date.
- **Local service businesses and agencies** (accountants, bookkeepers, web designers, B2B suppliers) building a list of new companies in their own city or ZIP codes.
- **Banks, payment processors and business lenders** that want a weekly list of newly formed companies to offer accounts, card processing or first credit lines.

**Why this Actor**

- **Official state open-data APIs only**: no web scraping, no logins, no proxies, so runs are fast (seconds) and reliable.
- **New this week in one click**: the default input returns entities formed in the last 7 days. Schedule it and turn on *Only new since last run* to get only what's new each time, including filings the state publishes late.
- **Entity-level data only**: no names of people, no home addresses by default (see *Data and privacy*).
- **Works with the Apify MCP server**, so AI agents can call it as a tool. Every input field has a plain, machine-readable description.

**Why choose this Actor**
| | |
|---|---|
| Reliability | 37 of 37 runs succeeded since launch (Oct 15-16, 2026); a state outage is reported per state in the run summary, other states still return; every request retries timeouts, 429 and 5xx errors with exponential backoff (up to 6 attempts) |
| Sources | 6 official state registry open-data APIs (TX, PA, NY, CO, CT, OR), one schema |
| Repeat use | *Only new since last run* returns each new entity once and catches filings a state publishes late |
| Filters | State, entity type, domestic/foreign, ZIP prefix, city |
| Compliance | Entity-level data only: no owner, officer or individual-agent names, no home street lines by default |
| Audit trail | Every row links to the official state record (`record_url` / source dataset) |
| Price | $3.00 per 1,000 records, no start fee, empty runs cost nothing |

### Quick start

**New this week (default input):**

```json
{ "mode": "newFilings", "states": ["CO", "CT", "NY", "OR", "PA", "TX"], "lastNDays": 7, "maxResults": 100 }
```

**Weekly new-business list in 2 minutes**

1. Click **Save as a new task** with *Formed in the last N days* = 7, *Only new since last run* = on, and *Max results* high enough for your states (e.g. 20,000).
2. Add a **schedule** (for example Mondays 9:00) to the task.
3. Export the dataset as CSV or Excel, or connect an Apify integration (Google Sheets, webhooks, Zapier, Make).
   **Deliver it automatically:** add a webhook on the task for `ACTOR.RUN.SUCCEEDED` (to your endpoint, Zapier, Make or n8n), or pull the latest results from `https://api.apify.com/v2/actor-tasks/<TASK_ID>/runs/last/dataset/items?format=csv&status=SUCCEEDED`.
   Each run returns only entities the task hasn't returned before. For a daily list, use *Formed in the last N days* = 1 and a daily schedule.

**New businesses in your area:** add ZIP codes (or ZIP prefixes) or cities:

```json
{ "mode": "newFilings", "states": ["CO"], "lastNDays": 30, "zipCodes": ["802"], "maxResults": 500 }
```

**Backfill a date range:** set *Formed on or after*, e.g. `2026-09-01`.

**Company lookup:**

```json
{ "mode": "lookup", "names": ["acme robotics"], "entityIds": ["CO:20261234567", "TX:0806661893"] }
```

IDs without a state prefix are tried in every selected state. `maxResults` caps the total and is split evenly across the selected states.

**Verifying a list of companies (KYB)?** Use [US Company Lookup & KYB Verification](https://apify.com/cpt_engineering/us-company-lookup-kyb): one result per name with a match score, fuzzy name matching, NOT_FOUND rows and pay-per-lookup pricing.

### What you get

| Field | Description |
|---|---|
| `state` | Registry state (CO, CT, NY, OR, PA, TX) |
| `entity_id` | State-assigned entity or file number |
| `entity_name` | Registered name |
| `entity_type` | Normalized: LLC, CORPORATION, NONPROFIT, PARTNERSHIP, OTHER |
| `entity_type_raw` | Type as filed |
| `domestic` | `true` if formed in that state, `false` if a foreign (out-of-state) registration |
| `jurisdiction_of_formation` | State or country of formation, where published |
| `status` | Status as reported (NY, OR, PA and TX datasets list active entities only) |
| `formation_date` | Formation/registration date, YYYY-MM-DD |
| `principal_city`, `principal_state`, `principal_zip` | Principal office location as filed (TX: taxpayer address on file with the Comptroller) |
| `principal_street` | Street line, only when *Include street line* is on (default off; never for TX) |
| `county` | NY and PA |
| `naics`, `naics_description` | Industry code where filed (CT, some TX) |
| `registered_agent_organization` | Commercial or organizational registered agent (CO, OR); individual agents are never returned |
| `record_url` | State record page where the dataset provides one (OR) |
| `source_dataset_url`, `retrieved_at` | Provenance |

The run also saves `RUN_SUMMARY` with results per state and **the newest formation date each state has published so far**, so you can see each state's publishing lag.

#### Example

```json
{
  "state": "TX",
  "entity_id": "0806661893",
  "entity_name": "BLUEBIRD CREEK FARMS LLC",
  "entity_type": "LLC",
  "entity_type_raw": "CL (Texas limited liability company)",
  "domestic": true,
  "jurisdiction_of_formation": "TX",
  "status": "Active",
  "formation_date": "2026-08-31",
  "principal_city": "DAYTON",
  "principal_state": "TX",
  "principal_zip": "77535",
  "source_dataset_url": "https://data.texas.gov/d/9cir-efmm"
}
```

### Coverage and freshness

| State | Source dataset | How fresh | Notes |
|---|---|---|---|
| Colorado | Business Entities in Colorado (Colorado Dept. of State, data.colorado.gov 4ykn-tg5h) | Daily | All statuses; filings with a future effective date appear once that date arrives |
| Connecticut | Business Registry - Business Master (Secretary of the State, data.ct.gov n7gp-d28j) | Daily | Rejected filings excluded |
| New York | Active Corporations (NYS Dept. of State, data.ny.gov n9v6-gdp6) | Daily in practice | Active entities only; street line usually not available |
| Oregon | Active Businesses - ALL (Oregon SOS, data.oregon.gov tckn-sxa6) | Weekly | Active entities only; assumed business names (DBAs) excluded |
| Pennsylvania | Registered Businesses in PA (PA Dept. of State, data.pa.gov xvd7-5r2c) | Published about every 1-2 weeks; newest records ~2 weeks old | Active registrations only; one record per filing number |
| Texas | Active Franchise Taxpayers (Texas Comptroller, data.texas.gov 9cir-efmm) | Weekly; most new charters appear 3-5 weeks after the charter date | Secretary of State-registered entities only; sole proprietors and general partnerships of individuals excluded |

Because PA and TX publish late, a "last 7 days" run returns few or no PA/TX records. Use *Formed in the last N days* = 45 for a full recent TX/PA list, or schedule with *Only new since last run* on: the Actor re-checks recent dates and returns late-published filings it hasn't given you yet.

### Pricing

Pay per result: **$0.003 per entity record** ($3.00 per 1,000) saved to the dataset. No start fee, and empty runs cost nothing. Apify Store discount tiers pay less per record:

| Apify Store discount tier | Per 1,000 records |
|---|---|
| No discount (Free / starter) | $3.00 |
| Bronze | $2.80 |
| Silver | $2.60 |
| Gold | $2.40 |

| Records | Price (no discount) |
|---|---|
| 100 | $0.30 |
| 1,000 | $3.00 |
| 10,000 | $30.00 |

Set *Max results* to cap what a run can cost.

### Data and privacy

This Actor deliberately returns **entity-level data only**:

- **Never returned:** names of individuals (members, managers, officers, organizers, incorporators, individual registered agents, service-of-process addressees), their addresses, mailing addresses, email addresses and owner-demographic flags. These columns are never even downloaded.
- **Pennsylvania:** the state file repeats each business once per officer/organizer with that person's name; only entity columns are requested and the repeats are merged, so one record per business comes back with no names.
- **Texas:** only entities registered with the Secretary of State; sole proprietorships and partnerships of individuals are excluded. The taxpayer street address is never downloaded (city/state/ZIP only).
- **Assumed business names / DBAs (Oregon)** are excluded, since they are often sole proprietors.
- **New York:** the city/state/ZIP of the service-of-process address is used when no physical location is filed; its street line and addressee are never returned.
- **Principal office street line is off by default**: you get city/state/ZIP. Turn on *Include street line* to also get the street as filed (some small businesses list a home address).

You are responsible for using the data lawfully, including anti-spam, telemarketing and privacy laws that apply to any outreach you do.

### FAQ

**Is this a Secretary of State business search?** Yes, for the six states listed. The data comes from each Secretary of State's (or, for Texas, the Comptroller's) official open-data publication, so lookups return the same entity ID, type, status and formation date the state publishes. For states not listed, use that state's own search.

**How do I get only new businesses every day or week?** Save your input as a task, turn on *Only new since last run*, and add a schedule. Each run returns only entities that task has not returned before, including filings a state publishes late.

**Why are some states behind?** Each state publishes on its own schedule (see *Coverage and freshness*). The run summary shows the newest formation date each state has published.

**Does it include owner names, emails or phone numbers?** No. It returns entity-level data only (see *Data and privacy*).

**Can AI agents use it?** Yes. It works through the Apify MCP server and the Apify API, the input fields are described for automated use, and you pay only per returned record.

**How do I call it from code?** Use the Apify API or client libraries (see the *API* tab on this page). Example: `POST https://api.apify.com/v2/acts/cpt_engineering~us-business-registrations-open-data/run-sync-get-dataset-items` with the JSON input as the body.

### Related Actors

- [Company Due Diligence Check](https://apify.com/cpt_engineering/company-due-diligence-check): one row per company with registry status, UCC liens, OFAC sanctions and SAM.gov exclusions screens plus risk flags.
- [US Company Lookup & KYB Verification](https://apify.com/cpt_engineering/us-company-lookup-kyb): bulk-verify company names or registry IDs against the same six state registries.
- [Form D Filings Feed](https://apify.com/cpt_engineering/form-d-private-offerings-feed): new US private offerings (Reg D) from official SEC data.
- [UCC Lien Filings](https://apify.com/cpt_engineering/ucc-lien-filings): new UCC-1 financing statements, liens lapsing soon and lien checks by company name (CO, CT, OR).

### Limitations

- Coverage is limited to states that publish registrations as open data through an official API. Florida and others are not included because their bulk files are not available through an open API.
- Data is as published by each state, with no enrichment (no phones or emails).
- Not affiliated with, endorsed by, or sponsored by any state government.

### Support

Open an issue on this Actor or email **cpt-datatools@mail.grokbot.com**. We reply to issues and support emails within 1 business day.

### Changelog

- **Oct 16, 2026 (night):** daily automated self-test with source schema-change detection; *Last verified* line; support response promise.
- **Oct 16, 2026:** "Why choose" summary, webhook and API delivery notes; discount tiers (Bronze/Silver/Gold).
- **Oct 15, 2026:** launched: CO, CT, NY, OR, PA, TX registries, new-filings feed and lookup, *Only new since last run*.

### Source data disclaimer

The data made available here has been modified for use from its original source, which is the State of Colorado. THE STATE OF COLORADO MAKES NO REPRESENTATIONS OR WARRANTY AS TO THE COMPLETENESS, ACCURACY, TIMELINESS, OR CONTENT OF ANY DATA MADE AVAILABLE THROUGH THIS SITE. THE STATE OF COLORADO EXPRESSLY DISCLAIMS ALL WARRANTIES, WHETHER EXPRESS OR IMPLIED, INCLUDING ANY IMPLIED WARRANTIES OF MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE. The data is subject to change as modifications and updates are complete. It is understood that the information contained in the Web feed is being used at one's own risk.

New York, Oregon, Connecticut, Pennsylvania and Texas data are provided by those states "as is", without warranty of accuracy, completeness or timeliness. Pennsylvania data: Commonwealth of Pennsylvania, Department of State, via data.pa.gov. Texas data: Texas Comptroller of Public Accounts, via the Texas Open Data Portal.

# Actor input Schema

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

newFilings: return business entities (LLCs, corporations, nonprofits, partnerships) formed in a date window, oldest first. lookup: find existing entities by name and/or state-assigned ID; needs 'names' or 'entityIds'.

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

Two-letter codes of the state registries to query. Supported: CO, CT, NY, OR, PA, TX. Empty = all supported states. Freshness differs by state: CO, CT, NY daily; OR weekly; PA about 2 weeks behind; TX 3-5 weeks behind (see README).

## `lastNDays` (type: `integer`):

newFilings only. Window size in days counted back from today, e.g. 7 = new this week, 1 = since yesterday, 30 = last month. Used when 'Formed on or after' is empty and there is no saved progress from an earlier run (see 'Only new since last run').

## `sinceDate` (type: `string`):

newFilings only. Exact start date, ISO format YYYY-MM-DD, e.g. 2026-09-01. Returns entities whose formation/registration date is on or after this date and not in the future. Overrides 'Formed in the last N days' and 'Only new since last run'.

## `onlyNewSinceLastRun` (type: `boolean`):

newFilings only. true: remember what this Actor already returned to you (per state, in a named key-value store on your account) and return only entities not returned before, including late-published filings. Turn it on for scheduled daily/weekly runs and tasks. false (default): always return the full window, so test runs are repeatable. Ignored when 'Formed on or after' is set.

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

Optional filter on the normalized entity type. Allowed values: LLC, CORPORATION, NONPROFIT, PARTNERSHIP, OTHER. Empty = all types.

## `includeForeign` (type: `boolean`):

true: also return out-of-state or foreign companies newly registered to do business in the state. false: only entities formed in that state (domestic).

## `zipCodes` (type: `array`):

Optional. Keep only entities whose principal-office ZIP starts with any of these, e.g. \['80202'] for one ZIP or \['802'] for the Denver area. Applied after download, so narrow filters over long windows read more pages (still billed only per returned record). Empty = all.

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

Optional. Keep only entities whose principal-office city matches one of these exactly (case-insensitive), e.g. \['Denver', 'Boulder']. Empty = all.

## `names` (type: `array`):

lookup only. Case-insensitive 'contains' match on the registered entity name, e.g. 'acme robotics'. Several names = OR.

## `entityIds` (type: `array`):

lookup only. Exact state-assigned entity/file numbers. Prefix with the state to target one registry, e.g. 'CO:20261234567', 'NY:8042889', 'PA:0015846315', 'TX:0806661893'. Unprefixed IDs are tried in every selected state.

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

Maximum entity records returned (and charged) in total, split evenly across the selected states, e.g. 100 with 6 states = up to 17 per state. Raise it for full daily or weekly lists.

## `includeStreetAddress` (type: `boolean`):

false (default): only city, state and ZIP of the entity's principal office. true: also the street line as filed with the state (CO, CT, NY, OR, PA; never for TX). Some small businesses list a home address, so leave it off unless you need it.

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

Optional free app token from a state open-data portal. Only useful for very large pulls; not required.

## Actor input object example

```json
{
  "mode": "newFilings",
  "states": [
    "CO",
    "CT",
    "NY",
    "OR",
    "PA",
    "TX"
  ],
  "lastNDays": 7,
  "onlyNewSinceLastRun": false,
  "entityTypes": [],
  "includeForeign": true,
  "zipCodes": [],
  "cities": [],
  "names": [],
  "entityIds": [],
  "maxResults": 100,
  "includeStreetAddress": false
}
```

# Actor output Schema

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

Dataset items: one normalized business entity per item (state, entity_id, entity_name, entity_type, status, formation_date, principal_city/state/zip, ...). See the dataset schema for all fields.

## `summary` (type: `string`):

JSON record RUN_SUMMARY: results per state, newest formation date each state has published, errors per state, HTTP requests and duration.

# 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",
        "CT",
        "NY",
        "OR",
        "PA",
        "TX"
    ],
    "lastNDays": 7,
    "maxResults": 100
};

// Run the Actor and wait for it to finish
const run = await client.actor("cpt_engineering/us-business-registrations-open-data").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",
        "CT",
        "NY",
        "OR",
        "PA",
        "TX",
    ],
    "lastNDays": 7,
    "maxResults": 100,
}

# Run the Actor and wait for it to finish
run = client.actor("cpt_engineering/us-business-registrations-open-data").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",
    "CT",
    "NY",
    "OR",
    "PA",
    "TX"
  ],
  "lastNDays": 7,
  "maxResults": 100
}' |
apify call cpt_engineering/us-business-registrations-open-data --silent --output-dataset

```

## MCP server setup

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

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/s2LqRAugeXVFSq5CW/builds/PwHiuaDPsdhM2brbs/openapi.json