# US Business Entity Check: Verify a Company Is Real & Active (`plainfold/business-entity-check`) Actor

Verify a US company is registered and active from official state registry open data (NY, CO, OR, CT, TX). Returns verdict, legal name, registry ID, status, entity type, formation date, address. Company records only, no API key. $0.004 per company found, $0.0005 per no-match.

- **URL**: https://apify.com/plainfold/business-entity-check.md
- **Developed by:** [Plainfold](https://apify.com/plainfold) (community)
- **Categories:** Lead generation, Business, Automation
- **Stats:** 2 total users, 1 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $4.00 / 1,000 company founds

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 Business Entity Check: Verify a Company Is Real & Active

### At a glance (for AI agents)

- **What it does:** Checks whether a US company is registered with a state and whether that registration is active, using **official state business-registry open data** (New York, Colorado, Oregon, Connecticut, Texas). For each company name you give it, it returns one result: a verdict (`active`, `inactive`, `found_status_unclear`, `not_found`), the matching registrations (legal name, registry ID, entity type, status, good standing, jurisdiction, formation date, business address) and a one-sentence summary.
- **When to use it:** Before paying a vendor or supplier, onboarding a customer (KYB), qualifying a lead, checking that a company in a contract, invoice or email actually exists, or enriching a list of company names with registry IDs and status.
- **When not to use it:** People lookups (it returns **company records only**, never officers, agents or owners), states other than NY/CO/OR/CT/TX, credit or financial data, or as a legal certificate of good standing (link to the state's own record for that).
- **Cost:** pay-per-event: **$0.004 per company found**, **$0.0005 per lookup with no match**, plus **$0.0005 per run** (at the default 256 MB memory). Lookups that fail because a registry is down are not charged. 100 companies in one run cost at most about $0.40. Apify platform usage is included.
- **Speed:** about 0.2 to 1 second per company; companies are checked in parallel.
- **Auth:** no API key or account with any state. AI agents can run it through the Apify API or Apify's MCP server.
- **Input:** just `companies`, a list of names. Everything else is optional.

**Example input:**

```json
{
  "companies": ["Arrow Electronics, Inc.", "Kodak Alaris LLC", "Dell Technologies Inc. | TX"]
}
```

**Example output item** (shortened):

```json
{
  "query": "Arrow Electronics, Inc.",
  "found": true,
  "verdict": "active",
  "isActive": true,
  "activeIn": ["CO", "TX", "NY", "OR", "CT"],
  "matchCount": 6,
  "bestMatch": {
    "matchType": "exact",
    "state": "CO",
    "name": "ARROW ELECTRONICS, INC.",
    "registryId": "19871071914",
    "registryIdLabel": "CO entity ID",
    "entityType": "Foreign Profit Corporation (FPC)",
    "status": "Good Standing",
    "isActive": true,
    "goodStanding": true,
    "jurisdictionOfFormation": "NY",
    "formationDate": "1979-04-30",
    "address": { "street": "9151 E Panorama Cir", "city": "Centennial", "state": "CO", "zip": "80112", "country": "US" },
    "source": {
      "registry": "Colorado Secretary of State",
      "datasetUrl": "https://data.colorado.gov/d/4ykn-tg5h",
      "datasetUpdatedAt": "2026-10-07T11:19:38.000Z"
    }
  },
  "similarNames": [{ "name": "ARROW ELECTRONICS FUNDING CORPORATION", "state": "CO", "isActive": true }],
  "summary": "6 matching registrations. Best: ARROW ELECTRONICS, INC. (CO, Good Standing, since 1979-04-30). Active in: CO, TX, NY, OR, CT."
}
```

### How matching works

- Names are compared after removing case, punctuation, a leading "The" and differences in suffix spelling, so `Arrow Electronics Inc` matches `ARROW ELECTRONICS, INC.` and `Acme L.L.C.` matches `ACME LLC`. Leading initials (`J.P. Morgan`, `A. O. Smith`) and `and`/`&` are handled too.
- **No suffix in your query** (`Arrow Electronics`): any entity type with that name counts as a match (`matchType: "nameWithoutSuffix"`).
- **Suffix in your query** (`AT&T Corp`): if that exact entity exists, only it counts; `AT&T Inc.` is listed under `similarNames` because it is a different legal entity.
- **Similar names** (for example subsidiaries like `Arrow Electronics Funding Corporation`) are suggested in `similarNames` and never count as a match.
- Restrict a single company to one state with `"Name | XX"`, e.g. `"Dell Technologies Inc. | TX"`, or restrict the whole run with `states`.

### Verdicts

| verdict | meaning |
|---|---|
| `active` | At least one matching registration is active (`activeIn` lists the states). |
| `inactive` | Matches exist, but all are dissolved, withdrawn, forfeited, revoked or merged. |
| `found_status_unclear` | Matches exist, but the registry doesn't give a clear active/inactive status. |
| `not_found` | No registration with this name in the states searched. Check `similarNames` for spelling variants. |
| `invalid_input` | Name empty or too short, or an unsupported state was requested. Not charged. |
| `error` | Every registry lookup failed (temporary outage). Not charged; try again. |

Being `not_found` in these five states doesn't prove a company is fake: it may be registered only in another state (for example Delaware or Florida) or trade under a different legal name.

### Data sources

All sources are official state open-data portals. They are public and need no key:

| State | Registry | Coverage | Status field |
|---|---|---|---|
| NY | Department of State, Division of Corporations: [Active Corporations](https://data.ny.gov/d/n9v6-gdp6) | Active entities only | Active |
| CO | Secretary of State: [Business Entities in Colorado](https://data.colorado.gov/d/4ykn-tg5h) | All entities since 1864 | Good Standing, Delinquent, Dissolved... |
| OR | Secretary of State, Corporation Division: [Active Businesses](https://data.oregon.gov/d/tckn-sxa6) | Active registrations only | Active |
| CT | Secretary of the State: [Business Registry](https://data.ct.gov/d/n7gp-d28j) | All businesses | Active, Forfeited, Dissolved... |
| TX | Comptroller of Public Accounts: [Active Franchise Taxpayers](https://data.texas.gov/d/9cir-efmm) | Entities set up for franchise tax | Right to transact business (Active, Forfeited...) |

Every match includes `source.datasetUrl` and `source.datasetUpdatedAt` (when the state last refreshed the data), and the run's `SUMMARY` record in the key-value store lists all sources. States refresh these datasets daily to weekly. For a legal certificate of good standing, use the state's own lookup page (`source.lookupUrl`, or `recordUrl` where the state provides a direct record link).

Florida's registry (Sunbiz) is only published as bulk files, not as a queryable open-data API, so it isn't included yet.

### Privacy: company records only

This Actor never requests or returns names of people: no officers, directors, registered agents, organizers or owners. In Texas, sole-proprietor and individual taxpayer records are excluded, and address lines that name a person ("c/o", "attn") are dropped. Output is limited to the entity's own public registration data.

### Input reference

| Field | Type | Default | Description |
|---|---|---|---|
| `companies` | array of strings | (required) | Company names. Optional `" \| XX"` suffix limits one name to one state. |
| `states` | array | all: `["NY","CO","OR","CT","TX"]` | State registries to search. |
| `includeInactive` | boolean | `true` | Also return dissolved, withdrawn and forfeited registrations (flagged `isActive: false`). |
| `includeSimilar` | boolean | `true` | Suggest up to 5 similar registered names. |
| `maxMatchesPerCompany` | integer | `10` | Maximum matching registrations listed per company. |

### Pricing

Pay-per-event:

- **$0.004 per company found** (at least one matching registration)
- **$0.0005 per lookup with no match**
- **$0.0005 per run** (Actor start, at the default 256 MB memory)
- No charge for invalid input or when a registry can't be reached. Apify platform usage is included.

Set a maximum cost per run and the Actor stops cleanly when the budget is reached.

### Use from code or an AI agent

Call it through the Apify API, the JavaScript or Python client, or Apify's MCP server (`https://mcp.apify.com/?actors=plainfold/business-entity-check`). For a synchronous call that returns the results directly:

`POST https://api.apify.com/v2/acts/plainfold~business-entity-check/run-sync-get-dataset-items` with body `{"companies": ["Acme Widgets LLC"]}`.

### FAQ

**Is this a scraper?** No. It queries the open-data APIs that each state publishes for public reuse.

**Why does a big company show "not_found"?** It may be registered under a different legal name (for example "Home Depot U.S.A., Inc." rather than "The Home Depot"), or only in states not covered. Check `similarNames`.

**Why can a company be active in one state and inactive in another?** Registrations are per state. A company can withdraw from one state while remaining active elsewhere; `activeIn` shows where it is active.

### Support

Found a wrong match or want another state? Open an issue on the Actor's Issues tab.

# Actor input Schema

## `companies` (type: `array`):

Legal or common names of the companies to verify, one per entry, e.g. \["Arrow Electronics, Inc.", "Kodak Alaris LLC"]. Matching ignores case, punctuation, a leading "The" and suffix spelling (Inc./Incorporated, LLC/L.L.C.). A name without a suffix ("Arrow Electronics") matches any entity type; a name with a suffix ("AT\&T Corp") prefers that exact entity. To search one state only, append " | XX", e.g. "Dell Technologies Inc. | TX". One result (and one charge) per entry. Up to 1,000 per run.

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

Which state registries to search. Default: all supported states \["NY", "CO", "OR", "CT", "TX"]. NY and OR publish active entities only; CO and CT include inactive entities with their status; TX reports the Comptroller's right-to-transact-business status.

## `includeInactive` (type: `boolean`):

Also return dissolved, withdrawn, forfeited or revoked registrations (marked isActive: false). Set false to return only active or status-unknown registrations. Default: true.

## `includeSimilar` (type: `boolean`):

Add up to 5 similar registered names (e.g. subsidiaries such as "Arrow Electronics Funding Corporation") in similarNames. Similar names never count as a match. Default: true.

## `maxMatchesPerCompany` (type: `integer`):

Maximum matching registrations listed per company (across all states), best first. Default: 10.

## Actor input object example

```json
{
  "companies": [
    "Arrow Electronics, Inc.",
    "Kodak Alaris LLC"
  ],
  "states": [
    "NY",
    "CO",
    "OR",
    "CT",
    "TX"
  ],
  "includeInactive": true,
  "includeSimilar": true,
  "maxMatchesPerCompany": 10
}
```

# Actor output Schema

## `results` (type: `string`):

One item per company checked (Overview view).

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

Sources searched, dataset refresh dates and counts.

# 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 = {
    "companies": [
        "Arrow Electronics, Inc.",
        "Kodak Alaris LLC"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("plainfold/business-entity-check").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 = { "companies": [
        "Arrow Electronics, Inc.",
        "Kodak Alaris LLC",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("plainfold/business-entity-check").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 '{
  "companies": [
    "Arrow Electronics, Inc.",
    "Kodak Alaris LLC"
  ]
}' |
apify call plainfold/business-entity-check --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,plainfold/business-entity-check"
        }
    }
}
```

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/x5a8quqHiOVccmvGb/builds/W96DhRU1J2vljGRGJ/openapi.json