# Ohio eLicense Scraper (`crawlerbros/ohio-elicense-scraper`) Actor

Look up Ohio professional and occupational licenses issued by the Ohio Department of Commerce's Division of Real Estate & Professional Licensing. Search by license number, name, business name, or license type. Get status, issue/expiration dates, and address.

- **URL**: https://apify.com/crawlerbros/ohio-elicense-scraper.md
- **Developed by:** [Crawler Bros](https://apify.com/crawlerbros) (community)
- **Categories:** Real estate, Automation, Integrations
- **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.

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

## Ohio eLicense Scraper

Look up **Ohio real estate, appraiser, home inspector, appraisal management company,
and related professional licenses** issued by the **Ohio Department of Commerce,
Division of Real Estate & Professional Licensing (REPL)**. Search by license number,
licensee/business name, or browse an entire license type — straight from Ohio's own
public eLicense Online license lookup tool. No login, no API key, no proxy required.

### What this actor does

- **Five search modes:**
  - `byLicenseType` — browse every license currently on file for a credential
    type (Real Estate Salesperson, Broker, Appraiser, Home Inspector,
    Appraisal Management Company, and more)
  - `byLicenseNumber` — exact license-number lookup
  - `byName` — search by licensee first/last (and optional maiden) name
  - `byBusinessName` — search by brokerage/company/DBA name
  - `byCity` — browse every license on file in a given city
- **37 Ohio REPL license/credential types** covering real estate brokers,
  broker associates, salespersons, real estate corporations/LLCs, certified
  general and residential appraisers (plus their out-of-state, reciprocal,
  and temporary variants), licensed real estate appraisers, appraisal
  management companies, home inspectors, and foreign real estate dealers
- **Narrow any search further** with optional city, county, state/province,
  zip code, and exact-match status filters
- **Empty fields are omitted** — a field only appears on a record when Ohio
  actually published that data for the licensee

### Output per license

- `licenseNumber` — Ohio REPL license/credential number
- `licenseType` — plain-English credential name (e.g. "Real Estate Salesperson")
- `licenseeName`, `firstName`, `lastName` — for individual licensees
- `businessName` — for brokerages, corporations, and appraisal management companies
- `status` — license status as published (e.g. "Active", "Expired")
- `board` — issuing division ("Ohio Division of Real Estate & Professional
  Licensing (Ohio Department of Commerce)")
- `address`, `city`, `state`, `zipCode`, `county` — mailing address, where published
- `issueDate`, `effectiveDate`, `expirationDate` — ISO dates, where published
- `supervisingBroker` — for salespersons, where published
- `sourceUrl` — the Ohio eLicense Online license lookup tool
- `recordType: "license"`, `scrapedAt`

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `mode` | string | `byLicenseType` | `byLicenseType` / `byLicenseNumber` / `byName` / `byBusinessName` / `byCity` |
| `licenseTypePrefix` | string | – | License/credential type code (required for `byLicenseType` and `byLicenseNumber`; optional narrowing filter otherwise) |
| `licenseNumber` | string | – | License number without the type prefix (mode=`byLicenseNumber`) |
| `licenseSuffix` | string | – | Optional sub-category/branch-office suffix (mode=`byLicenseNumber`) |
| `firstName` / `lastName` | string | – | Licensee name (mode=`byName`; at least one required) |
| `maidenName` | string | – | Optional maiden-name search field |
| `businessName` | string | – | Brokerage/company/DBA name (mode=`byBusinessName`) |
| `address` | string | – | Optional street-address filter |
| `city` | string | – | City (required for `byCity`; optional narrowing filter otherwise) |
| `county` | string | – | Optional Ohio county exact-match narrowing filter (e.g. `Franklin`) |
| `zipCode` | string | – | Optional 5-digit zip-code narrowing filter |
| `state` | string | – | Two-letter US state or Canadian province code |
| `status` | string | – | Optional exact-match license status filter |
| `maxItems` | integer | `20` | Maximum number of records to return (1-200) |
| `useApifyProxy` | boolean | `false` | Route the search through Apify's free datacenter proxy group |

#### Example: browse a license type

```json
{
  "mode": "byLicenseType",
  "licenseTypePrefix": "SAL",
  "status": "Active",
  "maxItems": 20
}
````

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

```json
{
  "mode": "byLicenseNumber",
  "licenseTypePrefix": "SAL",
  "licenseNumber": "2024001234"
}
```

#### Example: search by licensee name

```json
{
  "mode": "byName",
  "lastName": "Smith",
  "state": "OH",
  "maxItems": 20
}
```

#### Example: browse all real estate licenses in a city

```json
{
  "mode": "byCity",
  "city": "Columbus",
  "licenseTypePrefix": "SAL",
  "maxItems": 50
}
```

### Use cases

- **Real estate due diligence** — verify an agent's or broker's license status before signing a deal
- **Compliance monitoring** — track license status changes for agents, appraisers, or inspectors you work with
- **Lead generation** — build lists of licensed real estate professionals by city or credential type
- **Background research** — confirm licensure history for a specific real estate professional or business
- **Market research** — measure the number of active real estate licensees by license type or city

### Data Source

This actor targets **`elicense3.com.ohio.gov`** — the Ohio Department of
Commerce's "eLicense Online" public license lookup for its Division of Real
Estate & Professional Licensing. This is a distinct, older Ohio state
licensing portal from the newer, consolidated `elicense.ohio.gov` site (the
eLicense Ohio consortium covering ~24 separate boards including medical,
nursing, cosmetology, and engineering).

`elicense.ohio.gov` was evaluated first and found to be comprehensively
blocked at the network/WAF level: every page tested (the site root and the
`/oh_verifylicense` search page) returned a persistent F5 WAF `403 Forbidden`
("The requested URL was rejected") both from a plain `curl` request with a
realistic Chrome User-Agent header **and** from a full real headless Chromium
browser session (Playwright) — i.e. this is not merely a TLS-fingerprint or
missing-header block, both request types were rejected identically. Ohio's
`data.ohio.gov` open-data portal also republishes a "State of Ohio Licensure

- Individual" bulk dataset covering the same 24 boards (2.3M+ rows), but its
  only discovered public export path (`download-file`) consistently returns
  `412 Validation failed` for the documented request shape; the endpoint
  appears to require additional client-side request signing beyond what a
  plain HTTP client can replicate without live-browser reverse engineering.

`elicense3.com.ohio.gov` — a genuinely distinct, still-active, and fully
public Ohio government licensing system operated by the same Department of
Commerce — returns real HTML with no login wall, no CAPTCHA, and no bot
challenge for every page tested. It covers real estate brokers and
salespersons, real estate corporations/LLCs, certified general/residential
appraisers, licensed real estate appraisers, appraisal management companies,
home inspectors, and foreign real estate dealers.

### Limitations

- Ohio's own lookup page currently displays a notice that this system "has
  been retired and the data is no longer updated, effective 10/16/25" —
  the search tool itself is still live and fully queryable, but the
  underlying license records are a frozen snapshot as of that date rather
  than continuously updated. Ohio directs visitors to `com.ohio.gov/real`
  for current information; that destination does not expose an equivalent
  public search API at this time.
- This actor covers licenses issued by Ohio's Division of Real Estate &
  Professional Licensing only — it does not cover the ~24 other boards
  reachable through the newer `elicense.ohio.gov` consortium portal (medical,
  nursing, cosmetology, pharmacy, engineering, accountancy, etc.), which is
  blocked as documented above.
- A small number of credential-type codes (e.g. `ARA`, `BBB`, `BRKP`, `CBR`,
  `CEO`, `CRC`, `FPR`, `LPR`, `RECE`, `SALM`, `SOLE`) do not have a
  confidently documented plain-English meaning publicly available; these are
  exposed with their raw Ohio REPL code as the label rather than a guessed
  name (`CGR` is confirmed live to cover cemetery registrations, e.g.
  results named "\<Name> Cemetery").
- Browsing broadly by `licenseTypePrefix` alone (mode=`byLicenseType`, no
  name/city/status filter) returns Ohio's own default sort order, which is
  observed to surface long-inactive licenses (revoked/void/deceased/resigned)
  before currently active ones for large credential types. Add a `status`
  filter (the actor pages deeper automatically when `status` is set) or
  narrow with `city`/`name` to reliably surface active licensees.
- Fields such as `supervisingBroker`, `county`, and `effectiveDate` only
  appear on records where Ohio's own license-detail grid publishes them.

### FAQ

**Do I need a login or API key?**
No. This actor uses Ohio's public eLicense Online license lookup tool, which
requires no account.

**Can I look up a specific license number?**
Yes — set `mode` to `byLicenseNumber`, choose the matching `licenseTypePrefix`,
and enter the `licenseNumber`.

**How current is the data?**
Records are scraped live from Ohio's own license lookup tool at run time.

**Why don't some records have an expiration date or address?**
Ohio only publishes the fields it has on file for a given licensee. This
actor never fabricates or fills in placeholder values for missing data.

# Actor input Schema

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

Choose how to search Ohio's Division of Real Estate & Professional Licensing records.

## `licenseTypePrefix` (type: `string`):

Ohio REPL credential/license type. Required for `byLicenseNumber` and `byLicenseType`; optional narrowing filter for other modes.

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

Numeric license identifier, without the type-prefix letters (e.g. `2019005678`). Requires `licenseTypePrefix`.

## `licenseSuffix` (type: `string`):

Optional sub-category / branch-office suffix appended after the license number.

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

Licensee first name. At least one of `firstName` / `lastName` is required for `byName`.

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

Licensee last name. At least one of `firstName` / `lastName` is required for `byName`.

## `maidenName` (type: `string`):

Optional maiden-name search field.

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

Real estate corporation, brokerage, or appraisal-management-company name.

## `address` (type: `string`):

Optional street-address contains-filter.

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

Licensee/business city. Required for `byCity`; optional narrowing filter for other modes.

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

Optional Ohio county exact-match filter (e.g. `Franklin`), matched against the licensee/business mailing address on file. Leave blank for all counties.

## `zipCode` (type: `string`):

Optional 5-digit zip-code filter, matched against the licensee/business mailing address on file.

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

Two-letter US state or Canadian province code.

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

Optional exact-match filter on the license status text as returned by Ohio REPL (e.g. `Active`, `Expired`). Leave blank for all statuses.

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

Maximum number of license records to return.

## `useApifyProxy` (type: `boolean`):

Route the browser through Apify's free AUTO datacenter proxy group. Leave off unless you see 0 results and suspect an IP-based block.

## Actor input object example

```json
{
  "mode": "byLicenseType",
  "licenseTypePrefix": "SAL",
  "licenseNumber": "",
  "licenseSuffix": "",
  "firstName": "",
  "lastName": "Smith",
  "maidenName": "",
  "businessName": "",
  "address": "",
  "city": "",
  "county": "",
  "zipCode": "",
  "state": "OH",
  "status": "",
  "maxItems": 20,
  "useApifyProxy": false
}
```

# Actor output Schema

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

Dataset containing all scraped Ohio eLicense 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": "byLicenseType",
    "licenseTypePrefix": "SAL",
    "licenseNumber": "",
    "licenseSuffix": "",
    "firstName": "",
    "lastName": "Smith",
    "maidenName": "",
    "businessName": "",
    "address": "",
    "city": "",
    "county": "",
    "zipCode": "",
    "state": "OH",
    "status": "",
    "maxItems": 20,
    "useApifyProxy": false
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/ohio-elicense-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": "byLicenseType",
    "licenseTypePrefix": "SAL",
    "licenseNumber": "",
    "licenseSuffix": "",
    "firstName": "",
    "lastName": "Smith",
    "maidenName": "",
    "businessName": "",
    "address": "",
    "city": "",
    "county": "",
    "zipCode": "",
    "state": "OH",
    "status": "",
    "maxItems": 20,
    "useApifyProxy": False,
}

# Run the Actor and wait for it to finish
run = client.actor("crawlerbros/ohio-elicense-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": "byLicenseType",
  "licenseTypePrefix": "SAL",
  "licenseNumber": "",
  "licenseSuffix": "",
  "firstName": "",
  "lastName": "Smith",
  "maidenName": "",
  "businessName": "",
  "address": "",
  "city": "",
  "county": "",
  "zipCode": "",
  "state": "OH",
  "status": "",
  "maxItems": 20,
  "useApifyProxy": false
}' |
apify call crawlerbros/ohio-elicense-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Ohio eLicense Scraper",
        "description": "Look up Ohio professional and occupational licenses issued by the Ohio Department of Commerce's Division of Real Estate & Professional Licensing. Search by license number, name, business name, or license type. Get status, issue/expiration dates, and address.",
        "version": "1.0",
        "x-build-id": "gg4g3spRD8FCeaTsJ"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/crawlerbros~ohio-elicense-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-crawlerbros-ohio-elicense-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~ohio-elicense-scraper/runs": {
            "post": {
                "operationId": "runs-sync-crawlerbros-ohio-elicense-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~ohio-elicense-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-crawlerbros-ohio-elicense-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": [
                            "byLicenseType",
                            "byLicenseNumber",
                            "byName",
                            "byBusinessName",
                            "byCity"
                        ],
                        "type": "string",
                        "description": "Choose how to search Ohio's Division of Real Estate & Professional Licensing records.",
                        "default": "byLicenseType"
                    },
                    "licenseTypePrefix": {
                        "title": "License type (mode=byLicenseType, byLicenseNumber)",
                        "enum": [
                            "",
                            "ACG",
                            "ACGO",
                            "ACGR",
                            "ACGT",
                            "ACR",
                            "ACRO",
                            "ACRR",
                            "ACRT",
                            "ALR",
                            "ALRO",
                            "ALRR",
                            "ALRT",
                            "AMC",
                            "ARA",
                            "BBB",
                            "BRK",
                            "BRKA",
                            "BRKM",
                            "BRKP",
                            "CBR",
                            "CEO",
                            "CGR",
                            "CRC",
                            "FPR",
                            "FRC",
                            "FRDC",
                            "FRDI",
                            "FRS",
                            "HICE",
                            "HIQE",
                            "LPR",
                            "OHI",
                            "REC",
                            "RECE",
                            "SAL",
                            "SALM",
                            "SOLE"
                        ],
                        "type": "string",
                        "description": "Ohio REPL credential/license type. Required for `byLicenseNumber` and `byLicenseType`; optional narrowing filter for other modes.",
                        "default": ""
                    },
                    "licenseNumber": {
                        "title": "License number (mode=byLicenseNumber)",
                        "type": "string",
                        "description": "Numeric license identifier, without the type-prefix letters (e.g. `2019005678`). Requires `licenseTypePrefix`.",
                        "default": ""
                    },
                    "licenseSuffix": {
                        "title": "License suffix (mode=byLicenseNumber, optional)",
                        "type": "string",
                        "description": "Optional sub-category / branch-office suffix appended after the license number.",
                        "default": ""
                    },
                    "firstName": {
                        "title": "First name (mode=byName)",
                        "type": "string",
                        "description": "Licensee first name. At least one of `firstName` / `lastName` is required for `byName`.",
                        "default": ""
                    },
                    "lastName": {
                        "title": "Last name (mode=byName)",
                        "type": "string",
                        "description": "Licensee last name. At least one of `firstName` / `lastName` is required for `byName`.",
                        "default": ""
                    },
                    "maidenName": {
                        "title": "Maiden name (mode=byName, optional)",
                        "type": "string",
                        "description": "Optional maiden-name search field.",
                        "default": ""
                    },
                    "businessName": {
                        "title": "Business name / DBA (mode=byBusinessName)",
                        "type": "string",
                        "description": "Real estate corporation, brokerage, or appraisal-management-company name.",
                        "default": ""
                    },
                    "address": {
                        "title": "Street address (optional narrowing filter)",
                        "type": "string",
                        "description": "Optional street-address contains-filter.",
                        "default": ""
                    },
                    "city": {
                        "title": "City (mode=byCity, optional narrowing filter for other modes)",
                        "type": "string",
                        "description": "Licensee/business city. Required for `byCity`; optional narrowing filter for other modes.",
                        "default": ""
                    },
                    "county": {
                        "title": "County (optional narrowing filter)",
                        "type": "string",
                        "description": "Optional Ohio county exact-match filter (e.g. `Franklin`), matched against the licensee/business mailing address on file. Leave blank for all counties.",
                        "default": ""
                    },
                    "zipCode": {
                        "title": "Zip code (optional narrowing filter)",
                        "type": "string",
                        "description": "Optional 5-digit zip-code filter, matched against the licensee/business mailing address on file.",
                        "default": ""
                    },
                    "state": {
                        "title": "State / province (optional narrowing filter)",
                        "enum": [
                            "",
                            "AL",
                            "AK",
                            "AB",
                            "AS",
                            "AP",
                            "AZ",
                            "AR",
                            "AE",
                            "BC",
                            "CA",
                            "CO",
                            "CT",
                            "DE",
                            "DC",
                            "FM",
                            "FL",
                            "GA",
                            "GU",
                            "HI",
                            "ID",
                            "IL",
                            "IN",
                            "IA",
                            "KS",
                            "KY",
                            "LA",
                            "ME",
                            "MB",
                            "MH",
                            "MD",
                            "MA",
                            "MX",
                            "MI",
                            "MN",
                            "MS",
                            "MO",
                            "MT",
                            "NE",
                            "NV",
                            "NB",
                            "NH",
                            "NJ",
                            "NM",
                            "NY",
                            "NF",
                            "NC",
                            "ND",
                            "MP",
                            "NT",
                            "NS",
                            "OH",
                            "OK",
                            "ON",
                            "OR",
                            "PW",
                            "PA",
                            "PE",
                            "PR",
                            "PQ",
                            "RI",
                            "SK",
                            "SC",
                            "SD",
                            "TN",
                            "TX",
                            "UK",
                            "UT",
                            "VT",
                            "VI",
                            "VA",
                            "WA",
                            "WV",
                            "WI",
                            "WY",
                            "YT"
                        ],
                        "type": "string",
                        "description": "Two-letter US state or Canadian province code.",
                        "default": ""
                    },
                    "status": {
                        "title": "License status (optional narrowing filter, exact match)",
                        "type": "string",
                        "description": "Optional exact-match filter on the license status text as returned by Ohio REPL (e.g. `Active`, `Expired`). Leave blank for all statuses.",
                        "default": ""
                    },
                    "maxItems": {
                        "title": "Max results",
                        "minimum": 1,
                        "maximum": 200,
                        "type": "integer",
                        "description": "Maximum number of license records to return.",
                        "default": 20
                    },
                    "useApifyProxy": {
                        "title": "Use Apify Proxy (datacenter)",
                        "type": "boolean",
                        "description": "Route the browser through Apify's free AUTO datacenter proxy group. Leave off unless you see 0 results and suspect an IP-based block.",
                        "default": false
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
