# Connecticut Nursing License Lookup Scraper (`automation-lab/connecticut-nursing-license-lookup`) Actor

Search official Connecticut nursing credentials by name, type, status, city, or license number and export verification-ready records.

- **URL**: https://apify.com/automation-lab/connecticut-nursing-license-lookup.md
- **Developed by:** [Stas Persiianenko](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 $2.02 / 1,000 license record extracteds

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?

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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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

## Connecticut Nursing License Lookup Scraper

Search the official Connecticut eLicense data by holder name, credential type, status, city, or license number. The Actor exports verification-ready nursing credential records from Connecticut Open Data, including identity, credential code, status and reason, dates, location, responsible department, and source provenance.

The source is updated daily and contains active and inactive records. No Connecticut eLicense account, browser, or proxy configuration is required.

### What does this Actor do?

Connecticut Nursing License Lookup Scraper turns repeatable public-license checks into structured dataset rows.

It can:

- look up a Connecticut nurse by partial holder name;
- verify a full credential code or numeric credential number;
- filter RN, LPN, APRN, nurse-midwife, temporary, and nursing-home-administrator credentials;
- select active, inactive, or pending credentials;
- narrow a credential category by city;
- run up to 25 searches in one task;
- deduplicate credentials found by overlapping searches;
- stop at a user-controlled maximum result count.

Every result includes links to the official eLicense verification page and Connecticut's source dataset.

### Who is it for?

#### Healthcare employers

Check public credential status and expiration dates during onboarding or periodic workforce reviews.

#### Staffing and recruiting teams

Export nursing credentials into a spreadsheet, ATS enrichment step, or internal verification queue.

#### Compliance teams

Schedule the same input and compare datasets across runs to identify public status or expiration changes.

#### Data and integration teams

Use typed JSON instead of manually copying records from an interactive lookup page.

This Actor provides public source data. It does not make hiring, credentialing, disciplinary, or legal decisions for you.

### Supported nursing credentials

The Actor deliberately limits source results to professional nursing categories:

- Registered Nurse
- Registered Nurse - Temporary
- Licensed Practical Nurse
- Licensed Practical Nurse - Temporary
- Advanced Practice Registered Nurse
- Licensed Nurse Midwife
- Nursing Home Administrator

This whitelist prevents similarly named but unrelated nursery permits, facilities, and service-agency records from entering the output.

### What data is extracted?

| Field | Meaning |
| --- | --- |
| `holderName` | Public credential holder name |
| `fullCredentialCode` | Complete Connecticut credential code |
| `credentialNumber` | Number without the type prefix |
| `credentialDescription` | Nursing credential category |
| `department` | Responsible Connecticut department |
| `status` | Current public status |
| `statusReason` | Public reason associated with the status |
| `isActive` | Normalized active flag |
| `issueDate` | Original issue date when available |
| `effectiveDate` | Current effective date |
| `expirationDate` | Current expiration date |
| `address`, `city`, `state`, `zip` | Public source location fields |
| `recordRefreshedOn` | Date Connecticut refreshed the record |
| `verificationUrl` | Official interactive verification page |
| `sourceDatasetUrl` | Official daily source dataset |
| `query` | Filters that produced the record |
| `scrapedAt` | Actor extraction timestamp |

Source fields can be absent. Nullable output fields are returned as `null` rather than invented values.

### How to run your first lookup

1. Open the Actor in Apify Console.
2. Add one or more objects to **License searches**.
3. Enter a name, license number, credential type, status, or city.
4. Set **Maximum results**.
5. Click **Start**.
6. Open the Dataset tab to inspect, download, or integrate the records.

A search object combines its filters with AND logic. Separate objects are independent searches and their results are merged and deduplicated.

### Input parameters

#### `queries`

An array of 1–25 search objects. Each object must contain at least one filter.

| Filter | Behavior |
| --- | --- |
| `name` | Case-insensitive holder-name fragment, 2–100 characters |
| `licenseNumber` | Exact numeric credential number or full code |
| `credentialType` | One supported nursing credential category |
| `status` | `ACTIVE`, `INACTIVE`, or `PENDING` |
| `city` | Case-insensitive city fragment, 2–100 characters |

#### `maxItems`

Maximum unique credentials saved across all searches. The range is 1–10,000 and the default is 100.

Example:

```json
{
  "queries": [
    {
      "name": "Smith",
      "credentialType": "Registered Nurse",
      "status": "ACTIVE"
    }
  ],
  "maxItems": 10
}
```

### Batch workforce verification example

Use exact full credential codes to verify several nursing roles in one run:

```json
{
  "queries": [
    { "licenseNumber": "10.061935" },
    { "licenseNumber": "11.036142" },
    { "licenseNumber": "12.004821" }
  ],
  "maxItems": 3
}
```

Each query remains visible in its output row, which makes downstream reconciliation straightforward.

### Output example

A current output row has this shape:

```json
{
  "credentialId": "1000123",
  "holderName": "Jordan A SAMPLE",
  "holderType": "INDIVIDUAL",
  "fullCredentialCode": "10.012345",
  "credentialTypeCode": "10",
  "credentialNumber": "12345",
  "credentialDescription": "Registered Nurse",
  "department": "Connecticut Department of Public Health",
  "status": "ACTIVE",
  "statusReason": "CURRENT",
  "isActive": true,
  "issueDate": "2024-01-15T00:00:00.000",
  "effectiveDate": "2026-01-01T00:00:00.000",
  "expirationDate": "2027-01-31T00:00:00.000",
  "city": "Hartford",
  "state": "CT",
  "recordRefreshedOn": "2026-08-20T00:00:00.000",
  "verificationUrl": "https://www.elicense.ct.gov/Lookup/LicenseLookup.aspx",
  "sourceDatasetUrl": "https://data.ct.gov/Business/State-Licenses-and-Credentials/ngch-56tr",
  "query": { "credentialType": "Registered Nurse", "status": "ACTIVE" },
  "scrapedAt": "2026-08-25T20:00:00.000Z"
}
```

The example identity and code are anonymized. Actual datasets contain public source values.

### How much does it cost to verify Connecticut nursing licenses?

Pay-per-event pricing includes a **$0.00005 start fee** and one `item` charge for each saved credential.

| Tier | Price per saved credential |
| --- | ---: |
| FREE | $0.003864 |
| BRONZE | $0.00336 |
| SILVER | $0.0026208 |
| GOLD | $0.002016 |
| PLATINUM | $0.001344 |
| DIAMOND | $0.0009408 |

At the BRONZE rate, 10 saved credentials cost about **$0.03365** including the start fee, 100 cost about **$0.33605**, and 1,000 cost about **$3.36005**. Apify selects the applicable tier for the account.

No proxy charge is required by this Actor. Empty searches incur the start event but no item events.

### Recurring monitoring and integrations

The Actor returns current snapshots rather than a built-in change log. For monitoring:

1. save a stable input as an Apify Task;
2. schedule it daily, weekly, or monthly;
3. export each run's dataset;
4. compare `credentialId`, `status`, `statusReason`, `expirationDate`, and `recordRefreshedOn` in your system.

Useful integrations include Google Sheets, webhooks, Make, Zapier, cloud storage, databases, and internal compliance pipelines.

### Run with the Apify API

Replace `YOUR_TOKEN` with an Apify API token.

#### cURL

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~connecticut-nursing-license-lookup/runs?token=YOUR_TOKEN&waitForFinish=120" \
  -H "Content-Type: application/json" \
  -d '{"queries":[{"licenseNumber":"10.061935"}],"maxItems":1}'
```

#### JavaScript

```javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/connecticut-nursing-license-lookup').call({
  queries: [{ credentialType: 'Advanced Practice Registered Nurse', status: 'ACTIVE', city: 'Hartford' }],
  maxItems: 25,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_TOKEN")
run = client.actor("automation-lab/connecticut-nursing-license-lookup").call(
    run_input={"queries": [{"name": "Smith", "credentialType": "Registered Nurse"}], "maxItems": 10}
)
items = client.dataset(run["defaultDatasetId"]).list_items().items
print(items)
```

### Use through MCP

#### Claude Code setup

Add the Actor to Claude Code:

```bash
claude mcp add --transport http apify \
  "https://mcp.apify.com?tools=automation-lab/connecticut-nursing-license-lookup"
```

#### Claude Desktop, Cursor, and VS Code setup

Claude Desktop, Cursor, and VS Code can use this MCP configuration:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=automation-lab/connecticut-nursing-license-lookup"
    }
  }
}
```

Example prompts:

- “Verify Connecticut registered nurse code 10.061935 and return its current status and expiry.”
- “Find active Connecticut APRN credentials in Hartford, limited to 25 results.”
- “Run these three nursing credential numbers and format status changes for a spreadsheet.”

### Accuracy, freshness, and limitations

- Records come from Connecticut's official State Licenses and Credentials dataset.
- Connecticut describes the dataset as updated daily; this is not a real-time guarantee.
- The Actor does not expose private records, accounts, login-only data, or non-public discipline documents.
- A missing record is not proof that a person has never held a credential.
- Name searches are substring searches and can match multiple people.
- Address fields are public source fields and may be absent or outdated.
- The Actor does not decide whether a credential satisfies a role's legal requirements.
- Upstream outages or rate limits cause a clear failed run after bounded retries.

For consequential decisions, follow the `verificationUrl` and confirm the record with the responsible authority.

### Legality and responsible use

License and credential records can contain personal information. Use them for a legitimate verification purpose, minimize retained fields, secure exports, and follow applicable employment, privacy, discrimination, and records laws.

Do not use this Actor to harass individuals, construct sensitive profiles, or make automated adverse decisions without appropriate review. Apify users are responsible for their inputs, storage, integrations, and legal basis.

### Troubleshooting

#### Why did my run return no results?

Check the spelling and remove one filter at a time. Filters inside one query object are combined, so an incorrect city or status can exclude an otherwise matching credential. Try the numeric portion and full credential code separately only when needed.

#### Why was my input rejected?

Every query needs at least one supported filter. Names and cities need at least two characters. License numbers accept letters, numbers, periods, and hyphens. Credential types and statuses must use a listed value.

#### Why did the run fail with an upstream error?

Connecticut Open Data may be unavailable or rate limited. The Actor retries transient responses three times. Retry later rather than raising concurrency or adding proxies.

#### Why are two searches returning one row?

The Actor deduplicates overlapping searches by Connecticut credential identifier. The first matching query remains in the output row.

### Related Automation Lab Actors

- [Texas Pharmacy License Lookup](https://apify.com/automation-lab/texas-pharmacy-license-lookup) for Texas pharmacist, pharmacy, intern, and technician verification.
- [Virginia Real Estate License Lookup](https://apify.com/automation-lab/virginia-real-estate-license-lookup) for Virginia real-estate regulant exports.
- [Pennsylvania Attorney Registry Lookup](https://apify.com/automation-lab/pennsylvania-attorney-registry-lookup) for Pennsylvania attorney registration due diligence.

Choose this Actor when the job is specifically Connecticut public nursing credential verification.

### FAQ

#### Does it require an eLicense login?

No. It uses Connecticut's anonymous official Open Data API.

#### Does it support inactive credentials?

Yes. Set `status` to `INACTIVE`, or omit status to include every public status matching the other filters.

#### Can I search only by credential type?

Yes. Set one supported `credentialType` and control the export size with `maxItems`.

#### Can it search several license numbers at once?

Yes. Add one query object per number, up to 25 searches per run.

#### Does it publish monitoring alerts?

No. Schedule an Apify Task and compare datasets in your chosen integration.

#### Are issue and expiration dates always present?

No. The Actor preserves missing source fields as `null`.

#### Is this an official Connecticut government service?

No. It is an independent Apify Actor that reads official public Connecticut datasets and preserves source links for verification.

# Actor input Schema

## `queries` (type: `array`):

One to 25 searches. Each object must contain at least one filter. Multiple filters in one object are combined.

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

Maximum unique credentials saved across all searches.

## Actor input object example

```json
{
  "queries": [
    {
      "name": "Smith",
      "credentialType": "Registered Nurse",
      "status": "ACTIVE"
    }
  ],
  "maxItems": 10
}
```

# Actor output Schema

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

Dataset containing matched Connecticut nursing credentials.

# 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 = {
    "queries": [
        {
            "name": "Smith",
            "credentialType": "Registered Nurse",
            "status": "ACTIVE"
        }
    ],
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/connecticut-nursing-license-lookup").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 = {
    "queries": [{
            "name": "Smith",
            "credentialType": "Registered Nurse",
            "status": "ACTIVE",
        }],
    "maxItems": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/connecticut-nursing-license-lookup").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 '{
  "queries": [
    {
      "name": "Smith",
      "credentialType": "Registered Nurse",
      "status": "ACTIVE"
    }
  ],
  "maxItems": 10
}' |
apify call automation-lab/connecticut-nursing-license-lookup --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,automation-lab/connecticut-nursing-license-lookup"
        }
    }
}

```

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/QeF4KahWgTCN02smQ/builds/cSEFJBLOqhKzzDf1f/openapi.json