# US State Business Registry Scraper (`nanodata/us-state-business-registry-scraper`) Actor

Search official US state business registers (New York, Colorado, Connecticut, Oregon) by name or formation date. Entity id, type, status, formation date, registered agent and addresses. Pay per company.

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

## Pricing

from $1.50 / 1,000 company scrapeds

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

## US State Business Registry Scraper

Read companies from the official business registers of US states: New York, Colorado, Connecticut and Oregon. Search by name or by formation date and get one clean row per company with the entity id, type, status, formation date, registered agent and addresses.

The data comes from the official public register of each state, published on the state's open data portal. The actor adds nothing from other sources and does not combine records with other data. Each row also carries the original columns of the register in the `raw` field.

Data comes from the open data portals of [New York](https://data.ny.gov/), [Colorado](https://data.colorado.gov/), [Connecticut](https://data.ct.gov/) and [Oregon](https://data.oregon.gov/).

### What you get

- Companies from up to four state registers in one run, in one common layout.
- Filter by part of the name and by formation date.
- The original register columns next to the common fields, so nothing the register publishes is lost.
- A link to the record in the register data on every row.

### Covered states and datasets

| State | Portal | Dataset | Dataset id | What it holds |
|---|---|---|---|---|
| New York | data.ny.gov | Active corporations | n9v6-gdp6 | Active corporations and other entities of the Department of State |
| Colorado | data.colorado.gov | Business entities in Colorado | 4ykn-tg5h | Entities of every status, including dissolved ones |
| Connecticut | data.ct.gov | Connecticut business registry | n7gp-d28j | Business registry master list with status, annual report due date and business email |
| Oregon | data.oregon.gov | Active businesses | tckn-sxa6 | Active businesses; the register lists one row per role (principal place, mailing address, registered agent), the actor joins them into one company |

### Input

| Field | Type | Meaning |
|---|---|---|
| `states` | list | Registers to read, in this order. Use `NY`, `CO`, `CT`, `OR`. Default: `["NY"]`. |
| `nameContains` | text | Only companies whose name contains this text. Upper and lower case do not matter. |
| `formedAfter` | date | Only companies formed on or after this date, for example `2025-01-31`. |
| `maxResults` | number | Maximum number of companies in total across all states. Default 100, form prefill 40, up to 100000. With several states the total is split between them. |

Example 1: forty companies from New York.

```json
{
  "states": ["NY"],
  "maxResults": 40
}
```

Example 2: companies with "bakery" in the name that were formed in 2025 or later, in two states.

```json
{
  "states": ["CO", "CT"],
  "nameContains": "bakery",
  "formedAfter": "2025-01-01",
  "maxResults": 500
}
```

Example 3: all Oregon businesses whose name contains "brewing".

```json
{
  "states": ["OR"],
  "nameContains": "brewing",
  "maxResults": 100000
}
```

States are read one after the other. Each state gets an equal share of `maxResults` (rounded up, for example 25 each for four states and 100). What a state cannot fill, because it holds fewer matches, passes on to the states after it.

### Output fields

| Field | Meaning |
|---|---|
| `state` | Two-letter state code |
| `entityId` | Entity id in the state register (Connecticut: the account number) |
| `name` | Entity name as published |
| `entityType` | Entity type as published (Colorado publishes short codes such as DPC) |
| `status` | Status as published. New York and Oregon list active entities only, so their rows show `Active` |
| `formationDate` | Formation or registration date, `YYYY-MM-DD` |
| `jurisdiction` | Jurisdiction of formation as published |
| `registeredAgentName` | Registered agent as published (New York, Colorado, Oregon) |
| `registeredAgentAddress` | Registered agent address as published |
| `principalAddress` | Principal address as published. New York: the location address. Connecticut: the business address |
| `mailingAddress` | Mailing address as published |
| `email` | Business email, only where the register publishes it (Connecticut) |
| `sourceDataset` | Portal and dataset id the row was read from |
| `sourceUrl` | Address of the record in the register data (Oregon: the register's own lookup link) |
| `raw` | The original columns of the register. For Oregon: `{"rows": [...]}` with the rows of the company |
| `scrapedAt` | Time of collection (UTC) |

Fields a register does not publish are `null`.

### Output sample

```json
{
  "state": "NY",
  "entityId": "100",
  "name": "SEAMEN'S SOCIETY FOR CHILDREN AND FAMILIES",
  "entityType": "DOMESTIC NOT-FOR-PROFIT CORPORATION",
  "status": "Active",
  "formationDate": "1851-01-01",
  "jurisdiction": "New York",
  "registeredAgentName": "THE SOCIETY FOR SEAMEN'S CHILDREN",
  "registeredAgentAddress": "26 BAY ST., STATEN ISLAND, NEW YORK 10301",
  "principalAddress": null,
  "mailingAddress": null,
  "email": null,
  "sourceDataset": "data.ny.gov/n9v6-gdp6",
  "sourceUrl": "https://data.ny.gov/resource/n9v6-gdp6.json?dos_id=100",
  "raw": {"dos_id": "100", "current_entity_name": "SEAMEN'S SOCIETY FOR CHILDREN AND FAMILIES", "county": "Richmond"},
  "scrapedAt": "2026-11-12T10:00:00Z"
}
```

### Pricing

Pay per event.

| Event | When it is charged | Price |
|---|---|---|
| `actor-start` | Once per run, together with the first delivered company | $0.001 |
| `company-result` | For each company delivered to the dataset | $0.0015 |

A run that finds no company is not charged. If you set a maximum charge per run, the actor stops cleanly when it is reached.

**New to Apify?** Every account gets a $5 free monthly platform credit, enough for a first test run before you pay anything.

### Limitations

- Only New York, Colorado, Connecticut and Oregon are covered. More states can be added when their datasets are confirmed.
- The columns differ from state to state. The common fields are filled where the register has a matching column; the rest is in `raw`.
- The registers are published as open data and are updated by the states on their own schedule. A very recent filing may not be there yet.
- Registered agents and addresses can belong to private persons. The actor passes on only what the official register publishes and does not add anything.
- `nameContains` is a contains match on the name column of the register. It is not a fuzzy search.
- The portals ask for one request per second, so a large run takes time: about 1000 companies per request, one request per second.
- If a portal asks the actor to slow down, the actor waits (5, 15 and 45 seconds), then gives up on that state, keeps the companies already delivered and goes on with the next state. The final status says so.
- If the source does not let a run through at all, the run ends with a short message, writes it to the `OUTPUT` record and charges nothing.
- The actor is not an official service of any state, and a missing company in the result is not proof that it does not exist.

### FAQ

**Is the data official?**
Yes. Every row comes from the open data set that the state publishes for its business register. The `sourceDataset` field names it.

**Can I get all companies of a state?**
Yes, set `maxResults` to a large number. New York and Colorado hold millions of rows, so expect a long run and a large bill. Use `maxResults` to set the limit you want to pay for.

**Why are there fewer companies than I asked for?**
The registers held no more matches for your filters. The final status says "the registers held no more".

**Why is `status` always `Active` for New York and Oregon?**
Those two datasets list active entities only.

**Does it find people?**
No. It reads companies. Names of registered agents appear only where the register publishes them for a company.

**Which date does `formedAfter` use?**
The formation or registration date column of each register.

**What happens if the run is restarted?**
The actor saves its position after every delivered batch. A restarted run continues where it stopped and does not charge the same companies twice.

### Use with AI agents (MCP)

Connect this actor to any MCP-compatible AI client, such as Claude Desktop, Cursor, VS Code, LangChain or LlamaIndex.

**MCP server URL:**

```
https://mcp.apify.com?tools=nanodata/us-state-business-registry-scraper
```

**Example prompt once connected:**

> "Use `us-state-business-registry-scraper` to search the state registries for businesses named Acme and show status and filing date. Return results as a table."

### Related Actors

- [France Company Registry Scraper](https://apify.com/nanodata/france-company-registry-scraper): Search the French business register by keyword, activity code, department, postal code and more.
- [UK Companies House Scraper](https://apify.com/santamaria-automations/uk-companies-house-scraper): Search UK Companies House for company records.
- [SEC EDGAR Filings Scraper: 10-K, 10-Q, 8-K and Company Data](https://apify.com/santamaria-automations/sec-edgar-filings-scraper): Get SEC EDGAR filings by ticker, CIK or company name, or search filing text.

### Support

Found a problem or need a field added? Open an issue on the [Issues tab](https://apify.com/nanodata/us-state-business-registry-scraper/issues). We usually reply within one business day. You can also email contact@nanoscrape.com.

# Actor input Schema

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

Which state registers to read, in this order. Default: New York.

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

Only companies whose name contains this text (upper and lower case do not matter). Leave empty for all companies.

## `formedAfter` (type: `string`):

Only companies formed on or after this date, as 2025-01-31. Leave empty for all dates.

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

Maximum number of companies in total across all states. Default 100.

## Actor input object example

```json
{
  "states": [
    "NY"
  ],
  "maxResults": 40
}
```

# Actor output Schema

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

One row per company

# 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"
    ],
    "maxResults": 40
};

// Run the Actor and wait for it to finish
const run = await client.actor("nanodata/us-state-business-registry-scraper").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"],
    "maxResults": 40,
}

# Run the Actor and wait for it to finish
run = client.actor("nanodata/us-state-business-registry-scraper").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"
  ],
  "maxResults": 40
}' |
apify call nanodata/us-state-business-registry-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,nanodata/us-state-business-registry-scraper"
        }
    }
}
```

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/eblZNeDLd8ZMQC7qJ/builds/6DQwydvgwFW5etB3K/openapi.json
