# IA Business Entities - Active Iowa Registry (`j0401/ia-business-entities`) Actor

Iowa's active business-entity register (public open data, 344,639 entities): legal name, type, effective date, registered agent and principal office - each with a full address and latitude/longitude. Filter by name, type, city, state or date.

- **URL**: https://apify.com/j0401/ia-business-entities.md
- **Developed by:** [Wenhao Yang](https://apify.com/j0401) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.03 / 1,000 ia business entity records

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## IA Business Entities - Active Iowa Registry

Iowa's **active business-entity register**, read from the Secretary of State's own open data, with the **registered agent** and the **principal office** each carrying a full geocoded address.

Every entity has a corp number - the state's own identifier - and the register declares it unique. One record answers who the entity is, what form it took, when it took effect, who its registered agent is, and where it keeps its office.

### Low cost

**From $0.00005 per record, down to $0.00003 at Gold.** Pay only for the records delivered - nothing for the query.

### What you get

**344,639** active entities, each with:

- **Legal name** and **corp number** - the state's own id, 100% populated.
- **Corporation type** - the source's exact value, 32 of them: `DOMESTIC LIMITED LIABILITY COMPANY` (217,343), `DOMESTIC PROFIT` (39,186), `REVISED DOMESTIC NON-PROFIT` (31,916), `FOREIGN LIMITED LIABILITY COMPANY` (22,895), `FOREIGN PROFIT` (17,091), `DOMESTIC LIMITED LIABILITY PARTNERSHIP` (4,216), professional and cooperative forms, and the rest.
- **Effective date** - the day the registration took effect, 100% populated, ISO `YYYY-MM-DD`.
- **Registered agent** - the name, plus the agent's street address, city, state and ZIP. **99.8% populated**, and each agent address carries **latitude and longitude**.
- **Principal office** - the entity's own office address, city, state, ZIP and country, **96% populated**, with **latitude and longitude** of its own.

Both addresses are geocoded by the state, so a record can be placed on a map or measured against another without a second call to a geocoder.

```
legalName:        STRIPE DUO, LLC
corporationType:  DOMESTIC LIMITED LIABILITY COMPANY
corpNumber:       881835
effectiveDate:    2026-07-31
registeredAgent:  TRACY BOHLEN
agentAddress:     225 DUNHAM DR, WAUKEE, IA 50263   (41.594, -93.877)
officeAddress:    225 DUNHAM DR, WAUKEE, IA 50263   (41.594, -93.877)
```

### Modes

- **`rows`** (default) - records matching your filters.
- **`aggregate`** - one count row per group, by corporation type, agent state, agent city, office state or office country. Counting runs over **every row in the register**, so a 2,378-value city dimension comes back complete rather than capped.
- **`profile`** - a single entity, by `corpNumber`.

### Example inputs

**One entity by its corp number.**

```json
{ "mode": "profile", "corpNumber": "881835" }
```

**Companies by name** - matches the legal name **or the registered agent**, so one search answers both "find this company" and "find what this person represents".

```json
{ "name": "STRIPE" }
```

**Every domestic profit corporation** - `corporationType` is an exact, case-insensitive match.

```json
{ "corporationType": "DOMESTIC PROFIT" }
```

**Entities in a city** - matched on the agent's city or the office's city.

```json
{ "city": "DES MOINES" }
```

**Registrations since a date** - a `corpNumber`-filed window.

```json
{ "effectiveFrom": "2026-09-01" }
```

**How the register splits by type** - one count per group, over the whole corpus.

```json
{ "mode": "aggregate", "groupBy": "corporationType" }
```

**Where the agents sit** - the agent state is almost entirely Iowa, with a few out-of-state agents.

```json
{ "mode": "aggregate", "groupBy": "agentState" }
```

### A note on the data

The source carries a column called `home_office` that is populated on **198 of 344,639 rows** and, where it is set, holds a mix of company names, person names and bare ZIP codes - a mis-mapped column upstream. It is **not** served here. The `ho_*` address columns beside it are sound (96% populated, a real office address) and those are what you get as `officeAddress1`  `officeCountry`.

A small number of rows carry no registered agent (601) or no office address (~3.6%). That is the state's own record, not a gap introduced here - a blank field means the state holds no value for it.

### Source

Iowa Secretary of State, published through the Iowa Data Hub as [Active Iowa Business Entities](https://data.iowa.gov/catalog/dataset/554) - public open data, no login and no key. The register is rebuilt **monthly**; the copy read here last updated **2026-09-08**.

Each record carries `sourceUpdatedAt` - the register's own last-updated date - so you can surface the exact vintage of the data rather than take a claim about it. The delay is the state's own publishing cycle, and nothing is added on top of it.

### Output

Every record carries the same key set regardless of mode - the entity fields, the agent fields, the office fields, and the aggregate columns (`groupKey`, `groupCount`, `groupBy`) which are `""` outside aggregate mode.

### Example output

**One entity** - `mode=profile`, `corpNumber=881835`:

```json
{
  "platform": "ia-business-entities",
  "source": "iowa-sos-entities",
  "mode": "profile",
  "groupKey": "", "groupCount": "", "groupBy": "",
  "recordType": "entity",
  "corpNumber": "881835",
  "legalName": "STRIPE DUO, LLC",
  "corporationType": "DOMESTIC LIMITED LIABILITY COMPANY",
  "effectiveDate": "2026-07-31",
  "registeredAgent": "TRACY BOHLEN",
  "agentAddress1": "225 DUNHAM DR",
  "agentAddress2": "",
  "agentCity": "WAUKEE",
  "agentState": "IA",
  "agentZipCode": "50263",
  "agentLatitude": "41.594011025314273",
  "agentLongitude": "-93.877076010162511",
  "officeAddress1": "225 DUNHAM DR",
  "officeAddress2": "",
  "officeCity": "WAUKEE",
  "officeState": "IA",
  "officeZipCode": "50263",
  "officeCountry": "USA",
  "officeLatitude": "41.594011025314273",
  "officeLongitude": "-93.877076010162511",
  "sourceUpdatedAt": "2026-09-08"
}
```

**`mode=aggregate`, `groupBy=corporationType`** - one row per type, counted over the whole register (the record fields are `""`; the group lands in `groupKey` / `groupCount`):

```
DOMESTIC LIMITED LIABILITY COMPANY                      217,343
DOMESTIC PROFIT                                          39,186
REVISED DOMESTIC NON-PROFIT                              31,916
FOREIGN LIMITED LIABILITY COMPANY                        22,895
FOREIGN PROFIT                                           17,091
DOMESTIC LIMITED LIABILITY PARTNERSHIP                    4,216
```

### Related actors

- **CO Business Entities** - the Colorado register, plus its full filing history and trade names.
- **NY Corporation Registry** - New York's register, with the complete Department-of-State filing trail.
- **PA Registered Businesses** - the same idea for Pennsylvania, keyed per officer.

# Actor input Schema

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

rows = records matching your filters (default). aggregate = one count row per group, over the whole register. profile = a single entity, by corpNumber.

## `corpNumber` (type: `string`):

The state's own unique business id (e.g. '881835'). An exact filter, or the lookup key for mode=profile. Blank = any.

## `name` (type: `string`):

Business name or registered-agent name, substring, case-insensitive. Blank = any.

## `corporationType` (type: `string`):

The source's exact entity type (32 values). Case-insensitive. Blank = any.

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

Matches the registered-agent city OR the principal-office city. Blank = any.

## `state` (type: `string`):

Two-letter code, matched on the agent state OR the office state (most are IA). Blank = any.

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

Five-digit ZIP, exact, matched on the agent ZIP OR the office ZIP. Blank = any.

## `effectiveFrom` (type: `string`):

Earliest effective date (YYYY-MM-DD). Blank = no lower bound.

## `effectiveTo` (type: `string`):

Latest effective date (YYYY-MM-DD). Blank = no upper bound.

## `groupBy` (type: `string`):

Which dimension to aggregate over (mode=aggregate). Blank = corporationType. Counting runs over the whole register, so no group is truncated.

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

Maximum records to return (mode=rows). Default 50.

## Actor input object example

```json
{
  "mode": "rows",
  "corpNumber": "",
  "name": "",
  "corporationType": "",
  "city": "",
  "state": "",
  "zip": "",
  "effectiveFrom": "",
  "effectiveTo": "",
  "groupBy": "",
  "maxResults": 50
}
```

# Actor output Schema

## `recordsUrl` (type: `string`):

Iowa business-entity records or aggregates - as JSON

## `datasetUrl` (type: `string`):

No description

## `runUrl` (type: `string`):

No description

# 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("j0401/ia-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 = {}

# Run the Actor and wait for it to finish
run = client.actor("j0401/ia-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 '{}' |
apify call j0401/ia-business-entities --silent --output-dataset

```

## MCP server setup

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