# US Secretary of State Business Search – 11 States, LLC & Corp (`exuberantly_inventiveness/us-sos-business-entities`) Actor

Search US business entities (LLCs, corporations, nonprofits, partnerships) across 11 states incl. Florida, New York and Virginia, from official Secretary of State open data: entity number, status, formation date, registered agent, address, officers and source links.

- **URL**: https://apify.com/exuberantly_inventiveness/us-sos-business-entities.md
- **Developed by:** [justin cruz](https://apify.com/exuberantly_inventiveness) (community)
- **Categories:** Lead generation, Developer tools
- **Security:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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 Secretary of State Business Entity Search: 11 states, official open data

**Search LLCs, corporations, nonprofits and partnerships across 11 US states (including Florida) in one run, using official Secretary of State open data. Each result comes back as one normalized record: entity number, type, status, formation date, a business registered agent, principal and mailing address, officers, and a source link.**

### What it does / Who it's for / Why

- **What:** searches the official business-entity registries of **NY, CO, CT, OR, PA, TX, VA, DC, AK, IA and FL**. You can search by name (contains, starts with, or exact), by entity number, or in **list mode** with no name at all, using filters such as formation date, ZIP and city. List mode gives you every LLC formed in Colorado last week, for example.
- **Who:** KYB and compliance teams, lenders, B2B sales and lead-gen teams that want new-business lists, process servers and legal researchers, and journalists.
- **Why:** every record comes from a free government open-data API or official bulk download. There is no scraping of search pages, no captchas and no logins. Runs are fast, the record format is stable, and each record links to its source.

### Measured, not promised

Measured locally on 2026-11-04 (all 10 states, parallelism 3):

| Query | Results | Wall time |
|---|---|---|
| `"blue ridge"`, 5 per state | 42 | 8.8 s |
| `["smith","acme"]`, 200 per state | 1,946 | 12.1 s |
| 10 entity numbers (one per state) | 10 | ~9 s |
| List mode: active LLCs formed since 2026-10-01, 50 per state | 450 | ~5 s |

Florida (opt-in, add `FL` to `states`), measured on Apify on 2026-11-04:

| FL query | Results | Run time | Platform cost |
|---|---|---|---|
| List mode: active entities formed since 2026-10-20 (daily files only) | 200 | 4 s | $0.001 |
| `"blue ridge"`, 50 results | 50 | 91 s (4 GB) | $0.014 |
| One entity number | 1 | 78 s (4 GB) | $0.015 |
| `"blue ridge mountain"`, full scan of ~13M records | 24 | 303 s (4 GB) / 195 s (8 GB) | $0.063 / $0.080 |

FL has no query API. The State publishes a quarterly full file (1.8 GB zipped, Deflate64) and daily update files on its public SFTP server, using credentials it publishes on its Data Downloads page. The Actor reads the daily files first, then the quarterly file only when it still needs more results. Run FL with at least 4 GB of memory.

AK and IA have no query API, so each run streams their full official files (about 42 MB and 105 MB). That adds roughly 5 to 8 seconds whenever those states are included.

### Sample output

```json
{
  "state": "DC",
  "state_name": "District of Columbia",
  "entity_name": "BLUE RIDGE CONSULTING SERVICES Inc.",
  "entity_number": "250761",
  "entity_type": "Foreign Business Corporation",
  "entity_type_std": "corporation",
  "status": "Active - In Good Standing",
  "status_std": "active",
  "formation_date": "2005-03-10",
  "domestic_or_foreign": "Foreign",
  "foreign_formation_date": "2005-03-10",
  "registered_agent": {
    "name": "Business Filings Incorporated",
    "type": "organization",
    "address": {
      "line1": "1015 15TH STREET NW #1000",
      "line2": null,
      "city": "Washington",
      "state": "DC",
      "zip": "20005",
      "country": null,
      "full": "1015 15TH STREET NW #1000, Washington, DC 20005"
    }
  },
  "principal_address": {
    "line1": "114 Knightsridge Road",
    "line2": null,
    "city": "Travelers Rest",
    "state": "SC",
    "zip": "29690",
    "country": "USA",
    "full": "114 Knightsridge Road, Travelers Rest, SC 29690"
  },
  "annual_report_due": "04/01/2027",
  "last_report_filed": "2025-06-13",
  "record_last_modified": "2026-11-04",
  "source_url": "https://maps2.dcgis.dc.gov/dcgis/rest/services/DCGIS_DATA/Business_Licensing_and_Grants_WebMercator/MapServer/0/query?where=FILE_NUMBER+%3D+%27250761%27&outFields=*&returnGeometry=false&f=json",
  "official_record_url": "https://corponline.dlcp.dc.gov/",
  "source_dataset": "DC DLCP Corporate Registration (DC GIS Business_Licensing_and_Grants layer 0)",
  "data_scope": "all statuses",
  "retrieved_at": "2026-11-05T05:23:20.029Z"
}
```

**Common fields:**

- Identity: `state`, `entity_name`, `entity_number`, `entity_type` (as published) and `entity_type_std`, `status` (as published) and `status_std`, `formation_date`, `jurisdiction`
- Contacts: `registered_agent`, `principal_address`, `mailing_address`, `officers`
- Provenance: `source_url`, `official_record_url`, `source_dataset`, `data_scope`, `retrieved_at`

**Extra fields where the state publishes them:**

- `county` (NY, PA)
- `naics` (CT, TX)
- `annual_report_due` (CT, AK, DC)
- `dissolution_date` (CT)
- `status_reason` and `status_date` (VA)
- `assumed_name` (AK)
- `latitude` and `longitude` (IA)
- `service_of_process` (NY)
- `taxpayer_number` and `right_to_transact` (TX)
- `ownership_flags` (CT: woman-, veteran- or minority-owned)
- `business_email` (CT, opt-in)

### Privacy by design

- A **registered agent is output only when the agent is an organization**, such as CT Corporation, CSC or a law firm. For an individual agent, the name and address are replaced with `"type": "individual (omitted for privacy)"`.
- If a principal or mailing address matches an individual agent's address, which usually means a home address, the address is dropped and the reason goes into `privacy_notes`.
- `officers` contains **names and titles only**. Addresses of people are never output.

### Coverage

| State | Source (official) | Statuses | Agent | Officers | Freshness |
|---|---|---|---|---|---|
| NY | Dept. of State, Active Corporations + all-filings history (data.ny.gov n9v6-gdp6, 63wc-4exh) | all (inactive = not on active list, with filing history, former and assumed names) | ✓ (+ service of process) | chairman/CEO | daily |
| CO | Secretary of State, Business Entities (data.colorado.gov) | all | ✓ | – | daily |
| CT | Secretary of the State, Business Master + Agents + Principals (data.ct.gov) | all | ✓ | ✓ | daily |
| OR | Secretary of State, Active Businesses (data.oregon.gov) | active | ✓ | ✓ (authorized reps) | weekly/monthly |
| PA | Dept. of State, Currently Registered Businesses (data.pa.gov) | active | – (registered office address) | ✓ | periodic |
| TX | Comptroller, Active Franchise Taxpayers with SOS file number (data.texas.gov) | active franchise-tax entities | – | – | weekly |
| VA | SCC entity tables + Officer file (data.virginia.gov bulk downloads, cached, refreshed every 30 days) | all | ✓ | ✓ corporations only (see note) | **snapshot** (corp Nov 2024, LLC Jun 2022; index refreshed every 30 days; see `source_as_of`) |
| DC | DLCP Corporate Registration (DC GIS open data) | all | ✓ | – | daily |
| AK | Division of Corporations, full database download | all + business name registrations | ✓ | – | daily |
| IA | Secretary of State, Active Business Entities (Iowa Data hub, CC BY) | active | ✓ | – | monthly |
| FL | Division of Corporations, official quarterly + daily data files (public SFTP) | all | ✓ | ✓ (up to 6, names + titles) + FEI/EIN, annual reports | daily |

**Virginia officer gap:** VA officer data comes from the data.virginia.gov Officer file, which is cut off at Excel's 1,048,575-row limit. Corporations with IDs after F1923004 (about 4.8% of VA corporations) have no officers listed, though their entity records are complete. Every VA search with officers on carries a run note saying so.

**Not yet supported, and why:**

- **VA (official SCC weekly file) and IL (bulk data):** both hosts' robots.txt disallow automated access (`Disallow: /`), so VA stays on the data.virginia.gov snapshots and IL is skipped.
- **OH:** the business reports return 403.
- **MA:** the corporate export is behind a bot challenge.
- **RI:** the weekly export URL returns 404.
- **KY, WV:** bulk data requires a paid subscription.
- **WA, MS, ID and the rest:** search portals or script apps only. This Actor does not scrape HTML search pages.

### How to use

1. Enter a **business name**, several names, or **entity numbers**, and pick the states.
2. Optionally filter by **status**, **entity type**, **formed after/before**, **city** or **ZIP**.
3. Leave the name empty and set **formed after** to get a **new-business list** (list mode).
4. Results go to the dataset, which has an overview view and a flat "leads" view. Per-state counts and errors go to `RUN_STATS`.

### Example inputs

Copy one of these into the JSON input tab.

**1. Name search across all default states**

```json
{ "businessName": "blue ridge" }
```

Returns entities whose name contains "blue ridge" in the 10 default states (up to 100 per state). In our test this returned 629 results in about 20 s.

**2. Entity-number lookup (KYB / verification)**

```json
{ "entityNumbers": ["3523029"], "states": ["NY"] }
```

Returns the single New York record for DOS ID 3523029 (BLUE RIDGE ACCOUNTING SERVICES, INC.), with status, formation date and filing history. Our test run took about 3 s.

**3. New-filings feed (newly formed LLCs)**

```json
{ "formedAfter": "2026-10-01", "entityTypes": ["llc"], "status": "active", "states": ["CO", "CT", "NY"], "maxResultsPerState": 20, "maxItems": 60 }
```

List mode: no name needed. Returns active LLCs formed on or after the date. Our test returned 60 LLCs formed between 2026-10-01 and 2026-11-04 in about 3 s.

### Find newly formed LLCs for lead lists

New LLC filings are a common source of B2B leads. Freshly formed businesses often need a bank account, insurance, bookkeeping, a website, payroll or a registered agent. This Actor builds a **new business filings list** straight from official Secretary of State open data. It doesn't scrape search portals.

**Step 1: choose states and a date.** Leave the business name empty and set `formedAfter` to the start of your window, for example last Monday. List mode works in every state whose data includes a formation date. CO, CT and NY (active entities) were tested for this tutorial.

**Step 2: filter to LLCs that are still active.**

```json
{ "formedAfter": "2026-10-01", "entityTypes": ["llc"], "status": "active", "states": ["CO", "CT", "NY"], "maxResultsPerState": 200 }
```

Add `city` or `zip` to target a local market.

**Step 3: export.** Use the dataset's flat **leads** view for CSV or Excel. Each row has the entity name, entity number, formation date, status, the registered agent where the state publishes one, the business address and a link back to the official source record.

**Step 4: repeat weekly.** Run it again with a new `formedAfter` date to pick up only the latest filings. You pay $0.002 per result returned. The final coverage summary row is free.

**Good to know:**

- How fresh the data is depends on the state. CO, CT, NY and DC update daily, IA monthly. Virginia's open-data files are older snapshots. Each row's `source_as_of` or `retrieved_at` tells you how fresh it is.
- Individuals' home addresses and sole proprietors are never output.
- Many new LLCs list a commercial registered agent, not the owner. Treat these lists as company-level leads, not personal contact data, and follow the marketing rules that apply to you (CAN-SPAM, TCPA and state laws).
- The Actor provides no emails or phone numbers that the states don't publish.

### Use cases

| Use case | How |
|---|---|
| KYB / vendor onboarding | Exact name or entity number, then check `status_std`, `formation_date` and the agent |
| New-business leads | List mode: `formedAfter` = last week, `status` = active, filtered by ZIP or city |
| Registered-agent market share | Search a state, then group by `registered_agent.name` |
| Litigation / service of process | Find the registered agent (organization) and the NY service-of-process address |
| Due diligence | Officers (names and titles), dissolution date, annual report due |

### Notes

- `status_std` values:
  - `active`: good standing, exists, active
  - `delinquent`: still exists but not in good standing
  - `inactive`: dissolved, revoked, withdrawn, merged and similar
  - `reserved`
- NY, OR, PA, TX and IA publish **active entities only**, so a dissolved company in those states returns no result.
- TX data comes from the Comptroller's franchise-tax roll, which carries the SOS file number and charter date. The address is the taxpayer mailing address.
- Requests are throttled to about 3 per second per host and retried with backoff. All sources are public and need no login.

### v3 additions

- **UCC liens (CO, CT, OR)** from official open data (data.colorado.gov `wffy-3uut`/`8upq-58vz`/`ap62-sav4`, data.ct.gov `xfev-8smz`, data.oregon.gov `snfi-f79b`).
  - `mode: "liens"`: search liens by business debtor name; one record per lien (`record_type: "ucc_lien"`, filing_number, lien_kind, debtor_name/address, secured_parties, filings\[], status, lapse_date, image_url for OR).
  - `includeLiens: true`: attaches `ucc_filings` + `ucc_summary` (total, active, latest_filing_date, secured_parties) to CO/CT/OR entities by exact debtor-name match.
  - Only organization debtors/secured parties are returned. Oregon's lien dataset covers the most recent month only.
- **History** (`includeHistory`, default on): CT `filing_history`, `last_filing_date`, `name_history`, `former_names`; CO `filing_history`, `last_filing_date`, `trade_names`.
- **Oregon "new last month"**: entities from the monthly New Businesses list that are no longer on the active list are added (`new_last_month: true`).

### v4 additions

- **Business licenses** (`mode: "licenses"`, or `includeLicenses: true` to attach to CO/OR entities), from official open data. Only organization licensees are returned; sole proprietors and individuals are skipped.

| State | Jurisdiction | Dataset | Notable fields |
|---|---|---|---|
| IL | City of Chicago | data.cityofchicago.org r5kz-chrr | license type, business activity, status, issued/expires |
| DE | State of Delaware | data.delaware.gov 5zy2-grhr | statewide license category, valid from/to |
| WA | City of Seattle | cos-data.seattle.gov wnbq-64tb | **NAICS code**, ownership type, phone |
| CO | Denver | data.colorado.gov s9wt-dsfz | license type, status, expiry |
| LA | New Orleans | data.nola.gov hjcd-grvu | business type, start date, phone |
| OR | OLCC liquor + cannabis | data.oregon.gov srxe-qkm2, q32u-cmam | license type, endorsements, county |
| VA | City of Norfolk | data.norfolk.gov dpi6-sct5 | category, opened date |
| CA | Berkeley; Marin County | data.cityofberkeley.info rwnf-bu3w; data.marincounty.gov jfy7-shxv | **NAICS**, employees, ownership type |

- **CO UCC collateral**: `collateral` (descriptions) and `farm_products` on CO liens (data.colorado.gov 4am6-w6u4).
- No official inactive-entity open data exists for OR, PA, TX or IA (their portals publish active lists only), so inactive records there are not available.

### v5: two ways to use it

**Human mode (default)**: type a business name, optionally pick states, press Start. Long histories are capped at 10 entries (`*_count` shows the full number).

**AI / Agent mode** (`outputMode: "agent"`): every field, plus one final dataset item with `record_type: "coverage"` (also saved as key-value record `COVERAGE`):

```json
{"record_type":"coverage","run_status":"completed|no_match|failed",
 "states_queried":[{"state":"CO","status":"completed|no_match|failed|partial","results":60,"seconds":5.8,"notes":[]}],
 "states_skipped":[{"state":"ZZ","reason":"..."}],
 "queries":[{"query":"blue ridge","kind":"name","status":"completed|no_match|failed","results":83,"by_state":{"CO":60,"OR":23}}]}
```

The coverage item is not a charged result.

#### For AI assistants

Copy this into your agent's tool description:

```
Tool: US Secretary of State business search (official open data only).
Input JSON: {"outputMode":"agent","mode":"entities"|"liens"|"licenses",
 "businessNames":[...], "entityNumbers":[...], "states":[two-letter codes] (omit = defaults),
 "matchMode":"contains"|"startsWith"|"exact", "status":"any"|"active"|"inactive"|"active_or_delinquent",
 "formedAfter":"YYYY-MM-DD","formedBefore":"YYYY-MM-DD","city":"..","zip":"..",
 "includeOfficers":true,"includeHistory":true,"includeLiens":false,"includeLicenses":false,
 "maxResultsPerState":100,"maxItems":1000}
Entity states: NY CO CT OR PA TX VA DC AK IA, FL (opt-in, slow). Liens: CO CT OR. Licenses: IL DE WA CO LA OR VA CA.
List mode: no name, give formedAfter/formedBefore/city/zip -> new-business list.
Read the last item (record_type "coverage"): run_status, per-state status, per-query status.
"no_match" means the state was searched and has no match; "failed" means a source error, so retry or report unknown.
Never treat a state missing from states_queried as "no such business".
Each record has source_url and source_dataset; cite them.
```

### v6 – speed

Alaska and Iowa are served from a prebuilt index of their official bulk files. The index is kept in the named key-value store `sos-entities-bulk-cache` and is rebuilt automatically when it is more than 7 days old. To rebuild it now, set `refreshCache: true`. Every AK/IA record's `source_as_of` shows the index date. If a rebuild fails, the Actor falls back to the old index or to a live scan.
Smoke test: `APIFY_TOKEN=... python3 test/smoke.py`. It runs a small agent-mode query (about $0.0006, about 9 s) and exits 1 if any state fails. It can be scheduled with cron or an Apify schedule, and a scheduled run also keeps the index warm.

### v6.1 – time limits and reliability

- `maxRunSecs` (default 300) limits the whole run: when it is reached (or ~45 s before the run timeout), the run stops and returns the results found so far, with unfinished states marked `partial`.
- `stateTimeoutSecs` (default 30) sets a time limit for each state. A state that runs out of time returns what it found so far and is marked `partial` in COVERAGE, with a note. Set it to 0 for a complete search with no limit. Florida and cache rebuilds are not limited.
- Each HTTP request is retried 4 times with backoff. If a whole state fails before returning any results, it is retried once. Each state's status is one of completed, no_match, partial, failed or not_run.
- The AK/IA index is split into about 1.5 MB shards. They are downloaded, unzipped and filtered in parallel, so Iowa now takes about 4.5 s instead of 16–29 s.
- States are searched 10 at a time by default (`maxConcurrency`).
- smoke.py treats `partial` as a warning and fails only on `failed` or `not_run`.

#### v6.2 – Virginia cached

Virginia is now served from a monthly (30-day) index in the `sos-entities-bulk-cache` store, built from the official data.virginia.gov bulk download files (Corporation, LLC, LP, Business Trust, Officers). The SQL/datastore API is no longer used because data.virginia.gov's robots.txt disallows `/api/` and `/datastore/`; downloads respect its Crawl-delay. `source_as_of` carries the index build date; if the index is missing or stale, it is rebuilt (live fallback). Duplicate rows in the source files are de-duplicated.

# Actor input Schema

## `businessName` (type: `string`):

Name (or part of a name) to search for, e.g. "Blue Ridge". Leave empty to use list mode with the filters below.

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

Leave empty for the default: all entity states except Florida (entities mode), CO/CT/OR (liens mode), or all license sources (licenses mode). FL is opt-in: it scans the State's 1.8 GB official bulk file (about 1.5-5 minutes). IL, DE, WA, LA and CA are only available in licenses mode.

## `status` (type: `string`):

Filter by normalized status (status_std). Note: NY, OR, PA, TX and IA publish active entities only.

## `mode` (type: `string`):

"liens" searches official UCC/lien open data by business debtor name in CO, CT and OR and returns one record per lien.

## `outputMode` (type: `string`):

Agent mode returns every field and appends one record_type "coverage" item (states queried, results per state, skipped states, completed/no_match/failed per query). The same coverage object is always saved to the key-value store as COVERAGE.

## `businessNames` (type: `array`):

Search several names in one run (each matched with the same match mode).

## `entityNumbers` (type: `array`):

State file / entity / registry numbers (e.g. NY DOS ID, CO entity ID, VA SCC ID, TX SOS file number or taxpayer number). Leading zeros are optional.

## `matchMode` (type: `string`):

How business names are matched.

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

Filter by normalized type (entity_type_std). Empty = all.

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

YYYY-MM-DD. With no name this gives a list of newly formed businesses (lead lists).

## `formedBefore` (type: `string`):

YYYY-MM-DD.

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

Principal / mailing city (exact, case-insensitive).

## `zip` (type: `string`):

ZIP or ZIP prefix, e.g. 80202 or 802.

## `includeOfficers` (type: `boolean`):

CT, VA, PA, OR and NY publish officer names. Addresses of people are never output.

## `includeHistory` (type: `boolean`):

CT: filing history and former names; CO: filing history and trade names.

## `includeLiens` (type: `boolean`):

Attach ucc_filings and ucc_summary to CO, CT and OR entities whose exact name matches a business debtor in official UCC open data.

## `includeLicenses` (type: `boolean`):

Attach official license records whose licensee or trade name exactly matches the entity name.

## `includeEmails` (type: `boolean`):

Connecticut publishes a business email address on its business master file.

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

Maximum number of entities returned per state.

## `maxItems` (type: `integer`):

Max results in total

## `maxScanRowsPerState` (type: `integer`):

Safety cap for broad queries (rows read from the state's API before filters like status/type).

## `maxConcurrency` (type: `integer`):

States searched in parallel

## `refreshCache` (type: `boolean`):

Alaska and Iowa are served from a prebuilt index of their official bulk files, rebuilt automatically when older than 7 days. Tick to rebuild now (adds about 70 s).

## `stateTimeoutSecs` (type: `integer`):

A state that takes longer returns what it has so far with status "partial". 0 = no limit. Florida and cache rebuilds are exempt.

## `maxRunSecs` (type: `integer`):

The run stops searching after this many seconds and returns the results found so far, marked partial in COVERAGE. It also always stops ~45 s before the run's own timeout. 0 = no limit (only the run timeout applies).

## Actor input object example

```json
{
  "businessName": "blue ridge",
  "states": [],
  "status": "any",
  "mode": "entities",
  "outputMode": "human",
  "matchMode": "contains",
  "includeOfficers": true,
  "includeHistory": true,
  "includeLiens": false,
  "includeLicenses": false,
  "includeEmails": false,
  "maxResultsPerState": 100,
  "maxItems": 1000,
  "maxScanRowsPerState": 20000,
  "maxConcurrency": 10,
  "refreshCache": false,
  "stateTimeoutSecs": 30,
  "maxRunSecs": 300
}
```

# Actor output Schema

## `entities` (type: `string`):

One item per business entity.

## `runStats` (type: `string`):

Per-state counts, timing and errors.

# 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 = {
    "businessName": "blue ridge",
    "states": []
};

// Run the Actor and wait for it to finish
const run = await client.actor("exuberantly_inventiveness/us-sos-business-entities").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 = {
    "businessName": "blue ridge",
    "states": [],
}

# Run the Actor and wait for it to finish
run = client.actor("exuberantly_inventiveness/us-sos-business-entities").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 '{
  "businessName": "blue ridge",
  "states": []
}' |
apify call exuberantly_inventiveness/us-sos-business-entities --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,exuberantly_inventiveness/us-sos-business-entities"
        }
    }
}
```

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/FBNT8YiEdZN0VN5ZF/builds/7d2kChK3gXbuQBL1R/openapi.json