# New Business Filings USA - Newly Registered LLCs & Companies (`kadi_bence/us-new-business-filings`) Actor

Get newly registered US companies (LLCs, corporations, nonprofits) from state registries: New York, Colorado, Connecticut, Oregon. Input: states, filed-within days, entity types, name keywords, NAICS, ZIP. Returns per filing: name, entity type, filing date, city, ZIP, NAICS. Default: 20 filings.

- **URL**: https://apify.com/kadi_bence/us-new-business-filings.md
- **Developed by:** [Bence Kadi](https://apify.com/kadi_bence) (community)
- **Categories:** Lead generation, Marketing, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.25 / 1,000 filings

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 USA: newly registered LLCs and companies

Get a daily list of **newly registered LLCs, corporations, nonprofits and partnerships** from the official Secretary of State registries of **New York, Colorado, Connecticut and Oregon**. One flat row per filing as JSON, CSV or Excel: name, entity type, filing date, city, ZIP, county, NAICS industry (Connecticut) and registered-agent company. No API key, no login.

### What is New Business Filings USA?

This Actor reads the official open-data portals (Socrata APIs) of four US states and merges their formats into one schema. You pick states, a date window and filters, and get every business registered in that window. It outputs **company data only**: no people's names, e-mails, phone numbers or home addresses.

**Who uses it and why:**

- **Service providers** (accountants, insurance agents, banks, payroll and POS providers, web designers, sign makers) reach new companies in their first weeks, when they buy these services.
- **Market researchers** follow business-formation trends by state, industry (NAICS), ZIP code and entity type.
- **Expansion watchers** spot out-of-state companies registering in a state.
- **Compliance and KYB teams** check a new counterparty's entity ID, type, formation date and jurisdiction.
- **Local economic development offices and journalists** track new businesses in their area.
- **Data products and AI agents** use it as a fresh, legally sourced company-formation feed.

#### Data fields

Examples are from real runs on 2026-10-05.

| Field | Description | Example |
|---|---|---|
| `id` | Unique ID: state code + entity ID | `NY-8036903` |
| `state` | State registry the filing comes from | `NY` |
| `stateName` | Full state name | `New York` |
| `entityId` | The state's own entity or registry number | `8036903` |
| `entityName` | Business name as registered | `C&G CLEANING SOLUTIONS LLC` |
| `entityType` | Entity type in one common vocabulary | `LLC` |
| `entityTypeCategory` | Type as a filter value | `llc` |
| `entityTypeRaw` | Entity type exactly as the state writes it | `Domestic limited liability company (DLLC)` |
| `domestic` | `true` = formed in this state, `false` = foreign | `true` |
| `formationJurisdiction` | State or country where the company was formed | `CO` |
| `filingDate` | Filing, formation or registration date | `2026-10-03` |
| `status` | Status in the registry | `Good Standing` |
| `addressStreet` | Street, only for clear business premises | `418 BROADWAY, STE N` |
| `addressCity` | City of the business address | `ALBANY` |
| `addressState` | State of the business address | `NY` |
| `addressZip` | 5-digit ZIP code | `12207` |
| `addressCountry` | Address country, when published | `United States` |
| `county` | County (New York only) | `Albany` |
| `streetWithheld` | `true` when a possible home street was withheld | `true` |
| `naicsCode` | NAICS industry code (Connecticut only) | `561730` |
| `naicsTitle` | NAICS industry name (Connecticut only) | `Landscaping Services` |
| `registeredAgent` | Registered agent, only when it is an organisation | `NORTHWEST REGISTERED AGENT LLC` |
| `registryUrl` | Registry page (Oregon only) | `http://egov.sos.state.or.us/br/pkg_web_name_srch_inq.do_name_srch?...` |
| `recordUrl` | Official open-data record (company columns only) | `https://data.ct.gov/resource/n7gp-d28j.json?accountnumber=3527899&...` |
| `source` | Portal and dataset ID | `data.ct.gov (n7gp-d28j)` |
| `license` | Licence or terms of the source dataset | `Public Domain (Connecticut Secretary of the State)` |
| `isNew` | Only in monitoring mode: `true` for filings not delivered before | `true` |
| `scrapedAt` | When the Actor saved the item (UTC) | `2026-10-05T04:53:55Z` |

**Use cases:** Generate leads (local business prospecting, build B2B prospect lists) · Research markets & competitors (discover startups & new launches, build market datasets) · Developer tools (extract government & public data).

### How to use the new business filings scraper

1. Click **Try for free** (you need a free Apify account).
2. Pick the **States** and a date window, for example **Filed within the last N days** = 3.
3. Optionally set **Entity types**, **Formed in**, **Keywords**, **ZIP codes** or **NAICS codes**.
4. Set **Max results** (prefill 30, about 3 seconds) and click **Start**.
5. Download the results from the **Output** tab as CSV, Excel or JSON.
6. For a lead feed, turn on **Only new filings** and add a daily **Schedule**.

#### Input guide

**States.** `NY`, `CO`, `CT`, `OR`. Leave empty for all four. Other states, such as Texas, are not included (see the FAQ).

**Date window.** The filing, formation or registration date in the registry.

- **Filed within the last N days** = the last N days plus today. `3` suits a daily run, `7` a weekly one. Maximum 3,650.
- **Filed from / to** (YYYY-MM-DD) is for backfills, for example `2026-09-01` to `2026-09-30`. **Filed from** wins over "last N days". If all three are empty, the Actor uses the last 7 days.
- Warning: Oregon is weekly, so a 3-day window often has no Oregon rows. Use 10 days or more, or a daily schedule with **Only new filings**.
- Note: New York and Oregon list active businesses only, so old backfills miss closed companies.

**Entity types.** `llc`, `corporation`, `nonprofit`, `partnership`, `cooperative`, `other`, `assumed_name`. Empty = everything except assumed names.

- Good: `["llc", "corporation"]` for companies that buy B2B services.
- Tip: `assumed_name` (DBAs) exists only in Oregon. These are mostly sole proprietors, so they come only when selected, never with a street.

**Formed in.** `domestic` = brand-new businesses formed in that state. `foreign` = companies formed elsewhere (often Delaware) registering to do business there.

**Keywords in the business name.** Case-insensitive; several lines = any of them. Up to 50.

- Good: `construction`, `dental`, `logistics`.
- Bad: `dental clinic in Denver`. Use ZIP codes for places.
- Tip: it is a substring match, so `dent` also finds `ACCIDENT`. Use full words.

**NAICS codes** (Connecticut only). Prefixes of 2 to 6 digits: `54` = professional services, `5415` = IT services. Setting this limits the run to Connecticut; `RUN_SUMMARY` says why the other states were skipped.

**ZIP codes.** ZIP codes or prefixes (1 to 5 digits) of the business address.

- Good: `10001`, `100` (Manhattan), `802` (Denver area).
- Bad: `10001-1234` or `NY 10001`. Only digits are accepted; otherwise the run stops with a clear error.
- Tip: there is no city or county filter. Use ZIP prefixes, or filter the exported `addressCity` and `county` columns (county: New York only).

**Max results.** Stop after N filings (`0` = no limit). Shared round-robin between states, newest first, so even 30 results show every state with data. Also your cost cap: 1,000 filings cost $1.25.

**Only new filings** and **Monitor name.** The Actor remembers delivered filings and outputs only new ones on the next run with the same filters, so you pay only for new filings. Changing the date window keeps the list; changing any other filter starts a new one. Use one monitor name per schedule.

**Socrata app token** (optional). Not needed; the Actor retries when throttled. Your own free token gives your runs their own quota. Stored encrypted, never logged.

#### Input example: new LLCs and corporations in Manhattan and Denver this week

```json
{
  "states": ["NY", "CO"],
  "filedWithinDays": 7,
  "entityTypes": ["llc", "corporation"],
  "formation": "domestic",
  "zipCodes": ["100", "802"],
  "maxResults": 500,
  "onlyNewFilings": true
}
```

### Output

Each filing is one item in the run's dataset. This is a real New York filing from a run on 2026-10-05:

```json
{
  "id": "NY-8036903",
  "state": "NY",
  "stateName": "New York",
  "entityId": "8036903",
  "entityName": "C&G CLEANING SOLUTIONS LLC",
  "entityType": "LLC",
  "entityTypeCategory": "llc",
  "entityTypeRaw": "DOMESTIC LIMITED LIABILITY COMPANY",
  "domestic": true,
  "formationJurisdiction": "NY",
  "filingDate": "2026-10-03",
  "status": "Active",
  "addressStreet": "418 BROADWAY, STE N",
  "addressCity": "ALBANY",
  "addressState": "NY",
  "addressZip": "12207",
  "addressCountry": null,
  "county": "Albany",
  "streetWithheld": false,
  "naicsCode": null,
  "naicsTitle": null,
  "registeredAgent": "NORTHWEST REGISTERED AGENT LLC",
  "registryUrl": null,
  "recordUrl": "https://data.ny.gov/resource/n9v6-gdp6.json?dos_id=8036903&$select=dos_id,current_entity_name,...",
  "source": "data.ny.gov (n9v6-gdp6)",
  "license": "Open NY Terms of Use (no restrictions on reuse; source: New York State Department of State)",
  "scrapedAt": "2026-10-05T04:53:55Z"
}
```

A Connecticut row adds the industry, for example `"naicsTitle": "Landscaping Services"`. When the street could be a home address: `"addressStreet": null`, `"streetWithheld": true`, with city, state and ZIP still filled.

**Fill rates** (live 7-day run, 8,990 filings): city and ZIP 99.5%, formation state 99.9%, county 100% in New York, NAICS 98% in Connecticut, registered-agent company 18-41% depending on the state, business street 24%.

**Dataset views.** The **Output** tab shows two tables:

- **New filings**: the main columns, best for daily review.
- **All company fields**: adds entity ID, official type, formation, status, street and links.

Every run also saves a **Run summary** (`RUN_SUMMARY` in the key-value store): date window, filings saved and skipped, and per state the requests, rows read, filings saved, dataset update time (`datasetLastModified`) and any error.

**Export.** Download any view as JSON, CSV, Excel, XML, HTML or RSS, or send results to Google Sheets with the Google Sheets integration.

### Pricing

This Actor uses **pay per event**: **$1.25 per 1,000 filings** saved ($0.00125 per filing). Apify also charges a start fee of **$0.00005 per run**. Platform compute is included in the price.

| Typical run | Filings | Cost |
|---|---|---|
| First test with the prefilled input | 30 | about $0.04 |
| One export of 1,000 filings | 1,000 | about $1.25 |
| A full week of all four states (live test) | 8,990 | about $11.24 |
| Daily alert for Connecticut only, about 170 new filings a day, for 30 days | 5,100 | about $6.38 per month |

All four states daily (about 1,500 new businesses a day) cost about $1.88 per day.

**What is free:**

- In monitoring mode, filings that were already delivered in earlier runs are skipped and not charged.
- A search with no matches costs only the $0.00005 start fee.
- Apify's free plan's monthly credit covers a few thousand filings.

Cap spending with **Max results** or **Max charge per run**; the Actor then stops cleanly and keeps what it saved.

### Use it via API

Replace `MY_APIFY_TOKEN` with your token from Apify Console > Settings > API & Integrations.

**JavaScript / Node.js** (`npm install apify-client`):

```javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: 'MY_APIFY_TOKEN' });
const run = await client.actor('kadi_bence/us-new-business-filings').call({
    states: ['NY', 'CO'],
    filedWithinDays: 7,
    entityTypes: ['llc', 'corporation'],
    formation: 'domestic',
    zipCodes: ['100', '802'],
    maxResults: 500,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items.length, items[0]?.entityName);
```

**Python** (`pip install apify-client`):

```python
from apify_client import ApifyClient

client = ApifyClient("MY_APIFY_TOKEN")
run = client.actor("kadi_bence/us-new-business-filings").call(run_input={
    "states": ["CT"],
    "naicsCodes": ["54"],
    "filedWithinDays": 30,
    "maxResults": 1000,
})
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["entityName"], item["naicsTitle"], item["addressCity"], item["filingDate"])
```

**cURL** (runs the Actor and returns the items in one call):

```bash
curl -X POST "https://api.apify.com/v2/acts/kadi_bence~us-new-business-filings/run-sync-get-dataset-items?token=MY_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"states": ["CO"], "formation": "foreign", "filedWithinDays": 30, "maxResults": 200}'
```

**Apify CLI:**

```bash
apify call kadi_bence/us-new-business-filings --input '{"states": ["NY"], "entityTypes": ["llc"], "filedWithinDays": 3, "maxResults": 50}' --output-dataset
```

**MCP (AI agents such as Claude, Cursor or VS Code).** Add this to your MCP client config. The client will ask you to sign in to Apify (or send your token as an `Authorization: Bearer` header):

```json
{"mcpServers":{"apify":{"url":"https://mcp.apify.com/?actors=kadi_bence/us-new-business-filings"}}}
```

Then ask: "List new construction LLCs registered in Colorado this week".

### Integrations and scheduling

- **Schedules.** In Apify Console go to **Schedules > Create new**, pick this Actor (or a saved task) and set a time, for example every day at 07:00.
- **Webhooks.** Call your own URL when a run succeeds or fails.
- **Zapier, Make and n8n.** "Run Actor" as an action or "Actor run finished" as a trigger, then send rows to Slack, e-mail or a CRM such as HubSpot or Pipedrive. `id` is stable, so use it to avoid duplicates.
- **Google Sheets.** The Google Sheets integration on the **Integrations** tab appends each run's results to a sheet.

**Recipe: new businesses in my area every morning**

1. Set **Entity types** = LLC and Corporation, **Formed in** = Domestic, your **ZIP codes**, **Filed within the last N days** = 3.
2. Turn on **Only new filings** with a monitor name such as `denver-llcs`.
3. **Save as a new task** and schedule it daily at 07:00.
4. Connect it to Google Sheets, Slack or your CRM. Each morning you get only businesses you have not seen.

**Recipe: weekly expansion watch.** **Formed in** = Foreign, all states, last 10 days (this catches Oregon's weekly update), **Only new filings** on, weekly schedule, to a sheet.

### Related actors by the same developer

- [SEC Form D Scraper](https://apify.com/kadi_bence/sec-form-d-funding): startup funding rounds from SEC EDGAR.
- [Bulk WHOIS & RDAP Domain Lookup](https://apify.com/kadi_bence/domain-whois-lookup): check whether new companies already own a website domain.

### Personal-data policy (GDPR / CCPA)

Registries also hold data about people, often with a home address. This Actor outputs **company-level data only**:

- **Never output:** people's names, e-mail addresses, phone numbers and ownership demographics (woman-, minority-, veteran- or LGBTQI-owned flags). These columns are **not even downloaded**: every request asks only for company columns.
- **Registered agent:** only when it is an organisation, such as `LEGALZOOM USCA, INC.`. An individual agent gives an empty field.
- **Street address:** only for a clear business premises (suite, floor, building, office or business park). Otherwise you get **city, state, ZIP and county only** (`streetWithheld: true`). DBAs and general partnerships never get a street.
- **Business names** are public company identifiers and are output as registered. Some are named after their owner, so follow the marketing laws that apply to you (CAN-SPAM, TCPA, GDPR).

### FAQ

**How does it work, and where does the data come from?**
The Actor sends your filters to each state's official open-data portal (the Socrata SODA API) and converts the results to one schema. It does not scrape any Secretary of State search website. The sources:

| State | Dataset | Publisher | Licence / terms |
|---|---|---|---|
| New York | [Active Corporations: Beginning 1800](https://data.ny.gov/d/n9v6-gdp6) | NY Department of State, Division of Corporations | Open NY Terms of Use: free reuse, no attribution or share-alike required; only unlawful use is prohibited |
| Colorado | [Business Entities in Colorado](https://data.colorado.gov/d/4ykn-tg5h) | Colorado Department of State | Public Domain |
| Connecticut | [Connecticut Business Registry - Business Master](https://data.ct.gov/d/n7gp-d28j) | Office of the Secretary of the State | Public Domain |
| Oregon | [Active Businesses - ALL](https://data.oregon.gov/d/tckn-sxa6) | Secretary of State, Corporation Division | Public domain under Oregon law (ORS 276A.368: "All publishable data is in the public domain") |

Each row carries its `license` and a `recordUrl` back to the official record. This Actor is not affiliated with any state government. The data comes as is, without any guarantee of completeness or accuracy.

**Why only these four states? Is Texas included?**
No. These four publish their registry as daily or weekly open data under an open licence. Texas's dataset states no licence or reuse terms; Pennsylvania's has one row per organiser (a named person) and updates monthly; Florida, California and most other states have no free open-data API for new filings. More states will be added when they publish under an open licence.

**How fresh is the data?**
New York, Colorado and Connecticut update daily; a filing usually appears 1 to 2 days after its filing date. Oregon updates weekly, so its newest filings can be up to about 8 days old. `RUN_SUMMARY` shows each dataset's last update (`datasetLastModified`).

**Are there limits? How fast is it?**
A run reads at most 2 million rows per state. Each request returns up to 5,000 rows, so 30 filings take about 3 seconds, 1,000 take 3 to 11 seconds, and a full week of all four states (8,990) took 12 seconds. The Actor follows the portals' robots.txt (1-second crawl delay) and retries when throttled.

**Why are my results different from the state websites?**
The open-data datasets update daily (Oregon weekly) while the search websites are live; the New York and Oregon datasets list active businesses only; and DBAs are left out unless selected. In our live test, counts matched the portals' own record counts exactly.

**Is it legal? What about personal data?**
Yes: the data is official open data published for reuse, and only company data is output (see the policy above).

**Can I use it from Python, Google Sheets, Slack or my CRM?**
Yes. See **Use it via API** (JavaScript, Python, cURL, CLI, MCP) and **Integrations and scheduling** above.

**How does "Only new filings" work?**
The Actor stores the IDs of delivered filings in a named key-value store in your account. The next run with the same filters and monitor name outputs only filings not in that list, marked `isNew: true`. Filings cut off by **Max results** are not stored, so they come next run.

**What if a run fails or something looks wrong?**
Invalid input (such as a ZIP code with letters) or a rejected app token stops the run with a clear message. If one state's portal is down, the other states are still delivered and `RUN_SUMMARY` shows the error. Please open an issue on the **Issues** tab with the run link. Fixes usually land within 24 to 48 hours.

**What changed recently?**
See the changelog below.

### Need a custom version?

I build custom scrapers, scheduled data feeds and integrations (CSV, Excel, Google Sheets, API, MCP for AI agents). Tell me the sites and fields you need:

- Email: bence.kadi@gmail.com
- Apify profile: https://apify.com/kadi_bence

### Related Actors

More low-cost Actors by the same developer, built on official APIs and public data:

- [SEC Form D Scraper](https://apify.com/kadi_bence/sec-form-d-funding) — new startup funding rounds from SEC EDGAR
- [Bulk WHOIS & RDAP Domain Lookup](https://apify.com/kadi_bence/domain-whois-lookup) — registrar, dates and DNS for many domains
- [Website Tech Stack Detector](https://apify.com/kadi_bence/tech-stack-detector) — CMS, ecommerce, analytics and frameworks of any website
- [SAM.gov Scraper](https://apify.com/kadi_bence/sam-gov-scraper) — US federal contract opportunities and awards
- [Greenhouse, Lever & Ashby Jobs Scraper](https://apify.com/kadi_bence/ats-jobs-scraper) — all open jobs of a company from 6 applicant systems, plus Workday
- [Website Screenshot & PDF API](https://apify.com/kadi_bence/website-screenshot) — full-page screenshots and PDFs of any URL
- [SEO Site Audit](https://apify.com/kadi_bence/seo-site-audit) — 0-100 SEO score per page, broken links and fix hints

All my Actors: [apify.com/kadi_bence](https://apify.com/kadi_bence)

### Changelog

- **1.0 (2026-10-05):** First release.
  - New York, Colorado, Connecticut and Oregon, in one normalised schema.
  - Filters: entity type, domestic or foreign, name keywords, ZIP prefixes and NAICS codes.
  - Round-robin across states and monitoring mode.
  - Company data only, with no personal data.

# Actor input Schema

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

State registries to read. Leave empty for all four. New York, Colorado and Connecticut update daily; Oregon weekly, so use a window of 10+ days to get Oregon rows. Other states (e.g. Texas) are not included.

## `filedWithinDays` (type: `integer`):

e.g. 3 for the last three days plus today (good for a daily run), 7 for a week. Ignored when 'Filed from' is set. Leave empty to use the date range below (or the last 7 days when both are empty).

## `filedFrom` (type: `string`):

First filing / formation date (YYYY-MM-DD).

## `filedTo` (type: `string`):

Last filing / formation date (YYYY-MM-DD).

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

Leave empty for all types except assumed business names. Assumed names (DBAs, Oregon only) are mostly sole proprietors and are only returned when you select them; their street address is never output.

## `formation` (type: `string`):

Domestic = formed in that state (brand-new businesses). Foreign = companies from another state or country registering to do business there (expansion signal).

## `nameKeywords` (type: `array`):

Case-insensitive words in the business name, e.g. 'construction', 'dental', 'capital'. Several lines = any of them (up to 50). It is a substring match, so use full words.

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

Only Connecticut publishes the industry code of new businesses. Prefixes work: 54 = all professional services, 5415 = IT services. Setting this limits the run to Connecticut.

## `zipCodes` (type: `array`):

ZIP codes or prefixes (1 to 5 digits) of the business address, e.g. 10001 or 100 (Manhattan) or 80 (most of Colorado). Digits only.

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

Stop after this many filings (newest first, shared round-robin between the states, so small runs still show every state). 0 = no limit. The default without input (API, MCP and AI-agent calls) is 20.

## `onlyNewFilings` (type: `boolean`):

Remember returned filings and output only NEW ones on the next runs with the same filters (the date window can change). Ideal for a daily schedule: you only pay for new businesses.

## `monitorName` (type: `string`):

Keeps separate 'already seen' lists for different schedules.

## `socrataAppToken` (type: `string`):

Not needed. The state portals throttle anonymous traffic shared by many users; your own free Socrata app token (create one in any portal's developer settings) gives this run its own quota. Stored encrypted, never logged or saved.

## Actor input object example

```json
{
  "states": [
    "NY",
    "CO",
    "CT",
    "OR"
  ],
  "filedWithinDays": 3,
  "formation": "any",
  "maxResults": 30,
  "onlyNewFilings": false,
  "monitorName": "default"
}
```

# Actor output Schema

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

Newly registered businesses (table view).

## `filingsFull` (type: `string`):

Every field of every filing.

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

Per-state rows read, filings saved, dataset freshness and any problems.

# 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 = {
    "states": [
        "NY",
        "CO",
        "CT",
        "OR"
    ],
    "filedWithinDays": 3,
    "maxResults": 30
};

// Run the Actor and wait for it to finish
const run = await client.actor("kadi_bence/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 = {
    "states": [
        "NY",
        "CO",
        "CT",
        "OR",
    ],
    "filedWithinDays": 3,
    "maxResults": 30,
}

# Run the Actor and wait for it to finish
run = client.actor("kadi_bence/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 '{
  "states": [
    "NY",
    "CO",
    "CT",
    "OR"
  ],
  "filedWithinDays": 3,
  "maxResults": 30
}' |
apify call kadi_bence/us-new-business-filings --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,kadi_bence/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/b9qHr89gktX2oXjpV/builds/H4KGOLW3hqbXx89tf/openapi.json