# Michigan LARA Professional License Verification Scraper (`crawlyth-forge/michigan-lara-professional-license-verification`) Actor

Verify Michigan occupational and professional licenses against the state LARA registry by license number, licensee or business name, license type, county or status, including disciplinary action history when on file.

- **URL**: https://apify.com/crawlyth-forge/michigan-lara-professional-license-verification.md
- **Developed by:** [crawlyth forge](https://apify.com/crawlyth-forge) (community)
- **Categories:** Automation, Lead generation, Other
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.49 / 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/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

## Michigan LARA Professional License Verification Scraper

Michigan's Department of Licensing and Regulatory Affairs (LARA) runs the state's public "Search for a Licensee" lookup, covering 169 license and credential types from cosmetology to healthcare to skilled trades. This actor queries that same registry and returns structured license records, including disciplinary history where LARA publishes it. No login, API key, or proxy required.

### What this actor does

- **Browse or search** Michigan's full public license register by any
  combination of license type, license number, licensee name, organization
  name, DBA/trade name, or county
- **169 license/credential types** covering accountants, barbers,
  cosmetologists, dentists, medical doctors, nurses, pharmacists, real
  estate professionals, veterinarians, and dozens more
- **Exact license-number lookup** — enter a license number alone (no license
  type required; numbers are unique across every credential type)
- **All 83 Michigan counties** available as a filter, where the licensee's
  county is on file
- **Filter by license status** after fetching (Active, Lapsed, Expired,
  Revoked, Deceased, and more)
- **Disciplinary action history** — every recorded condition (suspensions,
  probation, fines, revocations) from LARA's own "Disciplinary Action(s)"
  grid, with name, status, severity, and start/end/expiration dates
- **Filter to only disciplined licensees** with `hasDisciplinaryAction`
- **Automatic pagination** — MILARA's own results grid shows 50 records per
  page; this actor pages through automatically up to your `maxItems` limit
- **Empty fields are omitted** — a field only appears on a record when LARA
  actually published that data for the licensee

### Output per license

- `licenseNumber` — LARA license number
- `licenseType` — one of LARA's 169 license/credential types
- `name` — the licensee's full display name (individual) or business name (organization)
- `firstName`, `middleInitial`, `lastName` — for individual licensees, where published
- `organizationName` — business/company/corporation name, where the license is issued to an entity
- `dbaTradeName` — "doing business as" / trade name on file, where published
- `licenseStatus` — current status as published (e.g. `Active`, `Lapsed`, `Expired`, `Revoked`, `Deceased`)
- `licenseIssueDate` — ISO date the license was first issued, where published
- `licenseExpirationDate` — ISO date the license expires/expired, where published
- `county` — Michigan county on file for the licensee, where published
- `disciplinaryActions[]` — recorded disciplinary conditions, where published: `{name, status, severity, startDate, endDate, expirationDate}` (e.g. `Suspended`, `Probation`, `Fine Imposed`)
- `sourceUrl` — the MILARA license detail page for this record
- `recordType: "license"`, `scrapedAt`

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `licenseType` | select | – | One of LARA's 169 license/credential types. Leave unset to search across all types. |
| `licenseNumber` | string | – | Exact license number (e.g. `4704006499`). Unique across all license types. |
| `formerLicenseNumber` | string | – | Older/legacy license number on file, where different from the current number. |
| `firstName` | string | – | Licensee's first name (individuals only). |
| `middleInitial` | string | – | Licensee's middle initial (individuals only). |
| `lastName` | string | – | Licensee's last name (individuals only). |
| `organizationName` | string | – | Business/company/corporation name on file. |
| `dbaTradeName` | string | – | "Doing business as" or trade name on file. |
| `county` | select | – | One of Michigan's 83 counties. Not every license type has a county on record. |
| `licenseStatus` | select | – | Only emit licenses currently in this status (matched case-insensitively). |
| `hasDisciplinaryAction` | boolean | `false` | Only emit licenses with 1+ recorded disciplinary condition on file. |
| `maxItems` | integer | `50` | Hard cap on emitted license records (1–2000). |

All fields are optional and combinable — leave everything blank to browse
LARA's most recently indexed licenses.

#### Example: browse a license type

```json
{
  "licenseType": "Cosmetologist",
  "maxItems": 50
}
```

#### Example: look up an exact license number

```json
{
  "licenseNumber": "4704006499"
}
```

#### Example: search by licensee last name within a license type

```json
{
  "licenseType": "Registered Nurse",
  "lastName": "Smith",
  "maxItems": 25
}
```

#### Example: licensees with disciplinary action(s)

```json
{
  "licenseType": "Massage Therapist",
  "hasDisciplinaryAction": true,
  "maxItems": 25
}
```

#### Example: browse active salons by county

```json
{
  "licenseType": "Barbershop",
  "county": "Wayne",
  "licenseStatus": "Active",
  "maxItems": 50
}
```

### Use cases

- **Credential verification** — confirm a professional's Michigan license is
  current before hiring, contracting, or referring business
- **Compliance monitoring** — track license status changes for
  professionals or businesses you work with
- **Lead generation** — build lists of licensed professionals by credential
  type, county, or status
- **Background research** — check licensure history for a specific
  individual or business
- **Market research** — measure the number of active licensees by
  credential type or county across Michigan

### Data Source

This actor targets **`aca-prod.accela.com/MILARA`** — the Michigan
Department of Licensing and Regulatory Affairs' public "Search for a
Licensee" tool, built on the Accela Citizen Access platform. The search form
and license-detail pages are public, unauthenticated, and require no
CAPTCHA.

### Limitations

- LARA's own search results grid caps out around 50 records per page and
  this actor pages through it automatically. Very broad searches (e.g. a
  common license type with no other filters, combined with a restrictive
  `licenseStatus` filter) may need to scan further into the register to
  find enough matching records — narrow with `lastName`, `county`, or a
  more specific `licenseType` for faster, more targeted results.
- `licenseIssueDate` is omitted whenever LARA's own system shows the
  placeholder date `01/01/1900`, which LARA uses internally to mean "no
  real issue date on file" — this is not treated as a real date.
- `county` and `licenseIssueDate` are only published on the license detail
  page for some license types; when unavailable, the field is simply
  omitted rather than filled with a placeholder.
- `disciplinaryActions[]` reflects LARA's public "Disciplinary Action(s)"
  summary grid on the license detail page (condition name, status, severity,
  dates). It is only populated when the per-license detail-page fetch
  succeeds — if that fetch fails after retries, the record falls back to
  results-grid-only fields (license number, type, name, status, expiration
  date, DBA/trade name) and omits this array along with `county`,
  `licenseIssueDate` and `organizationName`.
- Application/permit search and the full enforcement case file / complaint
  history on the MILARA portal require a MiPLUS account login and are out
  of scope for this actor.

### FAQ

**Do I need a login or API key?**
No. This actor uses LARA's public MILARA license search, which requires no
account.

**Can I look up a specific license number without knowing the license type?**
Yes — license numbers are unique across all 169 credential types, so
`licenseNumber` alone is enough.

**How current is the data?**
Records are scraped live from LARA's own license lookup tool at run time.
LARA's own disclaimer notes licensing data is updated once a day.

**Why don't some records have a county or issue date?**
LARA only publishes the fields it has on file for a given license. This
actor never fabricates or fills in placeholder values for missing data.

# Actor input Schema

## `licenseType` (type: `string`):

Filter to one of LARA's 169 license/credential types (e.g. `Cosmetologist`, `Registered Nurse`, `Real Estate Salesperson`). Leave unset to search across all license types.

## `licenseNumber` (type: `string`):

Exact LARA license number, e.g. `4704006499`. Unique across all license types, so `licenseType` isn't required when using this.

## `formerLicenseNumber` (type: `string`):

Older/legacy license number on file (LARA's own "Former License Number" search field), where different from the current number.

## `firstName` (type: `string`):

Licensee's first name (individuals only).

## `middleInitial` (type: `string`):

Licensee's middle initial (individuals only).

## `lastName` (type: `string`):

Licensee's last name (individuals only).

## `organizationName` (type: `string`):

Business/company/corporation name on file (e.g. for real estate brokerages, cosmetology establishments, pharmacies).

## `dbaTradeName` (type: `string`):

"Doing business as" or trade name on file (e.g. a salon's storefront name).

## `county` (type: `string`):

Narrow results to licensees whose county on file matches one of Michigan's 83 counties. Not every license type has a county on record.

## `licenseStatus` (type: `string`):

Only emit licenses currently in this LARA status (matched case-insensitively against the record's own `licenseStatus`). Leave unset for all statuses.

## `hasDisciplinaryAction` (type: `boolean`):

If enabled, only emit licenses that have 1+ recorded disciplinary condition on file (suspensions, probation, fines, revocations, etc. — from LARA's own "Disciplinary Action(s)" grid on the license detail page). Most licenses have none.

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

Hard cap on emitted license records. MILARA paginates 50 results per page; higher values fetch additional pages automatically.

## Actor input object example

```json
{
  "licenseType": "Cosmetologist",
  "licenseNumber": "",
  "formerLicenseNumber": "",
  "firstName": "",
  "middleInitial": "",
  "lastName": "",
  "organizationName": "",
  "dbaTradeName": "",
  "county": "",
  "licenseStatus": "",
  "hasDisciplinaryAction": false,
  "maxItems": 50
}
```

# Actor output Schema

## `licenses` (type: `string`):

Dataset containing all scraped Michigan LARA license 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 = {
    "licenseType": "Cosmetologist",
    "licenseNumber": "",
    "formerLicenseNumber": "",
    "firstName": "",
    "middleInitial": "",
    "lastName": "",
    "organizationName": "",
    "dbaTradeName": "",
    "county": "",
    "licenseStatus": "",
    "hasDisciplinaryAction": false,
    "maxItems": 50
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlyth-forge/michigan-lara-professional-license-verification").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 = {
    "licenseType": "Cosmetologist",
    "licenseNumber": "",
    "formerLicenseNumber": "",
    "firstName": "",
    "middleInitial": "",
    "lastName": "",
    "organizationName": "",
    "dbaTradeName": "",
    "county": "",
    "licenseStatus": "",
    "hasDisciplinaryAction": False,
    "maxItems": 50,
}

# Run the Actor and wait for it to finish
run = client.actor("crawlyth-forge/michigan-lara-professional-license-verification").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 '{
  "licenseType": "Cosmetologist",
  "licenseNumber": "",
  "formerLicenseNumber": "",
  "firstName": "",
  "middleInitial": "",
  "lastName": "",
  "organizationName": "",
  "dbaTradeName": "",
  "county": "",
  "licenseStatus": "",
  "hasDisciplinaryAction": false,
  "maxItems": 50
}' |
apify call crawlyth-forge/michigan-lara-professional-license-verification --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,crawlyth-forge/michigan-lara-professional-license-verification"
        }
    }
}
```

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/Qa8pdaZbGSPJPH3nu/builds/LlQ35sAo85VFugcpD/openapi.json
