New LLC & Business Registrations Feed – Colorado & Connecticut

A feed of newly registered US businesses read from the official open-data APIs of two Secretaries of State: Colorado (Colorado Department of State) and Connecticut (Connecticut Secretary of the State). One flat row per business: name, entity type, status, registration date, city, ZIP code, and in Connecticut the NAICS activity. Run it every day with onlyNew and you receive each new company once.

It does not scrape any website. The data comes from the states' own public-domain open-data portals (Socrata API, no key, no CAPTCHA, no proxy), so there is no portal layout to break. The Actor adds what a raw API call does not: a date window, filters, paging, retries, entity types grouped into common categories, a memory of what you already received, and a hard rule that no agent, e-mail, street address or ownership-survey data is ever read or delivered.

Who it is for

• Lead generation and sales teams that sell to new companies (accounting, banking, insurance, payroll, software, office, legal, marketing, coworking): a daily list of companies registered in the last days, filterable by city, ZIP code, entity type or a word in the name. You get the company, not a contact: see "What it does not do".
• Service providers and B2B vendors who want to know which businesses started in their area this week.
• Researchers, journalists and analysts who study business formation, by state, month, entity type or industry (NAICS in Connecticut).
• Data teams that need a clean, schedulable feed of new registrations without maintaining a portal scraper.

What you get

For every business: the state and the state's own ID, the registered name, the type (grouped: LLC, Corporation, Nonprofit, LP, LLP, Other, plus the state's original value), whether it is a domestic or a foreign registration, the status, the registration date, the city, state, ZIP code and country of its business address, the NAICS activity (Connecticut), and in every row the source, the licence, the attribution and the address of the record in the source. Rows come newest registration first, both states merged; on the same date the states alternate, so a small maxItems is not filled by one state.

A foreign registration is an existing company that registers to do business in the state; it is a new registration in that state, not a new company. registrationKind tells them apart, and the input filter registrationKind keeps only domestic formations or only foreign registrations.

Rejected filings and name reservations are not delivered. The Connecticut register also lists filings that never became a business: "Rejected" (about 4 to 5 % of its rows) and name reservations ("Reserved", "Expired Reservation", "Reserved Cancel"). By default they are left out, and so they are never charged; set includeRejectedAndReserved to true to receive them, or name one of those statuses in statuses. Colorado has no such rows.

Quick start

The default input needs nothing: both states, the last 7 days, up to 1,000 rows. Seven days of both states are about 4,500 rows, so the default maxItems of 1,000 stops at the newest 1,000 (the SUMMARY says so). For a first run that should take the whole window, set maxItems to 5000 or more.

{}

A daily feed of new companies, each delivered once (schedule the Actor every day; the default window is the last 7 days, so a missed day is caught up):

{
  "onlyNew": true
}

A daily Task for one audience, with its own memory (see "Several scheduled Tasks" below). Create a Task with this input and schedule it every day; each new domestic LLC in Denver arrives once:

{
  "states": ["CO"],
  "onlyNew": true,
  "memoryKey": "denver-llc",
  "entityTypes": ["LLC"],
  "registrationKind": "domestic",
  "cities": ["Denver"],
  "maxItems": 500
}

New LLCs and corporations in Denver and Aurora that are in good standing, registered in October 2026:

{
  "states": ["CO"],
  "registeredFrom": "2026-10-01",
  "registeredTo": "2026-10-31",
  "entityTypes": ["LLC", "Corporation"],
  "cities": ["Denver", "Aurora"],
  "statuses": ["Good Standing"],
  "maxItems": 500
}

Input

Field	Default	What it does
states	["CO","CT"]	Which registers to read: CO Colorado, CT Connecticut.
registeredFrom	6 days before registeredTo	First registration date to include, YYYY-MM-DD, inclusive.
registeredTo	today (UTC date)	Last registration date to include, YYYY-MM-DD, inclusive.
onlyNew	false	Deliver only businesses not delivered to you before (memory per state and entity ID).
memoryKey	none	With onlyNew: a name for a separate memory (letters, digits, hyphens, at most 26 characters). Use one per scheduled Task.
entityTypes	all	Any of LLC, Corporation, Nonprofit, LP, LLP, Other.
registrationKind	all	domestic (formed in the state), foreign (formed elsewhere, registered in the state) or all.
cities	all	Whole city names, upper or lower case does not matter.
zipCodes	all	5-digit ZIP codes; a business matches when its ZIP code starts with one of them.
nameContains	all	Words or fragments (2+ characters) that the registered name must contain (any of them).
statuses	all	Statuses as the state writes them, for example Good Standing (Colorado) or Active (Connecticut).
includeRejectedAndReserved	false	Also deliver (and pay for) Connecticut's rejected filings and name reservations. Off by default.
maxItems	1000	Stop after this many rows (1 to 100,000), all states together. It is also your cost cap.

