# New Business Filings and LLC Leads, 5 State Registries (`dynamic_jingle/new-business-filings-secretary-of-state`) Actor

Newly formed LLCs, corporations and nonprofits in Colorado, New York, Connecticut, Oregon and Texas from official Secretary of State open data. Formation date, status, addresses, registered agent, NAICS (CT, TX), and a weekly new-business monitor.

- **URL**: https://apify.com/dynamic_jingle/new-business-filings-secretary-of-state.md
- **Developed by:** [Scott Davidson](https://apify.com/dynamic_jingle) (community)
- **Categories:** Lead generation, Business
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 1,000 business records

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?

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 and LLC Leads from Secretary of State (CO, NY, CT, OR, TX)

Get **newly formed LLCs, corporations, nonprofits and partnerships** from five states in one run: **Colorado, New York, Connecticut, Oregon and Texas**. Every record comes from the state's **official open data portal** (Secretary of State, and the Texas Comptroller file that carries the Secretary of State charter date), and every state returns the **same clean fields**: business name, entity type, status, formation date, principal and mailing address, registered agent, NAICS industry code where the state publishes it, and a link to the source record.

Schedule the **New businesses monitor** weekly and you get a deduplicated feed of businesses formed since your last run, ready for Clay, HubSpot, Salesforce, Google Sheets or any CRM.

**Price:** $2 per 1,000 business records in search mode, $3 per 1,000 new-business leads in monitor mode, plus $0.001 per run. You only pay for results you get.

### What this new business scraper does

- **New LLC and corporation leads**: every business formed in the last 7, 30 or 90 days, filtered by state, city, ZIP, entity type and industry.
- **Weekly new business feed**: the monitor remembers what it already returned, so each scheduled run delivers only new filings, with no duplicates.
- **Secretary of State business search**: look up any business by name across five state registries at once.
- **Industry targeting with NAICS**: Connecticut and Texas publish NAICS codes, so you can pull only new restaurants (722), contractors (238), consultants (5416) or medical practices (621).
- **One schema for five states**: no more stitching together five different state formats.

### Who uses newly formed business data

#### Banks and credit unions

A new business needs a business checking account, a card and a loan. Pull new domestic LLCs and corporations in your branch footprint by city or ZIP every Monday and hand them to business bankers before a competitor gets there.

#### Business insurance agents

Every new company needs general liability, workers' comp and commercial auto. Filter by NAICS in Connecticut and Texas (for example 238 for trade contractors) or by name keywords like "ROOFING", "TRUCKING" or "CLEANING" in every state.

#### Payroll, PEO and HR software

New employers need payroll from day one. Schedule the monitor for your target states and send each new LLC into Clay for enrichment and an automated sequence.

#### Web design, SEO and marketing agencies

A business formed this week has no website, no Google profile and no reviews yet. The new business feed is the earliest possible list of local prospects for web, SEO and branding agencies.

#### Accountants, bookkeepers and tax firms

New entities need bookkeeping, a first tax return, sales tax setup and an S corp election. Filter by city to build a local prospect list every month.

#### Merchant services, POS and business lenders

New restaurants, retail shops and salons need card processing and equipment. Use NAICS 722 or 44-45 in Texas and Connecticut, or name keywords elsewhere.

#### KYB, compliance and market research

Confirm a company exists and is active, see when it was formed and who its registered agent is, or count new business formation by state, city and industry.

### Supported states and sources

| State | Official source | New entities per month (approx.) | Formation date | Status | Registered agent | NAICS |
|---|---|---|---|---|---|---|
| Colorado | Secretary of State, Business Entities in Colorado (data.colorado.gov), updated daily | ~14,000 | Yes | Yes (good standing, dissolved, withdrawn) | Yes | No |
| New York | Department of State, Active Corporations (data.ny.gov) | ~21,000 | Yes (initial DOS filing date) | Active entities only | Yes (or service of process address) | No |
| Connecticut | Secretary of the State, Business Registry (data.ct.gov), updated daily | ~5,000 | Yes (registration date) | Yes | No | Yes, plus business email |
| Oregon | Secretary of State, Active Businesses ALL, weekly, plus New Businesses Registered Last Month (data.oregon.gov) | ~7,000 including assumed business names | Yes (registry date) | Active, plus last month's registrations no longer active | Yes | No |
| Texas | Comptroller, Active Franchise Taxpayers with SOS charter date (data.texas.gov) | ~23,000 | Yes (SOS charter date) | Active franchise taxpayers | No | Yes |

How fresh is the data? Colorado and Connecticut update daily, New York within a few days and Oregon weekly. Texas lists a new entity once the Comptroller sets up its franchise tax account, which usually happens 2 to 4 weeks after the charter date, so for Texas use a 30 to 60 day window in search mode. The monitor's 60-day look-back catches these late Texas records automatically and returns each one once, as soon as it appears.

This Actor only reads the public open data APIs (Socrata) that each state publishes for reuse. It never touches login pages or captcha-protected search pages, it sends one request at a time and it respects each portal's crawl delay.

### Input

| Field | Type | Description |
|---|---|---|
| `mode` | `search` or `newBusinesses` | Search returns every match. The monitor returns only businesses not returned by earlier runs. |
| `states` | array | Any of `CO`, `NY`, `CT`, `OR`, `TX`. |
| `formedAfter` | date | `YYYY-MM-DD` or relative such as `7 days`. Default: last 30 days in search, last 7 days on the first monitor run. |
| `formedBefore` | date | Optional end date. |
| `entityTypes` | array | `llc`, `corporation`, `nonprofit`, `partnership`, `dba`, `other`. |
| `jurisdiction` | string | `any`, `domestic` (formed in the state), `foreign` (formed elsewhere and registered here). |
| `nameKeyword` | string | Business name contains this text. |
| `city` | string | City of the principal or mailing address. |
| `zip` | string | ZIP code or prefix, for example `787`. |
| `naicsCodes` | array | NAICS code prefixes, Connecticut and Texas only. |
| `status` | string | `active` (default), `inactive`, `any`. |
| `maxResults` | integer | Total cap across all states (default 1,000). |
| `maxResultsPerState` | integer | Cap per state. |
| `monitorId` | string | Separate memory for each scheduled feed. |
| `lookbackDays` | integer | How far back the monitor re-checks for late filings (default 60). |

#### Example: new Texas LLCs in Austin this week

```json
{
  "mode": "search",
  "states": ["TX"],
  "formedAfter": "7 days",
  "entityTypes": ["llc"],
  "jurisdiction": "domestic",
  "zip": "787"
}
```

#### Example: weekly new business feed for five states

```json
{
  "mode": "newBusinesses",
  "states": ["CO", "NY", "CT", "OR", "TX"],
  "entityTypes": ["llc", "corporation"],
  "jurisdiction": "domestic",
  "monitorId": "five-state-weekly",
  "maxResults": 5000
}
```

Save it as a task and add a weekly schedule. Each run returns only businesses the monitor has not returned before.

### Output fields

| Field | Description |
|---|---|
| `state` | Two-letter state code |
| `entityId` | State entity number (CO entity ID, NY DOS ID, CT account number, OR registry number, TX SOS file number) |
| `businessName` | Legal name |
| `entityType` | Entity type as published by the state |
| `entityTypeCategory` | Normalized: `llc`, `corporation`, `nonprofit`, `partnership`, `dba`, `other` |
| `isForeign` | `true` when formed in another state |
| `jurisdictionOfFormation` | State or country of formation where published |
| `status`, `statusCategory` | Status as published, plus normalized `active` or `inactive` |
| `formationDate` | Formation or registration date, `YYYY-MM-DD` |
| `principalAddress` | Street, city, state, ZIP, country |
| `mailingAddress` | Mailing address (New York: service of process address) |
| `registeredAgent` | Agent name and address where published |
| `naicsCode`, `naicsDescription` | Industry code (CT, TX) |
| `businessEmail` | Business email (CT) |
| `county` | County (NY) |
| `taxpayerNumber` | Texas Comptroller taxpayer number |
| `isNewBusiness`, `firstSeenAt` | Set in monitor mode |
| `sourceName`, `sourceUrl`, `registryUrl` | Official source and a link to the exact record |
| `scrapedAt` | Time of extraction |

#### Sample record

```json
{
  "state": "CO",
  "entityId": "20268253800",
  "businessName": "DiverFolio & Co, LLC",
  "entityType": "Domestic Limited Liability Company",
  "entityTypeCategory": "llc",
  "isForeign": false,
  "status": "Good Standing",
  "statusCategory": "active",
  "formationDate": "2026-10-18",
  "principalAddress": { "street": "10358 Blue Heron Ct", "city": "Highlands Ranch", "state": "CO", "zip": "80129", "country": "US" },
  "registeredAgent": { "name": "CINDY THI VAN", "city": "Highlands Ranch", "state": "CO", "zip": "80129" },
  "sourceUrl": "https://data.colorado.gov/resource/4ykn-tg5h.json?entityid=20268253800"
}
```

A `RUN_SUMMARY` record in the key-value store shows how many rows were scanned and returned per state.

### Pricing

| Event | Price |
|---|---|
| Business record (search mode) | $0.002 |
| New business (monitor mode) | $0.003 |
| Run start | $0.001 |

Example: a weekly five-state monitor for domestic LLCs and corporations returns roughly 10,000 to 15,000 new businesses a week across all five states, about $30 to $45. Filter by city, ZIP, NAICS or entity type to pay only for your territory, and use `maxResults` to cap any run.

### Use with Clay, Zapier, Make and n8n

Call the Actor from Clay's Apify integration, from Zapier, Make or n8n, or from the Apify API, then enrich each new business with a website, phone and owner contact. Because results are structured JSON with a stable schema, AI agents and MCP clients can run it too.

### FAQ

**Is this data legal to use?** Business entity filings are public records. Each state publishes these datasets on its official open data portal for public reuse (Colorado and Connecticut mark them public domain; Oregon law places portal data in the public domain; New York's OPEN-NY terms allow any lawful use). You are responsible for how you use the data, including following CAN-SPAM, TCPA and similar outreach rules.

**Why are some addresses or agents missing?** The Actor returns exactly what each state publishes. New York often lists only a service of process address, and Texas and Connecticut do not publish registered agents in these datasets.

**Why do New York and Texas show active entities only?** Those official datasets list active entities. Dissolved entities drop out.

**Can I add other states?** More states will be added where an official open data source exists. Tell us which state you need in the Issues tab.

**Why is the first run slower?** The first run in a look-back window can take about 2 to 3 minutes because it reads the full window from each state. Later runs are faster.

**Does the monitor send the same business twice?** No. The monitor remembers every business it has returned for each `monitorId` within the look-back window.

# Actor input Schema

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

Use "search" to export every business matching your filters, for example all LLCs formed in Colorado since October 1. Use "newBusinesses" for a scheduled lead feed: each run returns only businesses that were not returned by earlier runs with the same Monitor ID. The first monitor run returns businesses formed since "Formed on or after" (default: last 7 days).

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

Two-letter codes of the states to include. Supported: CO, NY, CT, OR, TX. Example: \["TX", "CO"].

## `formedAfter` (type: `string`):

Only businesses formed or registered on or after this date. Use YYYY-MM-DD ("2026-10-01") or a relative value ("7 days", "2 weeks", "1 month"). Leave empty for the last 30 days in search mode (or the whole registry when you search by name), and the last 7 days on the first monitor run.

## `formedBefore` (type: `string`):

Optional end date, YYYY-MM-DD or relative. Example: "2026-09-30" to export September only. Default: today.

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

Return only these normalized entity types. Example: \["llc", "corporation"] for for-profit leads. Leave empty for all types.

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

Domestic entities are brand-new businesses formed in the state. Foreign entities are existing out-of-state companies expanding into it. Example: "domestic" for brand-new small business leads, "foreign" for companies entering a new state.

## `nameKeyword` (type: `string`):

Return only businesses whose name contains this text (case-insensitive). Examples: "ROOFING", "DENTAL", "HOLDINGS", "PIZZA".

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

Exact city name of the principal or mailing address (case-insensitive). Example: "Denver", "Austin", "Brooklyn".

## `zip` (type: `string`):

ZIP code or ZIP prefix of the principal or mailing address. Example: "78701" for one ZIP or "787" for the Austin area.

## `naicsCodes` (type: `array`):

Return only businesses whose NAICS industry code starts with one of these codes. Connecticut and Texas publish NAICS; other states are skipped when this is set. Examples: "238" (specialty trade contractors), "5416" (consulting), "722" (restaurants), "621" (healthcare practices).

## `status` (type: `string`):

Filter by normalized status. New York and Texas publish active entities only. Example: "active" for lead lists.

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

Stop after this many results across all states, to control cost. Example: 100 for a sample, 0 for no limit. In monitor mode, businesses over the limit stay "new" and are returned by the next run.

## `maxResultsPerState` (type: `integer`):

Cap per state so one big state (New York and Texas file about 1,000 new entities a day) does not use the whole budget. Example: 200. 0 means no per-state cap.

## `monitorId` (type: `string`):

Name of the monitor's memory of businesses already returned. Use a different ID for each scheduled feed. Example: "tx-llc-weekly" or "denver-new-businesses". Only used in newBusinesses mode.

## `lookbackDays` (type: `integer`):

How far back each monitor run re-checks, so filings that a state posts late are still caught. Example: 60. Only used in newBusinesses mode.

## Actor input object example

```json
{
  "mode": "search",
  "states": [
    "CO",
    "NY",
    "CT",
    "OR",
    "TX"
  ],
  "formedAfter": "30 days",
  "jurisdiction": "any",
  "status": "active",
  "maxResults": 1000,
  "maxResultsPerState": 0,
  "monitorId": "default",
  "lookbackDays": 60
}
```

# Actor output Schema

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

Newly formed or matching business entities from the selected states.

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

Per-state scan counts, returned totals, date window and monitor baseline flags.

# 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 = {
    "formedAfter": "30 days"
};

// Run the Actor and wait for it to finish
const run = await client.actor("dynamic_jingle/new-business-filings-secretary-of-state").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 = { "formedAfter": "30 days" }

# Run the Actor and wait for it to finish
run = client.actor("dynamic_jingle/new-business-filings-secretary-of-state").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 '{
  "formedAfter": "30 days"
}' |
apify call dynamic_jingle/new-business-filings-secretary-of-state --silent --output-dataset

```

## MCP server setup

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

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/44irZQPYwDIMZLvca/builds/QL9o3y2hSHofO9zEl/openapi.json