# Wisconsin DFI Business Entity Search Scraper (`crawlerbros/wisconsin-dfi-business-entity-search-scraper`) Actor

Search Wisconsin's official Corporate Records registry (apps.dfi.wi.gov). Look up businesses by name or advanced filters (org type, status, name history, date range) and get entity type, status, registered agent, addresses, and filing history.

- **URL**: https://apify.com/crawlerbros/wisconsin-dfi-business-entity-search-scraper.md
- **Developed by:** [Crawler Bros](https://apify.com/crawlerbros) (community)
- **Categories:** Automation, Lead generation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 results

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

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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

## Wisconsin DFI Business Entity Search Scraper

Search **Wisconsin's official Corporate Records registry**, run by the Wisconsin Department of Financial Institutions (DFI) at `apps.dfi.wi.gov`. Look up a business by name, or use advanced filters (organization type, active/inactive status, current vs. former names, registration date range) and get entity type, status, registered agent, principal office address, annual report filing history, and the full filing chronology. HTTP-only, no login, no CAPTCHA.

### Data Source & Usage Notes

**Read this before running a large job.**

- **No login, no CAPTCHA, no bot-protection challenge observed.** `apps.dfi.wi.gov/apps/CorpSearch` is a plain, publicly accessible search — no account wall, no Cloudflare/Akamai/reCAPTCHA challenge on either the search or detail pages.
- **Why Wisconsin, and not another state?** Wisconsin's DFI Corporate Records search was chosen because it's fully open — no account wall, no CAPTCHA, no bot-protection challenge — and was verified live, multiple times, to return real, complete data. Some other state registries impose interactive "Human Verification" challenges that block automated access entirely; those are avoided in favor of sources that stay reliably accessible to everyone.
- **500-record cap per search.** Wisconsin's own results page caps any single search (quick or advanced) at 500 rows — this is a genuine source-side limit, not an actor bug. The source itself reports `"More than 500 records"` when a query is this broad; narrow your search text or add filters for a complete result set.
- **Detail-page enrichment is optional but on by default.** Each result row already includes entity ID, name, type, registration date, and status for free. Turning on `fetchDetails` (the default) additionally fetches each entity's own detail page for registered agent, principal office address, annual report history, and full filing chronology — richer, but one extra HTTP request per result.
- **Conservative by design.** This actor only ever uses Apify's free datacenter (AUTO) proxy group as a defensive fallback — never a paid residential proxy — even though the source has no observed bot-protection requiring one.
- **The entity detail page has its own request-volume gate, handled automatically.** Confirmed live: an unusually high volume of rapid detail-page requests in a short window can trigger a temporary "403 Forbidden" from the source's own server for that page — the main search/results page is unaffected. The actor paces detail-page requests and automatically recovers from a temporary block; if detail enrichment keeps failing, it falls back to the search-row fields it already has for the rest of that run rather than failing the whole job.
- **Give large jobs a generous run timeout.** With `fetchDetails` on (the default), each result requires one extra detail-page fetch. A `maxItems` of 500 with details enabled takes roughly 4–5 minutes end-to-end (confirmed live); set a run timeout of 600s or more (Input > Run options) for large jobs rather than relying on a short default.
- **Not affiliated with the State of Wisconsin.** This is an independent third-party tool using the Department of Financial Institutions' own public, no-login search.

### What this actor does

- **Two search modes:**
  - `search` — quick search: matches any part of the business name
  - `advancedSearch` — the same name search plus every filter the source's own Advanced Search page exposes
- **26 organization types** as a filter — every domestic/foreign corporation, LLC, partnership, cooperative, trust, and name-reservation type Wisconsin's own dropdown lists
- **Active / inactive filter** — restrict to entities currently in existence, no-longer-in-existence, or both
- **Name-history filter** — search current names only, current + former names, or former names only
- **Registration date range** — restrict by the entity's registered effective date
- **Text match type** (Advanced search) — exact phrase, all words, or starts-with
- **Full entity detail** — registered agent name and address, principal office address, annual report requirements text, foreign-entity organization date/state, complete annual report filing history, and the entity's full chronology of filings (registrations, agent changes, amendments, etc.)
- Empty fields are omitted — you never have to guard against `null`

### Output per business entity

- `entityId` — Wisconsin's unique entity/registration ID (e.g. `G058614`)
- `entityName`
- `entityTypeCode`, `entityType` — e.g. `12`, `Domestic Limited Liability Company`
- `registeredEffectiveDate` — `MM/DD/YYYY`
- `status`, `statusDate`
- `periodOfExistence` — e.g. `PER` (perpetual)
- `annualReportRequirements` — the statutory filing-requirement text for this entity type
- `foreignOrganizationDate`, `foreignState` — for entities formed outside Wisconsin
- `paidCapitalRepresented` — when on file
- `registeredAgentName`, `registeredAgentStreet`, `registeredAgentCity`, `registeredAgentState`, `registeredAgentZip`
- `principalOfficeStreet`, `principalOfficeCity`, `principalOfficeState`, `principalOfficeZip`, `principalOfficeCountry` (for foreign principal offices)
- `annualReports` — list of `{year, reel, image, filedBy, storedOn}`
- `chronology` — list of `{effectiveDate, transaction, processedDate, description}` — every filing event on record
- `certificatesOfNewlyElectedOfficers` — when on file
- `oldNames` — former names, when on file
- `detailUrl`, `sourceUrl` — direct link to the entity's live detail page
- `recordType: "businessEntity"`, `scrapedAt`

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `mode` | string | `search` | `search` (quick) / `advancedSearch` (name + filters) |
| `searchQuery` | string | `GOOGLE` | Business name or search text |
| `textSearchType` | string | `ExactPhrase` | `ExactPhrase` / `AllWords` / `StartsWith` (mode=advancedSearch) |
| `orgTypes` | array | `[]` | One or more of the 26 organization-type codes; empty = all types (mode=advancedSearch) |
| `includeActiveEntities` | string | `Include` | `Include` (all) / `Only` (active) / `Exclude` (inactive only) (mode=advancedSearch) |
| `includeOldNames` | string | `Exclude` | `Exclude` (current names) / `Include` (current + old) / `Only` (old names) (mode=advancedSearch) |
| `incorporationDateStart` | string | — | Registration date lower bound, `MM/DD/YYYY` (mode=advancedSearch) |
| `incorporationDateEnd` | string | — | Registration date upper bound, `MM/DD/YYYY` (mode=advancedSearch) |
| `fetchDetails` | boolean | `true` | Fetch each entity's full detail page (registered agent, addresses, filing history) |
| `proxyConfiguration` | object | AUTO proxy | Apify proxy config; always datacenter (AUTO), never residential |
| `maxItems` | int | `50` | Hard cap (1–500) — the source itself caps any search at 500 rows |

#### Example: quick search by business name

```json
{
  "mode": "search",
  "searchQuery": "GOOGLE",
  "maxItems": 25
}
```

#### Example: advanced search — active domestic LLCs registered in 2023

```json
{
  "mode": "advancedSearch",
  "searchQuery": "TECH",
  "textSearchType": "AllWords",
  "orgTypes": ["12"],
  "includeActiveEntities": "Only",
  "incorporationDateStart": "01/01/2023",
  "incorporationDateEnd": "12/31/2023",
  "maxItems": 50
}
```

#### Example: fast name-only pass (no detail enrichment)

```json
{
  "mode": "search",
  "searchQuery": "MADISON",
  "fetchDetails": false,
  "maxItems": 100
}
```

### Use cases

- **Due diligence** — confirm a counterparty's Wisconsin entity type, status, and registered agent before contracting
- **Compliance & KYC** — cross-check a business's legal entity name and registration date
- **Registered agent research** — see the registered agent and office on file for any Wisconsin entity
- **Company formation research** — filter by organization type and registration date range to study formation trends
- **Name-availability research** — search current and former names together to see if a name (or something close to it) is already on file
- **Filing-history review** — pull the complete chronology of filings for an entity (registrations, agent changes, amendments, terminations)

### FAQ

**What's the data source?** The Wisconsin Department of Financial Institutions' own free public Corporate Records Search at `apps.dfi.wi.gov`. This actor is an independent third-party tool and is not affiliated with the State of Wisconsin.

**Is this data official / legally binding?** No. For an official Certificate of Status or certified copies, use the state's own paid ordering channels (linked from each entity's detail page). This actor returns the same free-tier informational data the public search page shows.