Filters are combined with AND; the values inside one filter are alternatives (OR). Nothing outside the date range is read.

Invalid input never costs anything. If something cannot be understood (a date that does not exist, an unsupported state, maxItems of 0, a ZIP code with letters), the run does not start, ends successfully, and the SUMMARY record says exactly what to fix.

Output

One row per business, flat, ready for a spreadsheet (text or null in every field; the ID is text so it is never rounded). The Overview tab shows the main columns; the dataset has every field below.

Field	Type	Meaning
state	string	Two-letter code of the state whose Secretary of State registered the business: "CO" or "CT".
entityId	string	The state's own identifier of the business: Colorado entityid, Connecticut accountnumber (the Business ID; for the few records that carry the placeholder 0000000 it is the register's own record id instead). Unique within a state; with state it is the key of a business. Always text, so spreadsheets do not turn it into a rounded number.
name	string	The registered name of the business, whitespace cleaned. Never a contact person.
entityType	string	The type grouped into common categories: "LLC", "Corporation", "Nonprofit", "LP", "LLP" or "Other". The grouping is stated in the README; entityTypeSource keeps the state's own value.
entityTypeSource	string or null	The type exactly as the state gives it: a code in Colorado (DLLC, DPC, DNC, FLLC...), a text in Connecticut (LLC, Stock, Non-Stock...). Null if the state leaves it empty.
registrationKind	string or null	"domestic" = formed in this state, "foreign" = formed elsewhere and registered to do business here. Connecticut: the citizenship field of the state. Colorado: derived from the first letter of the state's entity type code (D = Colorado, F = formed elsewhere); null for the few types without that letter (general partnerships and others). A foreign registration is a new registration in the state, not a new company.
status	string or null	The status in the state's register at the time of the run, as the state words it ("Good Standing", "Delinquent", "Active", "Dissolved"...). It can change later; a business is delivered once, with the status it had then.
registeredOn	string	Date (YYYY-MM-DD) the business was formed (domestic) or registered in the state (foreign), as recorded by the Secretary of State. The sources keep a date without a time.
formationJurisdiction	string or null	Where the business was formed, as the state words it: Colorado gives a state code or name ("CO", "DE", "Delaware"), Connecticut a state or territory name ("Connecticut", "Delaware"). Not normalised: the states do not use one spelling. Null if empty.
city	string or null	City of the business address on file (Colorado: principal address; Connecticut: business address). City only: the street is never delivered. As written by the state (case differs between records).
region	string or null	State or province of the business address, as written by the state (usually a two-letter code; not necessarily the registering state, a foreign business can have its office elsewhere).
postalCode	string or null	ZIP code of that address, cut to the 5 digits of a US ZIP (ZIP+4 is shortened on purpose); a non-US postal code is kept as written. Null if empty.
country	string or null	"US" for every spelling of the United States the sources use (US, USA, United States); any other country as written by the state. Null where the state leaves it empty (about half of the Connecticut records).
naicsCode	string or null	North American Industry Classification code of the activity, 6 digits. Connecticut only (the business gives it on its registration); always null for Colorado.
naicsDescription	string or null	Text of the NAICS activity as the state gives it, without the code. Connecticut only; null for Colorado.
source	string	Which dataset the row comes from.
license	string	Licence the source states in its metadata: "Public Domain".
attribution	string	Credit to the publisher. Public domain data does not require it, but it says where the row comes from; keep it when you republish.
datasetUrl	string	Page of the open-data dataset the row comes from.
recordUrl	string	Public API address that returns this one record from the source (JSON, no key), limited to the same columns this Actor delivers (no agent, e-mail or street address).
retrievedAt	string	When this Actor read the row from the source, ISO 8601 UTC.

Real example: Colorado

Run on 21 October 2026 (registeredFrom 2026-10-19, maxItems 50). The Colorado register has no NAICS activity, so those two fields are null.

