# Indiana PLA Licensing E-Verification Scraper (`b-w/indiana-pla-scraper`) Actor

Scrape professional licensing and verification records from the Indiana PLA Portal (mylicense.in.gov). Search by name, license number, status, or zip. Extracts full details and captures stamped screenshots of license detail pages. Compatible with Residential Proxies to bypass firewall blocks.

- **URL**: https://apify.com/b-w/indiana-pla-scraper.md
- **Developed by:** [b-w.pro](https://apify.com/b-w) (community)
- **Categories:** Automation, Other
- **Stats:** 2 total users, 1 monthly users, 66.7% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $10.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.

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.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.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/platform/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

## Indiana PLA Scraper

### What does Indiana PLA Scraper do?

Indiana PLA Scraper enables you to extract professional licensing and e-verification data from the [Indiana Professional Licensing Agency Search Portal](https://mylicense.in.gov/EVerification/Search.aspx) more efficiently than manual searches.

Indiana PLA Scraper can scrape:

- Professional license details (name, license number, profession, license type)
- License status and validity information (issue dates, expiration dates)
- Licensee location data (address, city, county, state, zip code)
- Licensing method and verification details
- Full-page screenshots of licensee detail pages with timestamp verification
- Results across multiple search parameters (name, license number, profession, location, DBA)

### Why scrape Indiana Professional Licensing Agency?

The Indiana PLA Search Portal contains verified professional licensing records for thousands of healthcare professionals, behavior analysts, nurses, and other licensed practitioners across Indiana. This data is essential for compliance, verification, and background checking purposes.

Here are just some of the ways you could use this data:

- **Compliance verification** - Verify that professionals on your team maintain active, current licenses
- **Background screening** - Conduct thorough credential checks during hiring or onboarding processes
- **Risk management** - Audit your organization's professional credentials and maintain compliance records
- **Business intelligence** - Track licensing trends across professions and geographic regions in Indiana
- **Automated reporting** - Generate scheduled reports of licensee status changes for regulatory audits

If you would like more inspiration on how scraping professional licensing data could help your business or organization, check out our [industry pages](https://apify.com/industries).

### How to scrape Indiana Professional Licensing Agency

It's easy to scrape professional licensing data from [Indiana PLA](https://mylicense.in.gov/EVerification/Search.aspx) with Indiana PLA Scraper. Just follow these few steps and you'll get your data in a few minutes.

1. Click on **Try for free**.
2. Enter your search criteria - first name, last name, license number, profession, or other available filters.
3. Optionally enable **Save Screenshot** to capture verified detail pages, and ensure **Residential Proxies** are enabled under proxy configuration.
4. Click on **Run**.
5. When Indiana PLA Scraper has finished, preview or download your data from the Dataset tab in JSON, CSV, Excel, XML, or HTML format.

### How much will it cost to scrape Indiana Professional Licensing Agency?

This Actor is currently configured under the **Pay-Per-Event + Platform Usage** billing model:

- **Actor Start**: `$0.02` per run start
- **Result**: `$0.01` per scraped result in the dataset
- **Screenshot**: `$0.02` per detail page screenshot captured

> [!NOTE]
> **Important Note on Pricing Changes:** 
> We are actively working on getting the pricing balanced to cover platform compute usage costs. We anticipate making pricing adjustments in the near future to transition to a flat **Pay-Per-Event only** model, which will allow us to **turn off separate billing for platform usage** entirely.

For platform computing and proxy usage under the current model:
Apify gives you $5 free usage credits every month on the [Apify Free plan](https://apify.com/pricing). Depending on the number of records you need to verify, you may be able to complete your verification task completely free!

Since this Actor requires Residential Proxies to bypass Indiana PLA's datacenter IP restrictions, please note that proxy usage represents an additional cost. If you need to regularly scrape large batches of professional licenses, we recommend our [$49/month Starter plan](https://apify.com/pricing), which includes both compute credits and proxy allowances.

For high-volume verification needs, the [Scale plan](https://apify.com/pricing) at $499/month provides substantial resources for enterprise-level compliance and background screening operations.

### Input Parameters

Configure the Actor using the following parameters:

| Parameter | Type | Description | Default |
|-----------|------|-------------|---------|
| First Name | String | First name of the professional to search for | `Jane` |
| Last Name | String | Last name of the professional to search for | `Doe` |
| License Number | String | Specific license number to look up | None |
| Profession | String | Profession or license type (e.g., Behavior Analyst, Nursing) | None |
| License Status | String | Filter results by status | `All` |
| State | String | State abbreviation filter | `--All--` |
| City | String | City filter | None |
| County | String | County filter | None |
| Zip Code | String | Zip code filter | None |
| DBA | String | Doing Business As name | None |
| Exact Match | Boolean | Strictly match exact name provided (case-insensitive) | `true` |
| Save Screenshot | Boolean | Capture full-page detail screenshots and save to Key-Value Store | `false` |
| Proxy Configuration | Object | Configure rotating proxies (Residential Proxies recommended) | Apify Proxy (Residential Default) |

### Results

Here is a sample of the data that the Actor produces:

```json
{
  "name_from_search": "Doe, Jane",
  "license_no": "12345678A",
  "profession": "Behavior Analyst",
  "license_type": "Licensed Behavior Analyst",
  "status": "Active",
  "address": "Indianapolis IN  46204",
  "name": "Jane Doe",
  "city_state_zip": "Indianapolis IN  46204",
  "county": "Marion",
  "lic_no": "12345678A",
  "type": "Licensed Behavior Analyst",
  "issued": "10/15/2024",
  "expiration": "12/31/2026",
  "method": "Application",
  "detail_url": "https://mylicense.in.gov/EVerification/Details.aspx?result=00000000-0000-0000-0000-000000000000",
  "screenshot_url": "https://api.apify.com/v2/key-value-stores/YOUR_STORE_ID/records/screenshot_doejane_12345678a"
}
````

### Tips for scraping Indiana Professional Licensing Agency

- **Enable Residential Proxies** - Indiana PLA blocks datacenter IP addresses. Always run this Actor with Apify Residential Proxies enabled to avoid `ERR_CONNECTION_REFUSED` errors and ensure reliable data extraction.
- **Allocate sufficient memory** - This Actor uses a headless browser (Playwright) to fill forms and capture screenshots. We recommend running with at least 2048 MB (2 GB) of memory for optimal performance.
- **Use Exact Match for precision** - When searching by name, enable the "Exact Match" option to filter out partial matches and focus only on exact name results.
- **Schedule regular audits** - Set up recurring runs to maintain up-to-date compliance records and track license status changes over time.
- **Combine search parameters** - Use multiple search fields together (e.g., name + city) to narrow results and reduce unnecessary API calls.

### Is it legal to scrape Indiana Professional Licensing Agency?

Note that personal data is protected by GDPR in the European Union and by other regulations around the world. You should not scrape personal data unless you have a legitimate reason to do so. If you're unsure whether your reason is legitimate, consult your lawyers.

The Indiana PLA portal is a public government resource designed for license verification purposes. However, you should ensure your use case complies with applicable laws and regulations regarding professional credential data.

We also recommend that you read our blog post: [is web scraping legal?](https://blog.apify.com/is-web-scraping-legal/).

# Actor input Schema

## `first_name` (type: `string`):

First name of the professional to search for

## `last_name` (type: `string`):

Last name of the professional to search for

## `license_no` (type: `string`):

Specific license number to search for

## `profession` (type: `string`):

Profession to select (e.g. 'Behavior Analyst')

## `license_type` (type: `string`):

License Type to select (e.g. 'Licensed Behavior Analyst')

## `attribute_type` (type: `string`):

Attribute Type to select

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

City name to filter results

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

State abbreviation (e.g., 'IN')

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

Status to filter by (e.g., 'Active')

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

County name to filter results

## `dba` (type: `string`):

DBA name to search for

## `zip_code` (type: `string`):

Zip code to filter results

## `exact_match` (type: `boolean`):

Filter results to exact name matches (case-insensitive)

## `save_screenshot` (type: `boolean`):

Take and save a screenshot of each details page to the Key-Value store

## `verbose` (type: `boolean`):

Show verbose log messages from Crawlee

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

Select proxies to be used by the scraper. For government portals, it is recommended to use residential proxies (US-based) to prevent IP blocking.

## Actor input object example

```json
{
  "first_name": "Jane",
  "last_name": "Doe",
  "state": "--All--",
  "status": "All",
  "exact_match": true,
  "save_screenshot": false,
  "verbose": false,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

## `dataset` (type: `string`):

Dataset containing verified licensing details, expiration dates, and screenshot URLs.

## `screenshots` (type: `string`):

Key-Value Store containing captured full-page PNG screenshots of licensee detail pages.

# 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("b-w/indiana-pla-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 = {}

# Run the Actor and wait for it to finish
run = client.actor("b-w/indiana-pla-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 '{}' |
apify call b-w/indiana-pla-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Indiana PLA Licensing E-Verification Scraper",
        "description": "Scrape professional licensing and verification records from the Indiana PLA Portal (mylicense.in.gov). Search by name, license number, status, or zip. Extracts full details and captures stamped screenshots of license detail pages. Compatible with Residential Proxies to bypass firewall blocks.",
        "version": "1.0",
        "x-build-id": "URT0byF9j5HLyo6o1"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/b-w~indiana-pla-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-b-w-indiana-pla-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/b-w~indiana-pla-scraper/runs": {
            "post": {
                "operationId": "runs-sync-b-w-indiana-pla-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/b-w~indiana-pla-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-b-w-indiana-pla-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",
                "properties": {
                    "first_name": {
                        "title": "First Name",
                        "type": "string",
                        "description": "First name of the professional to search for",
                        "default": "Jane"
                    },
                    "last_name": {
                        "title": "Last Name",
                        "type": "string",
                        "description": "Last name of the professional to search for",
                        "default": "Doe"
                    },
                    "license_no": {
                        "title": "License Number",
                        "type": "string",
                        "description": "Specific license number to search for"
                    },
                    "profession": {
                        "title": "Profession",
                        "type": "string",
                        "description": "Profession to select (e.g. 'Behavior Analyst')"
                    },
                    "license_type": {
                        "title": "License Type",
                        "type": "string",
                        "description": "License Type to select (e.g. 'Licensed Behavior Analyst')"
                    },
                    "attribute_type": {
                        "title": "Attribute Type",
                        "type": "string",
                        "description": "Attribute Type to select"
                    },
                    "city": {
                        "title": "City",
                        "type": "string",
                        "description": "City name to filter results"
                    },
                    "state": {
                        "title": "State",
                        "type": "string",
                        "description": "State abbreviation (e.g., 'IN')",
                        "default": "--All--"
                    },
                    "status": {
                        "title": "License Status",
                        "type": "string",
                        "description": "Status to filter by (e.g., 'Active')",
                        "default": "All"
                    },
                    "county": {
                        "title": "County",
                        "type": "string",
                        "description": "County name to filter results"
                    },
                    "dba": {
                        "title": "Doing Business As (DBA)",
                        "type": "string",
                        "description": "DBA name to search for"
                    },
                    "zip_code": {
                        "title": "Zip Code",
                        "type": "string",
                        "description": "Zip code to filter results"
                    },
                    "exact_match": {
                        "title": "Exact Match",
                        "type": "boolean",
                        "description": "Filter results to exact name matches (case-insensitive)",
                        "default": true
                    },
                    "save_screenshot": {
                        "title": "Save Screenshot",
                        "type": "boolean",
                        "description": "Take and save a screenshot of each details page to the Key-Value store",
                        "default": false
                    },
                    "verbose": {
                        "title": "Verbose Logging",
                        "type": "boolean",
                        "description": "Show verbose log messages from Crawlee",
                        "default": false
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Select proxies to be used by the scraper. For government portals, it is recommended to use residential proxies (US-based) to prevent IP blocking.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ]
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
