# New LLC & Business Registrations Feed – Colorado & Connecticut (`far003/us-new-business-registrations`) Actor Feed of newly registered US businesses in Colorado and Connecticut from the official Secretary of State open-data APIs. Only-new mode skips companies already delivered. Public domain data, no scraping, no personal contacts. Spreadsheet-ready. - **URL**: https://apify.com/far003/us-new-business-registrations.md - **Developed by:** [Francesco Antonio Russo](https://apify.com/far003) (community) - **Security:** Limited permissions - **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks - **User rating**: No ratings yet ## Pricing $2.00 / 1,000 new 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 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. ```json {} ``` 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): ```json { "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: ```json { "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: ```json { "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. ```json { "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. ```json { "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): ```json { "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-`, 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](https://data.colorado.gov/d/4ykn-tg5h) | Colorado Department of State (CDOS) | Public Domain | | Connecticut | [Connecticut Business Registry - Business Master](https://data.ct.gov/d/n7gp-d28j) | 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. # Actor input Schema ## `states` (type: `array`): Which state registers to read. Colorado (Colorado Department of State) and Connecticut (Secretary of the State). Both by default. More states are added as their open-data registers are checked; a state is only added when its data is public domain and can be read through an official API. ## `registeredFrom` (type: `string`): First registration date to include (YYYY-MM-DD, inclusive). Leave empty for the default window: the last 7 days ending today (UTC date). If you give only "Registered to", the window starts 6 days before it. The date is the one recorded by the Secretary of State (formation date for businesses formed in the state, registration date for foreign ones). ## `registeredTo` (type: `string`): Last registration date to include (YYYY-MM-DD, inclusive). Leave empty for today (UTC date). ## `onlyNew` (type: `boolean`): Keep a memory between runs and deliver only businesses this Actor has not delivered to you before (per state and entity ID). Schedule the Actor daily with this on to get a feed of new companies, each delivered and charged once, for example {"onlyNew": true} in a daily Task. The memory is kept in a named key-value store in your account ("us-new-business-registrations-memory"), is updated only after the rows are stored, and only for rows that were delivered. Delete that store to start over. If you run more than one scheduled Task, give each its own "Memory key" so they do not take each other's businesses. ## `memoryKey` (type: `string`): Only used with "Only businesses not delivered before". Without a key, all your runs share one memory. Give a key (letters, digits and hyphens, at most 26 characters, for example "denver-llc") to keep a separate memory in the store "us-new-business-registrations-memory-". Use one key per scheduled Task, so two Tasks with different filters never take each other's businesses. Upper and lower case are the same key. Changing the key starts a new memory. ## `entityTypes` (type: `array`): Keep only these kinds of business. Empty = all. The categories group the states' own entity types (the README lists the grouping); "Other" covers everything that is not one of the first five. ## `registrationKind` (type: `string`): "Domestic" = formed in this state; "Foreign" = formed elsewhere and registered to do business here (not a new company, a new registration in the state); "All" = both. See the field registrationKind in the output; Colorado's kind is derived from its entity type code. ## `cities` (type: `array`): Keep only businesses whose address city is one of these (whole name, upper or lower case does not matter, for example "Denver"). The address is the principal address in Colorado and the business address in Connecticut. ## `zipCodes` (type: `array`): Keep only businesses whose address ZIP code starts with one of these 5-digit codes (for example "80222"). ZIP+4 values are shortened to 5 digits. ## `nameContains` (type: `array`): Keep only businesses whose registered name contains at least one of these words or fragments (at least 2 characters, case does not matter), for example "solar" or "roofing". ## `statuses` (type: `array`): Keep only businesses with one of these statuses, written as the state writes it (case does not matter). For active companies use "Good Standing" (Colorado) and "Active" (Connecticut). A brand-new registration is usually in good standing / active, but the status is not guaranteed: it is the state's status at the time of the run. Naming "Rejected", "Reserved", "Expired Reservation" or "Reserved Cancel" here delivers those rows too. ## `includeRejectedAndReserved` (type: `boolean`): Connecticut's 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 not delivered and not charged. Turn this on to receive them too. Colorado has no such rows. ## `maxItems` (type: `integer`): Stop after this many business rows (all states together, newest registrations first). This is also your cost cap: 1,000 rows cost 2 USD. Your account's spending limit for the run is respected as well. ## Actor input object example ```json { "states": [ "CO", "CT" ], "onlyNew": false, "registrationKind": "all", "includeRejectedAndReserved": false, "maxItems": 25 } ``` # Actor output Schema ## `businesses` (type: `string`): No description ## `summary` (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 '' with your token const client = new ApifyClient({ token: '', }); // Prepare Actor input const input = { "states": [ "CO", "CT" ], "maxItems": 25 }; // Run the Actor and wait for it to finish const run = await client.actor("far003/us-new-business-registrations").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 '' with your token. client = ApifyClient("") # Prepare the Actor input run_input = { "states": [ "CO", "CT", ], "maxItems": 25, } # Run the Actor and wait for it to finish run = client.actor("far003/us-new-business-registrations").call(run_input=run_input) # Fetch and print Actor results from the run's dataset (if there are any) print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}") for item in client.dataset(run.default_dataset_id).iterate_items(): print(item) # 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start ``` ## CLI example ```bash echo '{ "states": [ "CO", "CT" ], "maxItems": 25 }' | apify call far003/us-new-business-registrations --silent --output-dataset ``` ## MCP server setup ```json { "mcpServers": { "apify": { "type": "http", "url": "https://mcp.apify.com/?tools=fetch-actor-details,far003/us-new-business-registrations" } } } ``` 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 ` 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/J9pZUwaUvHrNiteG9/builds/GXw3HbdRH8qnpl7gq/openapi.json