{
  "state": "CO",
  "entityId": "20268284919",
  "name": "Stealth Automotive Technologies LLC",
  "entityType": "LLC",
  "entityTypeSource": "DLLC",
  "registrationKind": "domestic",
  "status": "Good Standing",
  "registeredOn": "2026-10-20",
  "formationJurisdiction": "CO",
  "city": "Denver",
  "region": "CO",
  "postalCode": "80203",
  "country": "US",
  "naicsCode": null,
  "naicsDescription": null,
  "source": "Colorado Department of State (CDOS) - Business Entities in Colorado",
  "license": "Public Domain",
  "attribution": "Colorado Department of State (CDOS), \"Business Entities in Colorado\", https://data.colorado.gov/d/4ykn-tg5h, Public Domain. Source rows were reduced to company-level fields and the entity type was grouped into categories.",
  "datasetUrl": "https://data.colorado.gov/d/4ykn-tg5h",
  "recordUrl": "https://data.colorado.gov/resource/4ykn-tg5h.json?$select=entityid,entityname,entitytype,entitystatus,entityformdate,principalcity,principalstate,principalzipcode,principalcountry,jurisdictonofformation&entityid=20268284919",
  "retrievedAt": "2026-10-21T14:28:48.853Z"
}

Real example: Connecticut

Same run. Connecticut adds the NAICS activity that the business gave when it registered.

{
  "state": "CT",
  "entityId": "3537206",
  "name": "Kitchen Line LLC",
  "entityType": "LLC",
  "entityTypeSource": "LLC",
  "registrationKind": "domestic",
  "status": "Active",
  "registeredOn": "2026-10-20",
  "formationJurisdiction": "Connecticut",
  "city": "Enfield",
  "region": "CT",
  "postalCode": "06082",
  "country": "US",
  "naicsCode": "513210",
  "naicsDescription": "Software Publishers",
  "source": "Connecticut Secretary of the State - Connecticut Business Registry - Business Master",
  "license": "Public Domain",
  "attribution": "Connecticut Secretary of the State, \"Connecticut Business Registry - Business Master\", https://data.ct.gov/d/n7gp-d28j, Public Domain. Source rows were reduced to company-level fields and the entity type was grouped into categories.",
  "datasetUrl": "https://data.ct.gov/d/n7gp-d28j",
  "recordUrl": "https://data.ct.gov/resource/n7gp-d28j.json?$select=id,accountnumber,name,business_type,status,date_registration,billingcity,billingstate,billingpostalcode,billingcountry,state_or_territory_formation,citizenship,naics_code&id=001eq00001f7mxRAAQ",
  "retrievedAt": "2026-10-21T14:28:48.752Z"
}

The run summary

Every run writes a SUMMARY record to its key-value store: totals, totals per state, the reason a run stopped early, warnings, and for onlyNew how many businesses were skipped because they were delivered before. The record of the run above (the attribution and warnings lists are left out here):

{
  "startedAt": "2026-10-21T14:28:47.345Z",
  "finishedAt": "2026-10-21T14:28:48.875Z",
  "status": "finished",
  "stopReason": "maxItems (50) reached: there may be more businesses in the range",
  "settings": {
    "states": [
      "CO",
      "CT"
    ],
    "registeredFrom": "2026-10-19",
    "registeredTo": "2026-10-21",
    "defaultWindow": false,
    "onlyNew": false,
    "memoryKey": null,
    "entityTypes": null,
    "registrationKind": null,
    "includeRejectedAndReserved": false,
    "cities": null,
    "zipCodes": null,
    "nameContains": null,
    "statuses": null,
    "maxItems": 50
  },
  "totals": {
    "delivered": 50,
    "alreadyDelivered": 0,
    "skippedAlreadyDelivered": 0,
    "duplicates": 0,
    "filteredOutLocally": 0,
    "skippedInvalid": 0,
    "rowsRead": 51,
    "requests": 2,
    "retries": 0
  },
  "byState": {
    "CO": {
      "requests": 1,
      "rowsRead": 26,
      "skippedInvalid": 0,
      "filteredOutLocally": 0,
      "duplicates": 0,
      "status": "stopped",
      "error": null,
      "delivered": 25
    },
    "CT": {
      "requests": 1,
      "rowsRead": 25,
      "skippedInvalid": 0,
      "filteredOutLocally": 0,
      "duplicates": 0,
      "status": "stopped",
      "error": null,
      "delivered": 25
    }
  }
}

status is finished (everything asked was read, or maxItems was reached), partial (a source failed, or the run was stopped by the spending limit, the time limit or an abort; what was delivered stays and is charged once) or failed (no source could be read; the run fails and nothing is charged). A run with invalid input has status invalid-input. In byState, each state is complete (read to the end of the range), stopped (the run ended before the end: maxItems, spending limit, time limit or abort) or failed (with the reason in error).

Entity types

The states use their own type codes. The entityType field groups them into six categories so one filter works for both states; entityTypeSource always keeps the state's original value.

