# Florida Optometrist License Verification (`automation-lab/florida-optometrist-license-verification`) Actor

Search the Florida DOH public optometrist registry by surname and export license, status, city, practitioner, and official verification URL.

- **URL**: https://apify.com/automation-lab/florida-optometrist-license-verification.md
- **Developed by:** [Automation Lab](https://apify.com/automation-lab) (community)
- **Categories:** Business
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.52 / 1,000 item processeds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
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

## Florida Optometrist License Verification

Look up **Florida optometrist licenses** in the Florida Department of Health (DOH) Medical Quality Assurance (MQA) public search portal. Enter practitioner surnames and get individual license numbers, names, professions, cities, current displayed statuses, and official license-verification URLs in a structured dataset. A healthcare credentialing team can rerun the same inputs to compare the latest public records with its own provider roster.

The public search says its results refresh nightly from the primary database. This Actor does not independently verify a person's identity or determine whether a practitioner is authorized to practice; consult the linked official license detail before making a decision.

### Who is it for?

- Provider enrollment and credentialing teams checking Florida optometrists on a recurring schedule.
- Health network compliance analysts reconciling names and license numbers from an internal roster.
- Researchers compiling public optometry credential snapshots for Florida.

### Why use this lookup?

One run accepts up to 20 surnames, follows the MQA result pages, deduplicates license numbers, and returns a direct official verification link per record. Unlike a generic provider directory, the result reports the status actually shown in the Florida regulator's public search. Names are not unique; use the license number and official detail page to distinguish people.

### What data is returned?

| Field | Meaning |
| --- | --- |
| `licenseNumber` | Number displayed by Florida MQA, including prefix |
| `practitioner` | Public holder name as shown in the search result |
| `profession` | Profession on the source row |
| `city` | Public city on the source row |
| `status` | Source's displayed license status, such as `Clear/Active` |
| `verificationUrl` | Individual official MQA verification detail link |
| `searchedSurname` | Surname input that matched this record |
| `checkedAt` | UTC retrieval timestamp, not a source issue date |

Only optometrist profession code 1801 is searched. All statuses are included. The search results may include profession labels such as `CERTIFIED OPTOM` within that profession code.

### How to get started

1. Enter at least one surname in **Practitioner surnames**; the prefilled `Smith` example is a real query with multiple records.
2. Choose **Maximum license records** to bound dataset size and runtime.
3. Run the Actor and open the **License records** dataset view.
4. Open each `verificationUrl` when making a credentialing decision. Save the dataset with the run timestamp for your audit trail.

### Input parameters

| Name | Required | Default | Description |
| --- | --- | --- | --- |
| `lastNames` | Yes | `Smith` prefill | 1–20 surnames; letters, spaces, hyphens and apostrophes, 2–80 characters each |
| `maxItems` | No | 50 | Maximum unique records emitted across all surnames, 1–1,000 |

Example input:

```json
{"lastNames":["Smith"],"maxItems":5}
```

### Sample output

A sample from the public MQA search (values can change on later nightly refreshes):

```json
{
  "licenseNumber": "OPC1445",
  "practitioner": "SMITH, ALAN J",
  "profession": "CERTIFIED OPTOM",
  "city": "WESLEY CHAPEL",
  "status": "Clear/Active",
  "verificationUrl": "https://mqa-internet.doh.state.fl.us/MQASearchServices/HealthCareProviders/LicenseVerification?LicInd=1076&ProCde=1801",
  "searchedSurname": "Smith",
  "checkedAt": "2026-09-25T12:00:00.000Z"
}
```

The `checkedAt` above illustrates the field shape; your run produces its own current UTC timestamp.

### How much does it cost to verify Florida optometrist licenses?

The Actor uses pay-per-event pricing: a one-time **$0.005 `start`** event per run and one `item` event per emitted license row. The BRONZE item price is **$0.005864 per record**; FREE is $0.0067436, SILVER $0.0045739, and GOLD/PLATINUM/DIAMOND $0.0035184. At BRONZE, 1 row costs approximately $0.010864, 20 rows $0.12228, and 100 rows $0.5914 (including start). No item event is charged for an empty result. These are estimates; check the Apify pricing panel for your actual spend tier, allowances and billing rules. Refunds, fraud, disputes, taxes, corrections and clawbacks may change eventual payouts. Larger surname lists can return more records and cost more, up to your configured result limit.

### Integration ideas

Schedule a run in Apify for your recurring roster checks and export its default dataset as CSV, JSON or Excel. Join on `licenseNumber` rather than a person's name; compare today's `status` with your previous stored snapshot in your own pipeline. Send only official verification URLs to the credentialing reviewer, not a guessed practitioner match. Apify webhooks can notify your system when a scheduled run finishes; this Actor itself does not send alerts or maintain historical diffs.

### API example: cURL

```bash
curl -X POST 'https://api.apify.com/v2/acts/automation-lab~florida-optometrist-license-verification/run-sync-get-dataset-items?token=YOUR_APIFY_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"lastNames":["Smith"],"maxItems":5}'
```

Use your own Apify token; do not put it in public tasks.

### API example: JavaScript

```js
import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/florida-optometrist-license-verification').call({ lastNames: ['Smith'], maxItems: 5 });
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

### API example: Python

```python
import os
from apify_client import ApifyClient
client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/florida-optometrist-license-verification').call(run_input={'lastNames': ['Smith'], 'maxItems': 5})
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

### MCP usage

For Claude Code:

```bash
claude mcp add --transport http apify \
  'https://mcp.apify.com?tools=automation-lab/florida-optometrist-license-verification'
```

For Claude Desktop, Cursor, or VS Code with an HTTP MCP server configuration, configure:

```json
{"mcpServers":{"apify":{"url":"https://mcp.apify.com?tools=automation-lab/florida-optometrist-license-verification"}}}
```

Example prompts for MCP usage:

- “Run the Florida optometrist license lookup for Smith, limit five, and include official verification links.”
- “Check the Florida DOH optometrist surname Jones and summarize the public license status for each returned license number.”

Review actual status on the regulator site.

### Limits and accuracy

The source is Florida DOH MQA, not a national optometry registry. The search is surname-based; similarly named people may be returned. It does not provide disciplinary history, practice privileges, independent identity matching, or a permanent historical status record. It reads the public search's nightly-refreshed results, not the regulator's primary database in real time. A result limit can truncate the output; increase `maxItems` if the source has more results than requested. An upstream site redesign, challenge or outage causes a failed run instead of silently returning an apparently complete empty dataset.

### Legality and responsible use

The data is publicly displayed by Florida DOH; this independent Actor is not affiliated with or endorsed by the agency. No AI is used. The Actor sends requested surnames to the Florida DOH public search and stores the returned public license rows in your Apify default dataset. It keeps no separate persistent cache; datasets and logs follow your Apify account retention settings, and you can delete them in the Apify Console. Follow applicable law, source conditions, privacy requirements and your organization's policies. Do not treat an Actor output snapshot as a certified primary-source verification letter. Open the official verification page and confirm the current record before consequential decisions.

### Troubleshooting and FAQ

**Why did my search return no records?** Check the spelling and try fewer terms. A valid empty response is distinct from an upstream error. Search on the official portal if you expect a known license.

**Why do I see several practitioners with the same surname?** The source searches a surname, not a unique person. Compare license numbers and official details.

**Does this monitor changes automatically?** No. Schedule repeat runs in Apify, then compare the separate datasets in your own workflow.

**Can I search other professions or states?** No. This Actor restricts every query to Florida DOH's optometrist profession code.

**Where can I report a problem?** Use the Actor's Apify Store issue form with the run ID and a non-sensitive reproduction input; do not paste personal data or tokens.

### Related automation-lab Actors

For other Florida professions governed by a different agency, see [Florida DBPR License Records Search](https://apify.com/automation-lab/florida-dbpr-license-records-search). It does not substitute for Florida DOH optometrist verification.

# Changelog

This Actor's version history is a separate document: https://apify.com/automation-lab/florida-optometrist-license-verification/changelog.md

# Actor input Schema

## `lastNames` (type: `array`):

One to twenty real optometrist surnames to search. Results from each surname are deduplicated by license number.

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

Stop after this many unique Florida optometrist license rows across all surnames.

## Actor input object example

```json
{
  "lastNames": [
    "Smith"
  ],
  "maxItems": 10
}
```

# Actor output Schema

## `overview` (type: `string`):

View matching Florida optometrist license rows, including public status and source links.

# 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 = {
    "lastNames": [
        "Smith"
    ],
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/florida-optometrist-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 = {
    "lastNames": ["Smith"],
    "maxItems": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/florida-optometrist-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 '{
  "lastNames": [
    "Smith"
  ],
  "maxItems": 10
}' |
apify call automation-lab/florida-optometrist-license-verification --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,automation-lab/florida-optometrist-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/lPF6vektf3gdaHsO2/builds/IpnLdPnUDagX7KxPc/openapi.json