# US Business Entity Search (`straightforward_hydra/us-business-entity-search`) Actor

Search US state business & corporation registries (NY, Colorado, Connecticut, Delaware) via official open-data APIs. No key.

- **URL**: https://apify.com/straightforward\_hydra/us-business-entity-search.md
- **Developed by:** [Dev D](https://apify.com/straightforward_hydra) (community)
- **Categories:** Lead generation, Developer tools, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $5.00 / 1,000 business entities

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/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.
Actors are written with capital "A".

## 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.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js/docs.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## US Business Entity Search 🏢

**Search US state business & corporation registries — New York, Colorado, Connecticut and Delaware — straight from official state open-data portals. No API key, no proxy.**

Find registered companies across multiple US states in one run: entity name, ID, type, status, formation/registration date, address, and — where the state publishes it — the **registered agent's name and address**. Filter by name, entity type, status, city, or formation date.

Perfect for **B2B lead generation** (reach newly formed companies), sales prospecting, KYC/due-diligence, supplier-diversity sourcing, and market research.

> Data comes from each state's **official open-data portal** (Socrata). Public business-registry records. No key required (an optional free Socrata app token raises rate limits).

---

### Supported states

| State | Registry | Highlights |
|---|---|---|
| **New York** | Active corporations (4.2M+) | Entity name, type, county, DOS process agent + address |
| **Colorado** | Business entities | Status, entity type, **registered agent name + address**, formation date |
| **Connecticut** | Business registry master | Status + **woman / veteran / minority / LGBTQ-owned flags** |
| **Delaware** | Business licenses | License category, validity dates, address |

One normalized schema across all of them — mix and match states in a single run.

### Features

- ✅ **No API key, no proxy** — official open-data APIs, very low maintenance.
- ✅ **Newly formed companies** — set `registeredAfter` to get fresh business leads.
- ✅ **Registered agent data** — Colorado & NY carry agent name/address (great for outreach).
- ✅ **Supplier diversity** — Connecticut woman/veteran/minority/LGBTQ-owned filter.
- ✅ **Normalized output** — same fields for every state; optional raw record included.

---

### Input

| Field | Description |
|---|---|
| **States** | Which registries to search (default: all four). |
| **Entity name contains** | Filter by company-name text. |
| **Entity type contains** | Filter by type text (see note below on state phrasing). |
| **Status contains** | Filter by status (e.g. "good standing"). |
| **City** | Filter by city (where the state exposes it). |
| **Registered/formed after / before** | Formation-date range (YYYY-MM-DD). |
| **Diversity-owned only (CT)** | Connecticut: only woman/veteran/minority/LGBTQ-owned. |
| **Keyword** | Full-text search across all columns (works on every state). |
| **Max results per state** | How many entities per selected state. |

> **Entity-type phrasing differs by state.** Colorado uses codes like `DLLC`; New York spells it out (`DOMESTIC LIMITED LIABILITY COMPANY`, `DOMESTIC BUSINESS CORPORATION`). Use `LLC` for Colorado, `LIMITED LIABILITY` for New York, or use the broad `keyword` field.

#### Example — brand-new Colorado LLCs (lead gen)

```json
{
  "states": ["co"],
  "entityTypeContains": "LLC",
  "registeredAfter": "2025-01-01",
  "maxResultsPerState": 1000
}
````

#### Example — Connecticut minority-owned businesses

```json
{
  "states": ["ct"],
  "diversityOwnedOnly": true,
  "maxResultsPerState": 500
}
```

### Output

```json
{
  "state": "CO",
  "source": "Colorado",
  "entity_name": "Redline Lighting LLC",
  "entity_id": "20261862530",
  "entity_type": "DLLC",
  "status": "Good Standing",
  "formation_date": "2026-07-16",
  "jurisdiction": "CO",
  "address": "3684 G 4/10 Rd",
  "city": "Palisade",
  "region_state": "CO",
  "zip": "81526",
  "agent_name": "QUINN RIDDELL-BROSIG",
  "agent_address": "3684 G 4/10 Rd Palisade CO 81526",
  "source_domain": "data.colorado.gov",
  "dataset_id": "4ykn-tg5h"
}
```

Field availability varies by state (e.g. Connecticut carries diversity-ownership flags; New York carries county; Delaware carries license validity dates).

### Run it on a schedule

Set `registeredAfter` to yesterday and run daily to get a steady feed of **newly registered companies** — pipe them to a CRM, Google Sheets or a webhook for a continuously refreshed prospect list.

### Notes & limitations

- Official state **open-data** registries — public business records.
- Coverage = the states listed above (those that publish clean open data). The US has no single federal company registry, so this is multi-state by design; more states can be added.
- Some filters only apply where a state exposes the matching column (documented above).
- Data freshness depends on each state's own publishing cadence.

***

#### Keywords

US business entity search, business registry, company registry, corporation search, LLC search, registered agent, new business leads, B2B lead generation, sales prospecting, KYC, due diligence, secretary of state, New York corporations, Colorado business entities, Connecticut business registry, Delaware business licenses, company data, business data, open data, Socrata, supplier diversity, minority owned business.

# Actor input Schema

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

Which state registries to search. Leave empty for all supported states.

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

Filter by company name text, e.g. "consulting", "solar", "acme". Matches on each state's entity-name column.

## `entityTypeContains` (type: `string`):

Filter by entity type text, e.g. "LLC", "corporation", "nonprofit". Applied where the state exposes an entity-type column.

## `statusContains` (type: `string`):

Filter by status text, e.g. "good standing", "active". Applied where the state exposes a status column (NY = all active; Delaware = licensed).

## `city` (type: `string`):

Filter by city, e.g. "Denver", "Brooklyn". Applied where the state exposes a city column (Connecticut has none).

## `registeredAfter` (type: `string`):

Only entities registered/formed on/after this date (YYYY-MM-DD). Great for pulling newly formed companies as leads.

## `registeredBefore` (type: `string`):

Only entities registered/formed on/before this date (YYYY-MM-DD).

## `diversityOwnedOnly` (type: `boolean`):

Connecticut only: return just woman-, veteran-, minority- or LGBTQ-owned businesses. Useful for supplier-diversity sourcing.

## `keyword` (type: `string`):

Full-text search across all columns (works on every state). Use for broad matches when the name filter is too strict.

## `maxResultsPerState` (type: `integer`):

How many entities to fetch per selected state (newest first).

## `includeRaw` (type: `boolean`):

Add the full original state record under a "raw" field alongside the normalized fields.

## `appToken` (type: `string`):

Optional free Socrata app token (dev.socrata.com) to raise rate limits. Not required for normal runs.

## Actor input object example

```json
{
  "states": [
    "ny",
    "co",
    "ct",
    "de"
  ],
  "diversityOwnedOnly": false,
  "maxResultsPerState": 200,
  "includeRaw": false
}
```

# 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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("straightforward_hydra/us-business-entity-search").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 = {}

# Run the Actor and wait for it to finish
run = client.actor("straightforward_hydra/us-business-entity-search").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{}' |
apify call straightforward_hydra/us-business-entity-search --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=straightforward_hydra/us-business-entity-search",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "US Business Entity Search",
        "description": "Search US state business & corporation registries (NY, Colorado, Connecticut, Delaware) via official open-data APIs. No key.",
        "version": "0.1",
        "x-build-id": "Ci1kAQqDadd9cbQfn"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/straightforward_hydra~us-business-entity-search/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-straightforward_hydra-us-business-entity-search",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/straightforward_hydra~us-business-entity-search/runs": {
            "post": {
                "operationId": "runs-sync-straightforward_hydra-us-business-entity-search",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/straightforward_hydra~us-business-entity-search/run-sync": {
            "post": {
                "operationId": "run-sync-straightforward_hydra-us-business-entity-search",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "states": {
                        "title": "States",
                        "type": "array",
                        "description": "Which state registries to search. Leave empty for all supported states.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "ny",
                                "co",
                                "ct",
                                "de"
                            ],
                            "enumTitles": [
                                "New York (active corporations)",
                                "Colorado (business entities + registered agent)",
                                "Connecticut (business registry)",
                                "Delaware (business licenses)"
                            ]
                        },
                        "default": [
                            "ny",
                            "co",
                            "ct",
                            "de"
                        ]
                    },
                    "nameContains": {
                        "title": "Entity name contains",
                        "type": "string",
                        "description": "Filter by company name text, e.g. \"consulting\", \"solar\", \"acme\". Matches on each state's entity-name column."
                    },
                    "entityTypeContains": {
                        "title": "Entity type contains",
                        "type": "string",
                        "description": "Filter by entity type text, e.g. \"LLC\", \"corporation\", \"nonprofit\". Applied where the state exposes an entity-type column."
                    },
                    "statusContains": {
                        "title": "Status contains",
                        "type": "string",
                        "description": "Filter by status text, e.g. \"good standing\", \"active\". Applied where the state exposes a status column (NY = all active; Delaware = licensed)."
                    },
                    "city": {
                        "title": "City",
                        "type": "string",
                        "description": "Filter by city, e.g. \"Denver\", \"Brooklyn\". Applied where the state exposes a city column (Connecticut has none)."
                    },
                    "registeredAfter": {
                        "title": "Registered/formed after",
                        "type": "string",
                        "description": "Only entities registered/formed on/after this date (YYYY-MM-DD). Great for pulling newly formed companies as leads."
                    },
                    "registeredBefore": {
                        "title": "Registered/formed before",
                        "type": "string",
                        "description": "Only entities registered/formed on/before this date (YYYY-MM-DD)."
                    },
                    "diversityOwnedOnly": {
                        "title": "Diversity-owned only (Connecticut)",
                        "type": "boolean",
                        "description": "Connecticut only: return just woman-, veteran-, minority- or LGBTQ-owned businesses. Useful for supplier-diversity sourcing.",
                        "default": false
                    },
                    "keyword": {
                        "title": "Keyword (full-text)",
                        "type": "string",
                        "description": "Full-text search across all columns (works on every state). Use for broad matches when the name filter is too strict."
                    },
                    "maxResultsPerState": {
                        "title": "Max results per state",
                        "minimum": 1,
                        "maximum": 50000,
                        "type": "integer",
                        "description": "How many entities to fetch per selected state (newest first).",
                        "default": 200
                    },
                    "includeRaw": {
                        "title": "Include raw record",
                        "type": "boolean",
                        "description": "Add the full original state record under a \"raw\" field alongside the normalized fields.",
                        "default": false
                    },
                    "appToken": {
                        "title": "Socrata app token (optional)",
                        "type": "string",
                        "description": "Optional free Socrata app token (dev.socrata.com) to raise rate limits. Not required for normal runs."
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