Category	Colorado entitytype codes	Connecticut business_type values
LLC	DLLC, FLLC	LLC
Corporation	DPC, FPC, DPC-PBC	Stock, B Corp, Insurance Stock, Bank Stock, Credit Union Stock, Stock Specially Chartered
Nonprofit	DNC, FNC	Non-Stock, Non-Stock Specially Chartered, Religious, Credit Union Non-Stock, Bank Non-Stock, Insurance Non-Stock
LP	DLP, FLP, DLLLP, FLLLP	Limited Partnership
LLP	DLLP, FLLP	LLP
Other	every other code, for example GP, FO, DC56, DLCA, IC, UNA, and an empty value	every other value, for example General Partnerships, Statutory Trust, Special Chartered, Cemetery, Unknown, and an empty value

Connecticut's non-stock forms (including religious corporations) are grouped as Nonprofit; that grouping is our reading of the form names, not a legal opinion. If your use needs the exact legal form, filter on entityTypeSource.

Pricing

Pay per event: one event, "New business record" (event name business), 0.002 USD per row delivered. Nothing else is charged by this Actor: rows that are skipped, filtered out, repeated, already delivered before (onlyNew), or that could not be read cost nothing.

Rows	Cost
25 (the prefilled console run)	0.05 USD
1,000 (the default maxItems)	2 USD
10,000	20 USD
About 4,500 (a typical week of both states, see below)	about 9 USD

Volume, measured on the registers (five full weeks, 14 September to 18 October 2026): on a weekday about 800 new rows (Colorado about 590, Connecticut about 210), on a weekend day about 290 (Colorado about 220, Connecticut about 70). That is about 4,500 rows in a week (Colorado about 3,350, Connecticut about 1,150 once rejected filings and name reservations are left out), about 640 a day on average. A daily onlyNew feed of both states therefore costs roughly 1.3 USD a day at that rate; with filters (city, entity type, ZIP code, registration kind) you pay only for the rows you keep. Volumes change from week to week.

Your spending limit is respected: the Actor never stores or charges one row more than the limit allows and stops with a clear reason in the SUMMARY. Rows are stored first and charged right after, in batches of at most 100. If a run is restarted by the platform (migration), the businesses already in the dataset are not delivered or charged again.

Only-new mode (onlyNew)

With onlyNew on, the Actor remembers, in a named key-value store in your own account (us-new-business-registrations-memory), which businesses it has delivered to you, by state and entity ID. A business is delivered once; the next run skips it for free.

• The memory is updated only after the row is stored in the dataset and charged. A run that fails before that remembers nothing, so the next run delivers those businesses.
• Only delivered businesses are remembered. Rows cut by maxItems, by the spending limit, or removed by a filter stay "new": change the filters or raise the limit and they come out next time.
• Because the default window is the last 7 days, a business that a state adds late (with an earlier registration date) is still caught by the next runs, as long as it is inside the window. Run at least once a week with the default window, or set registeredFrom yourself.
• It tracks businesses, not changes: a company already delivered is not delivered again when its status changes later.
• To start over, delete that key-value store in your account. Without onlyNew the Actor remembers nothing.

Several scheduled Tasks: memoryKey

By default all your runs with onlyNew share one memory. If you schedule two Tasks (for example new LLCs in Denver and new corporations in Hartford) and they overlap, the first Task to run would take the businesses that the second one is also meant to deliver, silently. Give each Task its own memoryKey (for example denver-llc and hartford-corp): each key keeps a separate memory in the store us-new-business-registrations-memory-<key>, so the Tasks never take businesses from each other. Without a key everything works as before. Keys are letters, digits and hyphens, at most 26 characters (the platform limits store names to 63), upper and lower case are the same key, and changing the key starts a new memory. A key given without onlyNew is ignored, with a warning.

Data sources, licence, freshness

State	Dataset	Publisher	Licence in the dataset's metadata
Colorado	Business Entities in Colorado	Colorado Department of State (CDOS)	Public Domain
Connecticut	Connecticut Business Registry - Business Master	Connecticut Secretary of the State	Public Domain

The licence is the one the portals state in their metadata (checked on 21 October 2026). Public domain data needs no attribution, but every row carries the publisher and dataset so you can show where it comes from. This is a description of the sources' own statement, not legal advice.

Freshness: the Actor adds no delay; it reads the portals live. The portals decide when their data is refreshed. On 21 October 2026 both already contained registrations dated that same day. The date in registeredOn is the date the state recorded, without a time. retrievedAt tells when the Actor read the row.

What it does not do

