# US New Business Filings (Daily Feed) (`great_pistachio/us-new-business-filings`) Actor

Daily feed of new business registrations across 6 US states (FL, NY, CO, CT, OR, TX), straight from official government sources. New LLCs, corporations, and non-profits with owner names, addresses, and registered agents in one unified schema. Schedule it daily for fresh leads every morning.

- **URL**: https://apify.com/great\_pistachio/us-new-business-filings.md
- **Developed by:** [Saturnin Pugnet](https://apify.com/great_pistachio) (community)
- **Categories:** Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $5.00 / 1,000 results

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/platform/actors/running/actors-in-store#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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js/docs.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/integrations/mcp.md).

If your project is in a different language, use 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 Filings — Daily Feed of New LLCs & Corporations

Get every new business registered in the covered states, delivered as one clean, unified dataset. Data comes straight from official government sources (Secretary of State bulk feeds and open-data portals), refreshed daily.

**Schedule this actor to run every morning and start the day with a fresh list of brand-new businesses — with owner names, addresses, and registered agents.**

### Who Uses This

- **Insurance agents**: new businesses need general liability, workers comp, and BOP policies from day one
- **Banks, payroll & merchant services**: new LLCs need bank accounts, payroll, and payment processing
- **B2B SaaS and agencies**: reach founders in their first week, before competitors know they exist
- **CPAs and attorneys**: new filings signal demand for accounting, bookkeeping, and legal setup
- **Commercial real estate**: new entities often precede office and retail leases
- **Data teams**: track business formation trends by state, city, or industry

### Supported States

| State | Source | Freshness | Extras |
|-------|--------|-----------|--------|
| Florida | Division of Corporations bulk feed (the data behind Sunbiz) | Daily | Officers (up to 6), EIN when published |
| New York | Department of State daily filings (data.ny.gov) | Daily (T-1) | County, filer, service-of-process address |
| Colorado | Secretary of State open data | Same-day | Registered agent with address |
| Connecticut | Business Registry master (data.ct.gov) | Same-day | **Business email address + NAICS code** |
| Oregon | Secretary of State open data | Weekly (Mondays) | Principal, mailing, and agent addresses |
| Texas | Comptroller franchise taxpayer registrations | Daily | Proxy source: new businesses appear days after SOS filing |

These six states cover roughly a third of all new US business formations. More states are added as their governments publish usable data. Need a specific state sooner? Open an issue on this actor and it moves to the front of the queue.

**Per-state notes:**
- **New York** publishes a rolling ~2-month window of daily filings, so use it as a feed, not an archive.
- **Oregon** refreshes weekly: use `last7days` or wider to always catch the latest batch.
- **Texas** SOS data is paywalled, so the feed uses the Comptroller's new franchise-taxpayer registrations instead: same businesses, a few days later, no agent/officer data.
- **Connecticut** is the only state publishing business email addresses: instant outreach lists.

### Output

One unified schema across all states. Each record includes (where the state provides it):

| Field | Description |
|-------|-------------|
| `state`, `stateName` | Where the business registered |
| `businessName` | Official registered name |
| `entityNumber` | Official registry ID |
| `entityType` | Normalized: LLC, CORPORATION, NONPROFIT, LP, OTHER |
| `entityTypeRaw` | The state's own type code |
| `status` | Registration status |
| `filingDate` | Date of formation/filing (YYYY-MM-DD) |
| `principalAddress` / `City` / `Zip` | Business address |
| `mailingAddress` / `City` / `Zip` | Mailing address if different |
| `registeredAgentName` / `Address` | Registered agent details |
| `officers` | Officers/members with titles, names, addresses (where published) |
| `feiNumber` | Federal EIN (where published) |
| `sourceUrl` | Link to the official state record |
| `dataSource` | Which government feed the record came from |

### Input

```json
{
    "dateRange": "last3days",
    "states": [],
    "entityTypes": ["LLC", "CORPORATION"],
    "maxResults": 0
}
````

- `dateRange`: `today`, `yesterday`, `last3days`, `last7days`, `last14days`, or `custom` with `customStartDate`/`customEndDate`
- `states`: empty = all supported states
- `entityTypes`: empty = all types
- `maxResults` / `maxResultsPerState`: 0 = unlimited

Note: states publish with a 1-2 day lag, and a record's `filingDate` can trail its publication date by a few days. `last3days` is a safe default for daily schedules.

### Why This Beats Doing It Yourself

Each state hides its data behind a different mechanism: fixed-width SFTP bulk files, open-data APIs, quirky portals. This actor normalizes all of it into one schema, handles retries and timeouts, and keeps up when states change their formats. You get a single feed instead of N integrations.

All data is public record, sourced from official government feeds — no scraping of protected websites, no PII beyond what states publish by law.

### Works Great With

- [Website Company Enricher](https://apify.com/great_pistachio/website-company-enricher) - Enrich new businesses with emails, phones, and tech stack from their websites
- [Florida New Business Leads](https://apify.com/great_pistachio/florida-business-leads) - Florida-only feed with extended filters (city, ZIP, filing type)
- [US Business Entity Search](https://apify.com/great_pistachio/us-business-search) - Look up any existing business across state registries
- [Property Tax Scraper](https://apify.com/great_pistachio/property-tax-scraper) - County assessor records for property research

### FAQ

**How fresh is the data?**
Records appear as soon as the state publishes them, which is typically the next business day after filing.

**Can I get only LLCs?**
Yes — set `entityTypes` to `["LLC"]`.

**Does it work on a schedule?**
Yes, that's the intended use: schedule a daily run with `dateRange: "last3days"` and dedupe on `entityNumber` downstream (or keep `yesterday` for near-zero overlap).

**Is this legal?**
Yes. All records are public business registrations published by state governments for exactly this kind of use.

# Actor input Schema

## `dateRange` (type: `string`):

Which filing dates to include. Government feeds publish with a 1-2 day lag, so 'Last 3 Days' is a safe default.

## `customStartDate` (type: `string`):

Start date for custom range (YYYY-MM-DD). Only used when Date Range is 'Custom Range'.

## `customEndDate` (type: `string`):

End date for custom range (YYYY-MM-DD). Only used when Date Range is 'Custom Range'.

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

Which states to pull filings from. Leave empty for all available states.

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

Filter by normalized entity type. Leave empty for all types.

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

Cap results per state. 0 = unlimited.

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

Cap total results across all states. 0 = unlimited.

## Actor input object example

```json
{
  "dateRange": "last3days",
  "states": [],
  "entityTypes": [],
  "maxResultsPerState": 50,
  "maxResults": 0
}
```

# Actor output Schema

## `defaultDataset` (type: `string`):

New business filings across US states in a unified schema — business name, entity type, filing date, addresses, registered agent, officers, and (where published) business email and NAICS code

# 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 = {
    "dateRange": "last3days",
    "maxResultsPerState": 50
};

// Run the Actor and wait for it to finish
const run = await client.actor("great_pistachio/us-new-business-filings").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 = {
    "dateRange": "last3days",
    "maxResultsPerState": 50,
}

# Run the Actor and wait for it to finish
run = client.actor("great_pistachio/us-new-business-filings").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "dateRange": "last3days",
  "maxResultsPerState": 50
}' |
apify call great_pistachio/us-new-business-filings --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=great_pistachio/us-new-business-filings",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "US New Business Filings (Daily Feed)",
        "description": "Daily feed of new business registrations across 6 US states (FL, NY, CO, CT, OR, TX), straight from official government sources. New LLCs, corporations, and non-profits with owner names, addresses, and registered agents in one unified schema. Schedule it daily for fresh leads every morning.",
        "version": "1.0",
        "x-build-id": "EqMqlkfbZihu3caoO"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/great_pistachio~us-new-business-filings/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-great_pistachio-us-new-business-filings",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/great_pistachio~us-new-business-filings/runs": {
            "post": {
                "operationId": "runs-sync-great_pistachio-us-new-business-filings",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/great_pistachio~us-new-business-filings/run-sync": {
            "post": {
                "operationId": "run-sync-great_pistachio-us-new-business-filings",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "dateRange"
                ],
                "properties": {
                    "dateRange": {
                        "title": "Date Range",
                        "enum": [
                            "today",
                            "yesterday",
                            "last3days",
                            "last7days",
                            "last14days",
                            "custom"
                        ],
                        "type": "string",
                        "description": "Which filing dates to include. Government feeds publish with a 1-2 day lag, so 'Last 3 Days' is a safe default.",
                        "default": "last3days"
                    },
                    "customStartDate": {
                        "title": "Custom Start Date",
                        "type": "string",
                        "description": "Start date for custom range (YYYY-MM-DD). Only used when Date Range is 'Custom Range'."
                    },
                    "customEndDate": {
                        "title": "Custom End Date",
                        "type": "string",
                        "description": "End date for custom range (YYYY-MM-DD). Only used when Date Range is 'Custom Range'."
                    },
                    "states": {
                        "title": "States",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Which states to pull filings from. Leave empty for all available states.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "FL",
                                "NY",
                                "CO",
                                "CT",
                                "OR",
                                "TX"
                            ],
                            "enumTitles": [
                                "Florida (daily)",
                                "New York (daily, T-1)",
                                "Colorado (same-day)",
                                "Connecticut (same-day, incl. business email + NAICS)",
                                "Oregon (weekly refresh)",
                                "Texas (daily, franchise-tax proxy)"
                            ]
                        },
                        "default": []
                    },
                    "entityTypes": {
                        "title": "Entity Types",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Filter by normalized entity type. Leave empty for all types.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "LLC",
                                "CORPORATION",
                                "NONPROFIT",
                                "LP",
                                "OTHER"
                            ]
                        },
                        "default": []
                    },
                    "maxResultsPerState": {
                        "title": "Max Results per State",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Cap results per state. 0 = unlimited.",
                        "default": 50
                    },
                    "maxResults": {
                        "title": "Max Results Total",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Cap total results across all states. 0 = unlimited.",
                        "default": 0
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
