# Minnesota Secretary of State Business Search Scraper (`crawlerbros/minnesota-sos-scraper`) Actor

Search the Minnesota Secretary of State's free Business Filings Online registry by business name or file number. Get entity type, status, registered agent, officers, filing history, and address.

- **URL**: https://apify.com/crawlerbros/minnesota-sos-scraper.md
- **Developed by:** [Crawler Bros](https://apify.com/crawlerbros) (community)
- **Categories:** Agents, Developer tools, Automation
- **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 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

## Minnesota Secretary of State Business Search Scraper

Scrape **Minnesota's Business Filings Online registry**, the Secretary of State's free public database of every business, nonprofit, trademark, and general entity on file with the State of Minnesota. Search by business name or look up a specific record by its Minnesota file number, and get entity type, filing status, registered agent, officers/managers, addresses, and complete filing history. HTTP-only via the public `mblsportal.sos.mn.gov` search — no login, no API key, no proxy required.

### What this actor does

- **Two search modes:** `byBusinessName` (with the source's own Begins-with/Contains, Active/Inactive, and Include-Prior-Names search options) and `byFileNumber` (direct lookup)
- **Every entity type** — Business Corporations, LLCs, LLPs, LPs, Cooperatives, Nonprofits, Assumed Names, Trademarks/Service Marks, Name Reservations, and General Entities
- **Full detail-page coverage** — officers, managers, presidents, CEOs (whichever roles the entity actually has on file), registered agent, registered office address, principal executive office address, and number of shares (for corporations)
- **Complete filing history** — every filing event on record (original filing, amendments, renewals, terminations, reinstatements) with date and description
- **Trademark markholders** — for Trademark/Service Mark records, the markholder name and address
- **Empty fields are omitted** — you never have to guard against `null`, only against fields not being present

### Output per business record

- `businessName` — the entity's current registered name
- `nameType` — e.g. `Minnesota Business Name`, `Word or Phrase` (for trademarks)
- `businessType` — e.g. `Limited Liability Company (Domestic)`, `Business Corporation (Domestic)`, `Nonprofit Corporation (Domestic)`, `Trademark - Service Mark`, `General Entity`
- `fileNumber` — the entity's Minnesota file number (the registry's own identifier; format varies by entity type/era, e.g. `1K-1056`, `631180100027`, `5761-NPA`)
- `filingGuid` — the internal record identifier used by the source's own detail-page URL
- `mnStatute` — the Minnesota statute chapter governing the entity type, when applicable
- `homeJurisdiction` — the entity's jurisdiction of formation
- `status` — `Active` or `Inactive`
- `statusDetail` — the source's own status qualifier, e.g. `In Good Standing`, `Dissolved`
- `filingDate` — original filing date (`YYYY-MM-DD`; very old "General Entity" records that only have a year on file show the bare year)
- `renewalDueDate` — `YYYY-MM-DD`, when the entity is subject to annual/periodic renewal
- `registeredOfficeAddress` — the entity's registered office address on file
- `principalExecutiveOfficeAddress` — the entity's principal executive office address, when on file
- `registeredAgentName` — the entity's registered agent, when one is on file
- `numberOfShares` — authorized shares, for corporations that have this on file
- `markType` — for trademark/service mark records
- `markholders[]` — `{ name, address }`, for trademark/service mark records
- `officers[]` — `{ title, name, address }` — every officer/manager/director role the entity has on file (titles vary by entity type: `Manager`, `President`, `Chief Executive Officer`, `Secretary`, etc.)
- `filingHistory[]` — `{ filingDate, description }` — every filing event on record, oldest to newest as rendered by the source
- `comments` — free-text notes from the registry, when present
- `sourceUrl` — the entity's own detail-page URL on `mblsportal.sos.mn.gov`
- `recordType: "business"`, `scrapedAt`

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `mode` | string | `byBusinessName` | `byBusinessName` / `byFileNumber` |
| `businessName` | string | `Target` | Business/entity name to search for (mode=byBusinessName) |
| `matchType` | string | `BeginsWith` | `BeginsWith` / `Contains` — how `businessName` is matched (mode=byBusinessName) |
| `status` | string | `Active` | `Active` / `Inactive` — filing status filter (mode=byBusinessName) |
| `includePriorNames` | boolean | `false` | Also match businesses' former/prior registered names (mode=byBusinessName) |
| `fileNumber` | string | – | The entity's Minnesota file number (mode=byFileNumber, required) |
| `maxItems` | int | `10` | Hard cap on emitted records (1–100) |

#### Example: search by business name (begins with)

```json
{
  "mode": "byBusinessName",
  "businessName": "Target",
  "matchType": "BeginsWith",
  "status": "Active",
  "maxItems": 10
}
````

#### Example: search anywhere in the name, including inactive filings

```json
{
  "mode": "byBusinessName",
  "businessName": "Historical Society",
  "matchType": "Contains",
  "status": "Active",
  "includePriorNames": true,
  "maxItems": 25
}
```

#### Example: lookup by file number

```json
{
  "mode": "byFileNumber",
  "fileNumber": "1K-1056"
}
```

### Use cases

- **Due diligence** — confirm a counterparty's Minnesota entity type, status, and registered agent before contracting
- **Compliance & KYC** — cross-check a business's legal entity name and file number against the state's own records
- **Officer/manager research** — see who's listed as an entity's manager, president, or CEO
- **Company name availability checks** — see what similarly-named entities already exist before choosing a new name
- **Trademark research** — look up who holds a Minnesota state-registered trademark or service mark
- **Historical/legal research** — pull an entity's complete filing history (amendments, terminations, reinstatements)

### FAQ

**What's the data source?** The Minnesota Secretary of State's own free public Business Filings Online search at `mblsportal.sos.mn.gov`. This actor is an independent third-party tool and is not affiliated with the Office of the Minnesota Secretary of State.

**Is this data official / legally binding?** No. For an official Certificate of Good Standing or certified copies, use the Secretary of State's own paid ordering channels (see the source site). This actor returns the same free informational data the public search page shows.

**What's the difference between `BeginsWith` and `Contains`?** They mirror the source search form's own "Search Scope" radio buttons exactly: `BeginsWith` matches names starting with your query; `Contains` matches your query appearing anywhere in the name.

**Why do some records have an `officers` array with a `Manager` title and others have `President` or `Chief Executive Officer`?** Minnesota's registry records different officer roles depending on entity type — LLCs typically list a `Manager`, nonprofits a `President`, corporations a `Chief Executive Officer`. This actor captures whichever roles the source actually has on file for each specific entity, rather than assuming one fixed role.

**Why is `registeredAgentName` missing on some records?** Not every Minnesota entity is required to have a registered agent on file (the source's own registry shows "(Optional) Currently No Agent" for these) — the field is simply omitted rather than populated with a placeholder.

**Why is `filingDate` sometimes just a year (e.g. `1849`) instead of a full date?** A small number of very old "General Entity" records in Minnesota's registry predate day-level date tracking and only have a filing year on file. This actor passes through the source's own real data rather than fabricating a day/month.

**What entity types are covered?** Every type the source's own search returns: Business Corporations, LLCs, LLPs, LPs, Cooperatives (including Housing Cooperatives), Nonprofit Corporations, Assumed Names, Trademarks/Service Marks, Name Reservations, and General Entities — both domestic and foreign where applicable.

**How fresh is the data?** Real-time — the search reflects the Secretary of State's database as of the moment of the search.

# Actor input Schema

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

Which axis of the Minnesota Business Filings Online search to use.

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

Business/entity name to search for.

## `matchType` (type: `string`):

How `businessName` is matched against the registry -- mirrors the source's own search-scope radio buttons.

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

Restrict the search to Active or Inactive filings -- mirrors the source's own Filing Status radio buttons.

## `includePriorNames` (type: `boolean`):

Also match against businesses' former/prior registered names -- mirrors the source's own Include Prior Names radio buttons.

## `fileNumber` (type: `string`):

The entity's Minnesota file number (e.g. `1K-1056`, `631180100027`, `5761-NPA` -- format varies by entity type and era).

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

Hard cap on emitted records (each record requires a separate detail-page fetch).

## Actor input object example

```json
{
  "mode": "byBusinessName",
  "businessName": "Target",
  "matchType": "BeginsWith",
  "status": "Active",
  "includePriorNames": false,
  "fileNumber": "1K-1056",
  "maxItems": 10
}
```

# Actor output Schema

## `businesses` (type: `string`):

Dataset containing all scraped Minnesota business filings.

# 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": "byBusinessName",
    "businessName": "Target",
    "matchType": "BeginsWith",
    "status": "Active",
    "includePriorNames": false,
    "fileNumber": "1K-1056",
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/minnesota-sos-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": "byBusinessName",
    "businessName": "Target",
    "matchType": "BeginsWith",
    "status": "Active",
    "includePriorNames": False,
    "fileNumber": "1K-1056",
    "maxItems": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("crawlerbros/minnesota-sos-scraper").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 '{
  "mode": "byBusinessName",
  "businessName": "Target",
  "matchType": "BeginsWith",
  "status": "Active",
  "includePriorNames": false,
  "fileNumber": "1K-1056",
  "maxItems": 10
}' |
apify call crawlerbros/minnesota-sos-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=crawlerbros/minnesota-sos-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Minnesota Secretary of State Business Search Scraper",
        "description": "Search the Minnesota Secretary of State's free Business Filings Online registry by business name or file number. Get entity type, status, registered agent, officers, filing history, and address.",
        "version": "1.0",
        "x-build-id": "v2pccnbigu54SCTdF"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/crawlerbros~minnesota-sos-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-crawlerbros-minnesota-sos-scraper",
                "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/crawlerbros~minnesota-sos-scraper/runs": {
            "post": {
                "operationId": "runs-sync-crawlerbros-minnesota-sos-scraper",
                "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/crawlerbros~minnesota-sos-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-crawlerbros-minnesota-sos-scraper",
                "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",
                "required": [
                    "mode"
                ],
                "properties": {
                    "mode": {
                        "title": "Search mode",
                        "enum": [
                            "byBusinessName",
                            "byFileNumber"
                        ],
                        "type": "string",
                        "description": "Which axis of the Minnesota Business Filings Online search to use.",
                        "default": "byBusinessName"
                    },
                    "businessName": {
                        "title": "Business name (mode=byBusinessName)",
                        "type": "string",
                        "description": "Business/entity name to search for.",
                        "default": "Target"
                    },
                    "matchType": {
                        "title": "Name match type (mode=byBusinessName)",
                        "enum": [
                            "BeginsWith",
                            "Contains"
                        ],
                        "type": "string",
                        "description": "How `businessName` is matched against the registry -- mirrors the source's own search-scope radio buttons.",
                        "default": "BeginsWith"
                    },
                    "status": {
                        "title": "Filing status (mode=byBusinessName)",
                        "enum": [
                            "Active",
                            "Inactive"
                        ],
                        "type": "string",
                        "description": "Restrict the search to Active or Inactive filings -- mirrors the source's own Filing Status radio buttons.",
                        "default": "Active"
                    },
                    "includePriorNames": {
                        "title": "Include prior names (mode=byBusinessName)",
                        "type": "boolean",
                        "description": "Also match against businesses' former/prior registered names -- mirrors the source's own Include Prior Names radio buttons.",
                        "default": false
                    },
                    "fileNumber": {
                        "title": "File number (mode=byFileNumber)",
                        "type": "string",
                        "description": "The entity's Minnesota file number (e.g. `1K-1056`, `631180100027`, `5761-NPA` -- format varies by entity type and era)."
                    },
                    "maxItems": {
                        "title": "Max items",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Hard cap on emitted records (each record requires a separate detail-page fetch).",
                        "default": 10
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```