**Why did my run return 0 results?** Either the query genuinely has no match, or your filters (organization type, active/inactive, date range) are narrower than expected. Try widening them, or switch `textSearchType` to `AllWords` for a looser match.

**Why does the source say "More than 500 records"?** Wisconsin's own results page caps every search at 500 rows — even the state's own site doesn't show more. Narrow your search text or add filters (organization type, date range) to get under the cap.

**What's the difference between the two modes?** `search` is a quick, name-only lookup. `advancedSearch` runs the same name search but also lets you filter by organization type, active/inactive status, current-vs-former names, and a registration date range — exactly the options on the source's own Advanced Search page.

**How fresh is the data?** Real-time — every search reflects the Department of Financial Institutions' database as of the moment of the search.

**Does this cost extra for proxies?** No. The actor only ever uses Apify's free datacenter (AUTO) proxy group, included in every Apify plan.

# Actor input Schema

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

Which search to run.

## `searchQuery` (type: `string`):

Text to search for. Quick search matches names containing this text; Advanced search additionally honors the 'Text match type' option below.

## `textSearchType` (type: `string`):

How the search text is matched against entity names. Only applies to Advanced search.

## `orgTypes` (type: `array`):

Restrict results to one or more entity/organization types. Leave empty for all types. Only applies to Advanced search.

