# New Business Filings — Colorado, Connecticut & Pennsylvania (`pennant/us-new-business-filings`) Actor

Daily feed of newly registered LLCs, corporations, nonprofits and partnerships from official Colorado, Connecticut and Pennsylvania open-data registries, in one normalized schema. Business fields only; street addresses off by default.

- **URL**: https://apify.com/pennant/us-new-business-filings.md
- **Developed by:** [Pennant](https://apify.com/pennant) (community)
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 filing 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/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 — Colorado, Connecticut & Pennsylvania

**Pennant** — Official public records as clean, tested data feeds.

One daily feed of **newly registered businesses** (LLCs, corporations, nonprofits and partnerships) from official state open-data registries, normalized into a single schema. Set `sinceDate` to yesterday and schedule the Actor to collect fresh filings from Colorado, Connecticut and Pennsylvania in one run.

**Source:** official open-data business registries of Colorado (data.colorado.gov), Connecticut (data.ct.gov) and Pennsylvania (data.pa.gov), all Public Domain. Colorado's required disclaimer and full credit are in the "Data sources and licenses" section below.

### Who it's for

Insurance agents, banks, payroll and accounting firms, web and marketing agencies, and B2B SaaS teams who sell to brand-new businesses and want a reliable lead feed instead of three separate state downloads.

**Use cases**

- A daily lead list of new LLCs and corporations across three states, scheduled with `sinceDate` set to yesterday.
- New Connecticut businesses in a specific industry, using the NAICS code Connecticut publishes.
- A monthly count of new formations by state and entity type for market research.
- New nonprofits only (`entityKinds: ["nonprofit"]`) for a grant or services outreach list.

### Input examples

Yesterday's LLCs and corporations in all three states:

```json
{ "sinceDate": "2026-11-14", "states": ["CO", "CT", "PA"], "entityKinds": ["llc", "corporation"], "maxItems": 2000 }
```

Colorado-only filings for a date range:

```json
{ "sinceDate": "2026-11-01", "untilDate": "2026-11-14", "states": ["CO"] }
```

The first example at a glance:

| Field | Example value | What it does |
|---|---|---|
| `sinceDate` | `2026-11-14` | Filed on or after this date (required) |
| `states` | `["CO", "CT", "PA"]` | All three states (default) |
| `entityKinds` | `["llc", "corporation"]` | Only LLCs and corporations |
| `maxItems` | `2000` | Stop after 2,000 filings |

### Input

| Field | Type | Notes |
|---|---|---|
| `sinceDate` | YYYY-MM-DD (required) | Filing/formation date on or after. For a daily schedule, use yesterday's date. |
| `untilDate` | YYYY-MM-DD | Inclusive upper bound. |
| `states` | `CO`, `CT`, `PA` | Default: all three. |
| `entityKinds` | `llc`, `corporation`, `nonprofit`, `partnership` | Empty = all kinds, mapped to each state's type codes. |
| `nameContains` | string | Optional case-insensitive name filter. |
| `maxItemsPerState` / `maxItems` | integers | Caps (default 1,000 / 5,000). Each result is one billable event. |
| `includeStreetAddress` | boolean | **Default off.** Only city, state and ZIP unless you turn this on. Pennsylvania rows never include street lines. |
| `requestDelayMs`, `maxRetries` | integers | Politeness delay (default 1,100 ms) and retries. |

### Sample output (one item per filing)

Street lines are omitted under the default privacy setting:

```json
{
  "registryState": "CT",
  "registryId": "3548302",
  "name": "Pro Home Renovation LLC",
  "entityKind": "llc",
  "rawEntityType": "LLC",
  "status": "Active",
  "filingDate": "2026-11-09",
  "formationJurisdiction": "Connecticut",
  "industry": { "naicsCode": "236118", "title": "Residential Remodelers" },
  "address": {
    "street1": null,
    "street2": null,
    "city": "Waterbury",
    "state": "CT",
    "zip": "06705-1145",
    "country": "United States"
  },
  "sourceDataset": "https://data.ct.gov/Business/Connecticut-Business-Registry-Business-Master/n7gp-d28j",
  "sourceRecordUrl": "https://data.ct.gov/resource/n7gp-d28j.json?id=…",
  "retrievedAt": "2026-11-15T16:00:00.000Z"
}
```

The run also writes `RUN_SUMMARY` (per-state counts and errors) and `SOURCE_NOTICE` (each state's required notice).

**Example output as a table** (fictional rows, key columns only; street fields are null by default and not shown):

| registryState | name | entityKind | filingDate | industry (NAICS) | city | zip |
|---|---|---|---|---|---|---|
| CT | Maple Row Bookkeeping LLC | llc | 2026-11-14 | 541219 | Hamden | 06518 |
| CO | Summit Trail Outfitters Inc | corporation | 2026-11-14 | null | Fort Collins | 80524 |
| PA | Keystone Mobile Detailing LLC | llc | 2026-11-14 | null | Lancaster | 17601 |

### Privacy defaults

- Street addresses are **off by default**. Only city, state and ZIP are returned unless `includeStreetAddress` is on.
- Pennsylvania street lines are never returned (many small LLCs list apartments).
- No registered-agent person names, emails, owner-demographic flags, officer names, or mailing addresses.
- Pennsylvania's source repeats each business once per officer; this feed never selects officer name fields and groups server-side so each filing appears once.

### Limitations

- Covers **Colorado, Connecticut and Pennsylvania only**. Other states are added only after their portal terms pass review (New York, Oregon, Iowa and Texas did not).
- `industry` (NAICS) is published only for Connecticut. Colorado and Pennsylvania have no NAICS field here.
- Pennsylvania has no status field, so `status` is `null`. `formationJurisdiction` is `Pennsylvania` for domestic filings and `null` for foreign ones.
- If one registry is down, the other states' results are still delivered and `RUN_SUMMARY.perState` shows the error.
- Only fields the states publish in these open-data datasets: no formation documents, no officer or owner lists, no phone numbers.
- Unauthenticated SODA requests share a per-IP pool and may receive HTTP 429; the Actor backs off and retries.

### Data sources and licenses

All three datasets are published as **Public Domain** and are read through the documented Socrata SODA API, with at least 1.1 seconds between pages (`Crawl-delay: 1`). This Actor is not affiliated with or endorsed by any of these states.

| State | Dataset | Portal | License |
|---|---|---|---|
| Colorado | Business entities (`4ykn-tg5h`) | [data.colorado.gov](https://data.colorado.gov) | Public Domain |
| Connecticut | Business Registry — Business Master (`n7gp-d28j`) | [data.ct.gov](https://data.ct.gov) | Public Domain |
| Pennsylvania | Registered businesses (`xvd7-5r2c`), Dept of State | [data.pa.gov](https://data.pa.gov) | Public Domain (U.S. Government) |

**Colorado disclaimer** (required by the state's terms; also written to `SOURCE_NOTICE`):

> 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.

Connecticut and Pennsylvania provide the data "as is", with no warranty of accuracy, timeliness or completeness. See [data.ct.gov/terms](https://data.ct.gov/terms) and [data.pa.gov/data-policy](https://data.pa.gov/data-policy).

### Pricing

Pay per event, billed by Apify:

| Event | Price |
|---|---|
| Run start (`apify-actor-start`) | $0.005 per run |
| Each filing returned (`result`) | $0.003 per filing |

**Worked example:** one run that returns 200 filings costs $0.005 + 200 × $0.003 = **$0.605**. A run of 1,000 filings costs **$3.005**.

To control spend, set `maxItems` (the Actor never returns more), and set a maximum cost per run in Apify. The Actor stops cleanly when it reaches the caller's max charge, and the filings already returned are kept.

### FAQ

**What does it cover, and what doesn't it?**

New LLCs, corporations, nonprofits and partnerships registered in Colorado, Connecticut and Pennsylvania. Other states are added only after their portal terms pass review; New York, Oregon, Iowa and Texas did not. It has no formation documents, officer or owner lists, or phone numbers, and NAICS industry codes exist only for Connecticut.

**What happens to personal names and addresses?**

No registered-agent names, officer names, emails, owner-demographic flags or mailing addresses are selected. Only city, state and ZIP are returned unless you turn on `includeStreetAddress`, and Pennsylvania street lines are never returned.

**Is this official data or a scrape?**

Official open data. The Actor reads each government portal's documented Socrata API, at a polite pace (at least 1.1 seconds between pages). It does not log in anywhere or scrape a private website.

**How do I cap the cost of a run?**

Set `maxItems`; each returned record is one billable result. The defaults are 1,000 per state and 5,000 in total, so a default run over all three states returns at most 3,000 filings (up to $9.005). Set a lower `maxItems` for a first test. You can also set a maximum cost per run in Apify, and the Actor stops cleanly when it reaches it.

**How fresh is the data?**

Every run reads the three state registries live, so a filing appears as soon as the state publishes it to its open-data portal. For a daily feed, schedule the Actor with `sinceDate` set to yesterday.

**Is Pennant affiliated with the source?**

No. Pennant is not affiliated with or endorsed by Colorado, Connecticut or Pennsylvania. The source agency is the authoritative record; confirm anything important with it.

**Where do I get help?**

Email 51wrw1aj@mail.grokbot.com. For a bad or unexpected record, include the run ID and the record's ID or licence number.

### For AI agents

- **Purpose:** list businesses newly registered in Colorado, Connecticut and/or Pennsylvania since a date.
- **Call when:** the user wants new-business leads or formation counts for CO/CT/PA.
- **Minimal input:** `{"sinceDate": "YYYY-MM-DD"}`.
- **Cost control:** one `result` event per filing; set `maxItems`.

# Actor input Schema

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

YYYY-MM-DD. For a daily schedule use yesterday's date.

## `untilDate` (type: `string`):

YYYY-MM-DD (inclusive, optional).

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

Registries to include.

## `entityKinds` (type: `array`):

Leave empty for all kinds.

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

Optional case-insensitive name filter.

## `maxItemsPerState` (type: `integer`):

Cap per registry.

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

Run-wide cap (each result is one billable event).

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

Off by default: only city, state and ZIP. Turn on to include street lines for Colorado and Connecticut. Pennsylvania rows never include street lines (many small LLCs list apartments).

## `requestDelayMs` (type: `integer`):

Politeness delay (portal robots.txt Crawl-delay: 1).

## `maxRetries` (type: `integer`):

Retries on timeouts, 408/429/5xx.

## Actor input object example

```json
{
  "sinceDate": "2026-11-01",
  "states": [
    "CO",
    "CT",
    "PA"
  ],
  "maxItemsPerState": 1000,
  "maxItems": 5000,
  "includeStreetAddress": false,
  "requestDelayMs": 1100,
  "maxRetries": 4
}
```

# Actor output Schema

## `filings` (type: `string`):

No description

## `runSummary` (type: `string`):

No description

## `sourceNotice` (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 = {
    "sinceDate": "2026-11-01"
};

// Run the Actor and wait for it to finish
const run = await client.actor("pennant/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 = { "sinceDate": "2026-11-01" }

# Run the Actor and wait for it to finish
run = client.actor("pennant/us-new-business-filings").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 '{
  "sinceDate": "2026-11-01"
}' |
apify call pennant/us-new-business-filings --silent --output-dataset

```

## MCP server setup

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

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/AsW8vsOhtglYhLfBe/builds/cawCvxY6TBuUqaqJ4/openapi.json