• No contact data and no personal data. Never the registered agent (name or address), never e-mail addresses, never street addresses (only city, state, ZIP code and country), never the ownership survey flags (woman, veteran, minority, LGBTQI or disability owned), never a precise location. The Actor asks the portals only for the columns it delivers, and a test checks that nothing else can come out even if a portal answered with more. If you need to reach a company, you need another source and your own legal basis.
• recordUrl shows only the columns the Actor delivers. It is the address of that one record on the state's open-data portal with a $select of exactly the delivered columns, so opening it shows no agent, e-mail, street address or survey flag. The portal itself still publishes its complete rows (agent and addresses included) at its own address; if you drop the $select from the link, or query the portal directly, you reach them: that is your own access to a public register and your own responsibility.
• Only Colorado and Connecticut. Other states are not included: only registers that publish public-domain data through an official open-data API are added.
• Not a verification or KYC service. A registration is not proof that a business operates. Look at the rows before you build outreach on them: some registrations arrive in batches with similar names (for example on 20-21 October 2026 several Colorado corporations whose names end in "inc" and that share one ZIP code). The Actor delivers what the state recorded and leaves the judgement to you.
• No tracking of later changes. It does not report dissolutions, status changes or annual reports of businesses; status is the status at the time of the run.
• Entity names can contain a person's name (for example a sole practitioner's LLC). That is the registered name of the business. Handle it under the rules that apply to your use (marketing and privacy law included).

Limits and honest notes

• Maximum 100,000 rows per run; split a bigger job by date range.
• At most 2 requests per second are made to the portals, pages of up to 1,000 rows, retries with a growing wait on errors and "too many requests" answers (the Retry-After header is honoured). If a portal fails for good, the other state is still delivered and the run is marked partial.
• Dates are calendar dates as recorded by the state. The default "today" is the UTC date.
• Cities and statuses are compared as written by the states (upper or lower case ignored, nothing else): "Ft. Collins" is not "Fort Collins". Cities are written differently from record to record (HARTFORD, Hartford); the value in the row is the state's, unchanged.
• Half of the Connecticut records have no country; country is then null (nothing is guessed). A few countries are misspelled by the states and are kept as written.
• ZIP+4 codes are shortened to 5 digits on purpose.
• A portal's firewall can refuse a request (HTTP 403). The Actor retries; if the refusal stays, that source is marked failed with the reason in the SUMMARY and the other state is still delivered. Run again later.
• Some businesses are already closed when they are registered. About 0.4 % of the new rows (measured 14 September to 18 October 2026: 69 of 16,693 in Colorado, "Voluntarily Dissolved" mostly; 30 of 5,763 in Connecticut, "Dissolved") already carry a dissolved or withdrawn status. They are delivered and charged like the others. To leave them out, set statuses to ["Good Standing", "Active"].

FAQ

How do I get only active companies? Set statuses to ["Good Standing", "Active"] (Colorado says "Good Standing", Connecticut "Active"). New registrations are normally in good standing / active already, but the status is the state's, at the time of the run.

How do I get only domestic formations, not foreign companies registering in the state? Set the input registrationKind to domestic (or foreign for the opposite).

Can I get a CSV or Excel file? Yes: the dataset can be downloaded as CSV, Excel, JSON, XML, and the columns are flat.

How is this different from the "business search" scrapers? Those drive a Secretary of State website, which is slow and breaks when the site changes. This Actor reads the state's open-data API for new registrations and is built for feeds (date window, only-new memory), not for looking up one named company.

Can I look up one specific company? Use nameContains with a wide registeredFrom; the Actor is built for new registrations, not for the full history of one company.

Why only two states? Each state needs its own check that the data is public domain and offered through an official API without a key. These two passed; others are added the same way.

What happens if a source is down? The Actor retries; if it still fails it says so in the SUMMARY, delivers the other state, and charges only for rows it delivered.

Can I schedule it? Yes. Schedule it daily with onlyNew on and leave the dates empty; if you schedule more than one Task, give each its own memoryKey. Add an integration (webhook, Google Sheets, e-mail, your CRM) on the dataset.

Technical notes

• Node.js 22, Apify SDK. The Actor runs in 256 MB; a run of 30,000 rows peaked at about 180 MB in a local test.
• Pagination uses a total order (registration date, then ID, both descending), so no row is read twice or skipped between pages unless the state adds records while the run is reading; a repeated row is delivered once.
• The User-Agent identifies the Actor. No proxy, no browser, no login.
• The source of this Actor's field list is the same file that generates the dataset schema, and a test checks this README against the code.