## `includeActiveEntities` (type: `string`):

Restrict by whether the entity is currently in existence. Only applies to Advanced search.

## `includeOldNames` (type: `string`):

Whether to also match against an entity's former/old names. Only applies to Advanced search.

## `incorporationDateStart` (type: `string`):

Only include entities registered on/after this date. Format MM/DD/YYYY, e.g. 01/01/2020.

## `incorporationDateEnd` (type: `string`):

Only include entities registered on/before this date. Format MM/DD/YYYY, e.g. 12/31/2020.

## `fetchDetails` (type: `boolean`):

Follow each search result to its detail page for registered agent, addresses, annual reports, and filing chronology. Slower but much richer records. Turn off for a fast name-only pass.

## `proxyConfiguration` (type: `object`):

Uses Apify's free datacenter (AUTO) proxy group as a defensive fallback. Residential proxy is never used by this actor.

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

Hard cap on emitted records. The source itself returns at most 500 rows for any single search (its own server-side limit) — narrow your search/filters for more precise results.

## Actor input object example

```json
{
  "mode": "search",
  "searchQuery": "GOOGLE",
  "textSearchType": "ExactPhrase",
  "orgTypes": [],
  "includeActiveEntities": "Only",
  "includeOldNames": "Exclude",
  "fetchDetails": true,
  "proxyConfiguration": {
    "useApifyProxy": true
  },
  "maxItems": 50
}
```

# Actor output Schema

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

Dataset containing all scraped Wisconsin business entity records.

# 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 = {
    "mode": "search",
    "searchQuery": "GOOGLE",
    "textSearchType": "ExactPhrase",
    "orgTypes": [],
    "includeActiveEntities": "Only",
    "includeOldNames": "Exclude",
    "fetchDetails": true,
    "proxyConfiguration": {
        "useApifyProxy": true
    },
    "maxItems": 50
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/wisconsin-dfi-business-entity-search-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 = {
    "mode": "search",
    "searchQuery": "GOOGLE",
    "textSearchType": "ExactPhrase",
    "orgTypes": [],
    "includeActiveEntities": "Only",
    "includeOldNames": "Exclude",
    "fetchDetails": True,
    "proxyConfiguration": { "useApifyProxy": True },
    "maxItems": 50,
}

# Run the Actor and wait for it to finish
run = client.actor("crawlerbros/wisconsin-dfi-business-entity-search-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 '{
  "mode": "search",
  "searchQuery": "GOOGLE",
  "textSearchType": "ExactPhrase",
  "orgTypes": [],
  "includeActiveEntities": "Only",
  "includeOldNames": "Exclude",
  "fetchDetails": true,
  "proxyConfiguration": {
    "useApifyProxy": true
  },
  "maxItems": 50
}' |
apify call crawlerbros/wisconsin-dfi-business-entity-search-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,crawlerbros/wisconsin-dfi-business-entity-search-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/Qgwr0XUrveH4Ilzzh/builds/gq22907YcdMv0YA64/openapi.json