# US Clinical Lab Leads Scraper (CLIA Registry) (`scrapesage/clinical-lab-leads-scraper`) Actor

Scrape every US clinical lab from the official CMS CLIA registry: name, phone, fax, address, certificate & facility type, accreditation, annual test volume, new-lab & ownership signals + lead score. Filter by state, lab type & size. B2B lab leads + monitoring.

- **URL**: https://apify.com/scrapesage/clinical-lab-leads-scraper.md
- **Developed by:** [Scrape Sage](https://apify.com/scrapesage) (community)
- **Categories:** Lead generation, Automation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$5.00 / 1,000 clinical lab records

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## US Clinical Lab Leads Scraper — CLIA Registry, Labs, Test Volume & B2B Leads

Extract **every US clinical and diagnostic laboratory** straight from the official **[CMS CLIA registry](https://www.cms.gov/medicare/quality/clinical-laboratory-improvement-amendments)** (Clinical Laboratory Improvement Amendments — the federal database of all ~320,000 certified labs). Every lab comes back as a ready-to-use **B2B lead**: lab name, **phone, fax**, full address, county, **certificate type** (compliance / accreditation / PPM / waiver), **facility type** (independent, hospital, physician office, blood bank, dialysis, community clinic…), ownership, **accreditation body** (CAP, COLA, Joint Commission, A2LA, AABB…), **estimated annual test volume + size tier**, lifecycle signals (new lab, ownership change, expiring certificate, compliance status) and a derived **lead score**.

No login, no cookies, no browser, **no API key** — fast, reliable extraction from the CMS Provider of Services data API.

### Why this CLIA lab scraper?

Generic "find-a-lab" Google-Maps scrapers grab a name and a guessed email and miss everything that lets you **segment and qualify** a lab. This actor reads the official CMS regulatory registry directly and ships the **richest dataset in the category** — firmographics **and** every certificate, size, accreditation and lifecycle signal, in one clean table.

| Data | Maps / email scrapers | This actor |
|---|---|---|
| Lab name, full address, county, geo | partial | ✅ |
| **Phone + fax** (from the federal record) | guessed / scraped | ✅ ~100% phone |
| **CLIA number** (CMS Certification Number) | ❌ | ✅ |
| **Certificate type** (compliance / accreditation / PPM / waiver / registration) | ❌ | ✅ |
| **Facility type** (independent, hospital, physician office, blood bank, dialysis…) | ❌ | ✅ 29 types |
| Ownership (proprietary / private / nonprofit / government) | ❌ | ✅ |
| **Accreditation body** (CAP / COLA / Joint Commission / A2LA / AABB / AOA / ASHI) | ❌ | ✅ |
| **Estimated annual test volume + size tier** | ❌ | ✅ |
| New-lab / ownership-change / certificate-expiration signals | ❌ | ✅ |
| Compliance status, multi-site & affiliated-lab network | ❌ | ✅ |
| Derived **lead score + lead signals** | ❌ | ✅ |
| Only-new / changed **monitoring mode** | ❌ | ✅ |

### Who buys clinical-lab data?

- **IVD & diagnostics manufacturers** — sell analyzers, reagents, assays and test kits; target labs by size (test volume), certificate type and specialty facility type.
- **LIS / LIMS & lab software vendors** — find independent and hospital labs running real volume; new labs need a system on day one.
- **Lab billing / revenue-cycle & consulting** — labs flagged *not in compliance* or with **expiring certificates** are in-market for compliance, accreditation and RCM services.
- **Reference labs & send-out partnerships** — map physician-office and small labs in a region that send out specialized testing.
- **Lab supplies, consumables & courier/logistics** — every active lab is a recurring-supply and specimen-transport account.
- **Accreditation & proficiency-testing organizations** — target labs by current accreditation body and renewal timing.
- **M&A, market & competitive intelligence** — track new labs each quarter, ownership changes and multi-site networks.

### How to use

1. [Sign up for Apify](https://console.apify.com/sign-up) — the free plan is enough to try this actor.
2. Open the **US Clinical Lab Leads Scraper**, set one or more **states** (or leave empty for all 50 + DC), optionally pick **facility types**, **certificate types** or a **size** filter, and choose your limit.
3. Click **Start** and watch lab records stream into the dataset table.
4. **Export** as JSON, CSV, Excel, XML, or RSS — or pull results programmatically via the [Apify API](https://docs.apify.com/api/v2).

### Input

```json
{
    "states": ["CA", "TX"],
    "facilityTypes": ["independentLab", "hospital"],
    "certificateTypes": ["accreditation", "compliance"],
    "minTestVolume": 25000,
    "sortBy": "leadScore",
    "maxResults": 1000
}
````

- **states** — two-letter state codes (e.g. `["CA","TX"]`). Leave empty to scrape all 50 states + DC. Territories (PR, GU, VI, AS, MP) are also supported.
- **facilityTypes** — keep only `independentLab`, `hospital`, `physicianOffice`, `skilledNursing`, `communityClinic`, `ruralHealthClinic`, `fqhc`, `dialysis`, `bloodBank`, `ambulatorySurgery`, `homeHealth`, `hospice`, `assistedLiving`, `pharmacy`, `publicHealth`, `school`, `mobileLab`, and more.
- **certificateTypes** — `compliance`, `accreditation`, `ppm` (provider-performed microscopy), `waiver`, `registration`.
- **ownershipTypes** — `proprietary`, `private`, `nonprofit`, `government`.
- **accreditedBy** — `cap`, `cola`, `jointCommission`, `a2la`, `aabb`, `aoa`, `ashi`.
- **cities / counties / zipCodes / nameQuery** — location and name filters.
- **cliaNumbers** — look up specific labs by CLIA number (CMS Certification Number).
- **activeOnly** *(default true)*, **withPhoneOnly**, **multiSiteOnly**, **notInComplianceOnly** — record filters.
- **minTestVolume / labSizeTiers** — size filters (`micro`, `small`, `medium`, `large`, `veryLarge`).
- **newLabWithinDays** — only labs first certified within N days (brand-new labs that need everything).
- **ownershipChangedWithinDays** — only labs with a recent change of ownership (M\&A / new decision-maker).
- **certificateExpiringWithinDays** — only labs whose CLIA certificate expires within N days (renewal timing).
- **minLeadScore / maxResults / maxResultsPerState / sortBy / deduplicateResults** — output controls. Sort by `leadScore` (default), `testVolumeHigh`, `newest`, `expiringSoon`, `name`, or `source`.
- **monitorMode / monitorKey** — only return labs that are new or changed since the last run.
- **proxyConfiguration** — optional; the CMS data API needs no proxy, so leave it off for the fastest queries.

### Output

By default you get **one clean, dense table of laboratories** — every column applies to every row. A lab record:

```json
{
    "cliaNumber": "27D0405331",
    "labName": "Cccs Toxicology Lab",
    "phone": "(406) 782-0417",
    "fax": "(406) 782-0418",
    "street": "1019 East Front Street",
    "city": "Butte",
    "state": "MT",
    "county": "Silver Bow",
    "zip": "59701",
    "fullAddress": "1019 East Front Street, Butte, MT, 59701",
    "certificateType": "Certificate of Accreditation",
    "facilityType": "Independent Laboratory",
    "ownershipType": "Proprietary",
    "ownershipCategory": "proprietary",
    "isIndependentLab": true,
    "estimatedAnnualTestVolume": 144000,
    "labSizeTier": "large",
    "accreditations": ["COLA"],
    "isAccredited": true,
    "status": "active",
    "complianceStatus": "In compliance",
    "certificationDate": "2021-06-14",
    "originalParticipationDate": "2009-03-02",
    "certificateExpirationDate": "2026-09-06",
    "certificateExpiresInDays": 77,
    "isNewLab": false,
    "changeOfOwnershipCount": 1,
    "isMultiSiteCertificate": false,
    "affiliatedCliaNumbers": [],
    "leadScore": 100,
    "leadSignals": ["Independent laboratory", "Accredited (COLA)", "Certificate expires 2026-09-06", "High test volume (~144,000/yr)"],
    "scrapedAt": "2026-06-21T00:16:00.000Z"
}
```

Every record also carries the raw CMS source row under `sourceFields` (all 100+ original columns) unless you turn off **includeRawFields**. Switch the dataset view to **Labs**, **Lab leads**, or **Size & accreditation** for a focused table.

#### What to expect (field coverage)

The CLIA registry is a regulatory file, so the core lead fields are near-complete.

| Field group | Coverage |
|---|---|
| Lab name, address, state, CLIA number, certificate & facility type | ✅ ~100% |
| **Phone**, county, ownership, certification dates | ✅ high (~100% phone on tested states) |
| Fax | ✅ present for most labs |
| Estimated annual test volume & size tier | ✅ present whenever the lab reported a volume |
| Accreditation bodies | present for accreditation-certificate labs |
| Ownership-change / expiration signals | present when CMS records them |

A blank field means CMS doesn't publish that signal for that lab — not that scraping failed. Nothing is dropped, so you always get the richest record available.

### Automate & schedule

Run this actor on autopilot and pull results into your own stack:

- **[Apify API](https://docs.apify.com/api/v2)** — start runs, fetch datasets, and manage schedules over REST.
- **[apify-client for JavaScript](https://docs.apify.com/api/client/js/)** and **[apify-client for Python](https://docs.apify.com/api/client/python/)** — official SDKs.
- **[Schedules](https://docs.apify.com/platform/schedules)** — run it monthly/quarterly with **monitoring mode** to capture newly-certified labs and changed certificates as fresh leads (CMS refreshes CLIA every quarter).
- **[Webhooks](https://docs.apify.com/platform/integrations/webhooks)** — trigger downstream actions (CRM import, Slack alert, email sequence) the moment a run finishes.

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

const client = new ApifyClient({ token: 'MY_APIFY_TOKEN' });

const run = await client.actor('scrapesage/clinical-lab-leads-scraper').call({
    states: ['CA'],
    facilityTypes: ['independentLab'],
    minTestVolume: 25000,
    sortBy: 'leadScore',
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(`Got ${items.length} labs`);
```

### Integrate with any app

Connect the dataset to 5,000+ apps — no code required:

- **[Make](https://docs.apify.com/platform/integrations/make)** — multi-step automation scenarios.
- **[Zapier](https://docs.apify.com/platform/integrations/zapier)** — push new lab leads straight into your CRM.
- **[Slack](https://docs.apify.com/platform/integrations/slack)** — get notified when a monitored state gets a new or changed lab.
- **[Google Drive / Sheets](https://docs.apify.com/platform/integrations/drive)** — auto-export every run to a spreadsheet.
- **[Airbyte](https://docs.apify.com/platform/integrations/airbyte)** — pipe results into your data warehouse.
- **[GitHub](https://docs.apify.com/platform/integrations/github)** — trigger runs from commits or releases.

### Use with AI assistants (MCP)

The output is clean, LLM-ready JSON. Call this actor from Claude, ChatGPT, or any agent framework through the **[Apify MCP server](https://docs.apify.com/platform/integrations/mcp)** — ask your assistant to "find every independent laboratory in California doing over 50,000 tests a year, accredited by CAP, with a phone number and a lead score" and let it run the scraper for you.

### More scrapers from scrapesage

Build a complete **healthcare, government-data & B2B lead-gen stack**:

- **[NPI / NPPES Scraper](https://apify.com/scrapesage/npi-nppes-scraper)** — every US healthcare provider and organization with NPI, taxonomy and address.
- **[FDA Scraper (openFDA)](https://apify.com/scrapesage/fda-scraper)** — drug, device & food recalls, adverse events and manufacturer leads.
- **[Clinical Trials Scraper](https://apify.com/scrapesage/clinical-trials-scraper)** — trials, sponsors, sites and investigators from ClinicalTrials.gov.
- **[SAMHSA Treatment Facility Scraper](https://apify.com/scrapesage/samhsa-treatment-facility-scraper)** — addiction & mental-health treatment centers with phone and website.
- **[Healthgrades Scraper](https://apify.com/scrapesage/healthgrades-scraper)** — physician profiles, specialties and ratings.
- **[EPA ECHO Scraper](https://apify.com/scrapesage/epa-echo-scraper)** — regulated facilities, environmental compliance, violations & penalties.
- **[FSIS Establishment Scraper](https://apify.com/scrapesage/fsis-establishment-scraper)** — USDA meat, poultry & egg plants with contacts.
- **[HUD Multifamily Scraper](https://apify.com/scrapesage/hud-multifamily-scraper)** — affordable-housing properties, management contacts & loans.
- **[Form 5500 ERISA Scraper](https://apify.com/scrapesage/form-5500-erisa-scraper)** — retirement & benefit-plan leads from DOL filings.
- **[US Business Formation Scraper](https://apify.com/scrapesage/us-business-formation-scraper)** — newly-registered companies as fresh leads.

### Tips

- **Start with a state + facility type** (e.g. `CA` + `independentLab`) for a fast, focused list, then layer on size or accreditation filters.
- **Highest-value labs**: set `minTestVolume` (or `labSizeTiers: ["large","veryLarge"]`) and sort by `testVolumeHigh` — big labs are the biggest buyers of analyzers, reagents and software.
- **New-lab intent**: set `newLabWithinDays: 365` to find labs certified in the last year — they need equipment, a LIS, supplies and a billing partner.
- **Renewal timing**: set `certificateExpiringWithinDays: 120` to reach labs ahead of their CLIA renewal.
- **Compliance services**: set `notInComplianceOnly: true` to find labs that need corrective-action, consulting or accreditation help.
- **Recurring monitoring**: combine [Schedules](https://docs.apify.com/platform/schedules) with `monitorMode` to capture only labs added or changed since the last run — perfect for catching every new lab each quarter.

### FAQ

**Where does the data come from?** From the U.S. **CMS Provider of Services File — Clinical Laboratories (CLIA)**, the official federal registry of every laboratory certified under the Clinical Laboratory Improvement Amendments, published on [data.cms.gov](https://data.cms.gov).

**Does it need an API key or login?** No. The CMS data API is queried directly — no key, no login, no browser.

**How fresh is it?** CMS refreshes the CLIA Provider of Services file **quarterly**, and this actor always resolves the newest available quarter automatically. Run on a [Schedule](https://docs.apify.com/platform/schedules) with monitoring mode to capture newly-certified labs as they post.

**Does it include emails?** No — the CLIA registry is a regulatory file that carries **phone and fax** (near-100% phone coverage) but not email. We never fabricate contact data; everything in the record is straight from CMS.

**What's the "estimated annual test volume"?** CMS records each lab's reported annual test volume (accreditation, compliance, survey, waived or PPM). We surface the best available figure and a size tier (`micro` → `veryLarge`) so you can target labs by scale.

**Can I export to Google Sheets, CSV, or Excel?** Yes — one click in the dataset view, or automatically on every run via the [Google Drive integration](https://docs.apify.com/platform/integrations/drive).

**A field is empty — why?** A lab only carries data for the programs it participates in (e.g. no accreditation body if it holds a Certificate of Waiver). Blank means CMS has no value, never that scraping failed.

**Is scraping this data legal?** This actor collects publicly available U.S. government data. You're responsible for using it in compliance with applicable laws and CMS's terms.

### Need help?

Open an issue on the actor's **Issues** tab, or visit the [Apify help center](https://help.apify.com/). Feature requests are welcome — this actor is actively maintained.

# Actor input Schema

## `states` (type: `array`):

Two-letter state codes to scrape (e.g. \["CA","TX"]). Leave empty to scrape all 50 states + DC. Territories also supported: PR, GU, VI, AS, MP.

## `facilityTypes` (type: `array`):

Keep only labs of these facility types. Allowed values: independentLab, hospital, physicianOffice, skilledNursing, communityClinic, ruralHealthClinic, fqhc, dialysis, bloodBank, ambulatorySurgery, homeHealth, hospice, assistedLiving, pharmacy, publicHealth, school, prison, mobileLab, ancillaryTestSite, comprehensiveRehab, hmo, insurance, industrial, intermediateCare, otherPractitioner, ambulance, healthFair, tissueBank, other. Leave empty for all.

## `certificateTypes` (type: `array`):

Keep only labs with these CLIA certificate types. Allowed values: compliance, accreditation, ppm (provider-performed microscopy), waiver, registration. Leave empty for all.

## `ownershipTypes` (type: `array`):

Keep only labs with these ownership types. Allowed values: proprietary, private, nonprofit, government. Leave empty for all.

## `accreditedBy` (type: `array`):

Keep only labs accredited by any of these bodies. Allowed values: cap (College of American Pathologists), cola, jointCommission, a2la, aabb, aoa, ashi. Leave empty for all.

## `cities` (type: `array`):

Keep only labs in these cities (case-insensitive, exact match on the lab's city). Optional.

## `counties` (type: `array`):

Keep only labs in these counties (case-insensitive, matches the resolved county name, e.g. "Los Angeles"). Optional.

## `zipCodes` (type: `array`):

Keep only labs whose ZIP starts with any of these values (full ZIP or prefix, e.g. "900" or "90210"). Optional.

## `nameQuery` (type: `string`):

Keep only labs whose name contains this text (case-insensitive). Optional.

## `cliaNumbers` (type: `array`):

Look up specific labs by CLIA number (CMS Certification Number, e.g. "05D0642245"). When set, the state filter is ignored and only these labs are returned.

## `activeOnly` (type: `boolean`):

Keep only labs with an active (non-terminated) CLIA certificate.

## `withPhoneOnly` (type: `boolean`):

Keep only labs that have a phone number.

## `minTestVolume` (type: `integer`):

Keep only labs whose estimated annual test volume is at least this value (a proxy for lab size). Leave empty for no minimum.

## `labSizeTiers` (type: `array`):

Keep only labs in these size tiers. Allowed values: micro, small, medium, large, veryLarge. Leave empty for all.

## `newLabWithinDays` (type: `integer`):

Keep only labs first certified (original participation / certificate effective date) within the last N days — brand-new labs that need equipment, software and supplies. Leave empty to disable.

## `ownershipChangedWithinDays` (type: `integer`):

Keep only labs whose most recent change of ownership was within the last N days — an M\&A / new-decision-maker signal. Leave empty to disable.

## `certificateExpiringWithinDays` (type: `integer`):

Keep only labs whose CLIA certificate expires within the next N days — a renewal-timing / re-engagement signal. Leave empty to disable.

## `notInComplianceOnly` (type: `boolean`):

Keep only labs flagged as not in compliance at their last certification survey — buyers of compliance, consulting and corrective-action services.

## `multiSiteOnly` (type: `boolean`):

Keep only labs operating under a multi-site CLIA certificate (chains / health systems).

## `minLeadScore` (type: `integer`):

Keep only labs with a lead score at or above this value (0-100).

## `sortBy` (type: `string`):

Order of the output.

## `maxResults` (type: `integer`):

Maximum number of lab records to return across all states.

## `maxResultsPerState` (type: `integer`):

Optional cap on the number of labs returned from each state (useful for balanced multi-state pulls). Leave empty for no per-state cap.

## `deduplicateResults` (type: `boolean`):

Drop duplicate labs that share the same CLIA number.

## `includeRawFields` (type: `boolean`):

Attach the raw CMS POS source row (all 100+ original columns) under sourceFields on each record.

## `monitorMode` (type: `boolean`):

Only return labs that are new or whose certificate, status or ownership changed since the last run with the same monitor key. Ideal on a Schedule to capture newly-certified labs each quarter.

## `monitorKey` (type: `string`):

Namespace for monitoring mode so independent monitors don't collide. Use a distinct key per saved configuration.

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

Optional. The CMS data API needs no proxy, so leave this off for the fastest queries.

## Actor input object example

```json
{
  "states": [
    "WY"
  ],
  "activeOnly": true,
  "withPhoneOnly": false,
  "notInComplianceOnly": false,
  "multiSiteOnly": false,
  "sortBy": "leadScore",
  "maxResults": 1000,
  "deduplicateResults": true,
  "includeRawFields": true,
  "monitorMode": false,
  "monitorKey": "default",
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `results` (type: `string`):

All scraped clinical-laboratory records in the default dataset, each with firmographics, certificate & facility type, accreditation, test volume, lifecycle signals and a lead score.

# 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 = {
    "states": [
        "WY"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapesage/clinical-lab-leads-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 = { "states": ["WY"] }

# Run the Actor and wait for it to finish
run = client.actor("scrapesage/clinical-lab-leads-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 '{
  "states": [
    "WY"
  ]
}' |
apify call scrapesage/clinical-lab-leads-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "US Clinical Lab Leads Scraper (CLIA Registry)",
        "description": "Scrape every US clinical lab from the official CMS CLIA registry: name, phone, fax, address, certificate & facility type, accreditation, annual test volume, new-lab & ownership signals + lead score. Filter by state, lab type & size. B2B lab leads + monitoring.",
        "version": "0.1",
        "x-build-id": "csPw5Uo35Ybbtm0yh"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapesage~clinical-lab-leads-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapesage-clinical-lab-leads-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/scrapesage~clinical-lab-leads-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scrapesage-clinical-lab-leads-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/scrapesage~clinical-lab-leads-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scrapesage-clinical-lab-leads-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": {
                    "states": {
                        "title": "States",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Two-letter state codes to scrape (e.g. [\"CA\",\"TX\"]). Leave empty to scrape all 50 states + DC. Territories also supported: PR, GU, VI, AS, MP.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "facilityTypes": {
                        "title": "Facility types",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Keep only labs of these facility types. Allowed values: independentLab, hospital, physicianOffice, skilledNursing, communityClinic, ruralHealthClinic, fqhc, dialysis, bloodBank, ambulatorySurgery, homeHealth, hospice, assistedLiving, pharmacy, publicHealth, school, prison, mobileLab, ancillaryTestSite, comprehensiveRehab, hmo, insurance, industrial, intermediateCare, otherPractitioner, ambulance, healthFair, tissueBank, other. Leave empty for all.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "certificateTypes": {
                        "title": "Certificate types",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Keep only labs with these CLIA certificate types. Allowed values: compliance, accreditation, ppm (provider-performed microscopy), waiver, registration. Leave empty for all.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "ownershipTypes": {
                        "title": "Ownership types",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Keep only labs with these ownership types. Allowed values: proprietary, private, nonprofit, government. Leave empty for all.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "accreditedBy": {
                        "title": "Accredited by",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Keep only labs accredited by any of these bodies. Allowed values: cap (College of American Pathologists), cola, jointCommission, a2la, aabb, aoa, ashi. Leave empty for all.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "cities": {
                        "title": "Cities",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Keep only labs in these cities (case-insensitive, exact match on the lab's city). Optional.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "counties": {
                        "title": "Counties",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Keep only labs in these counties (case-insensitive, matches the resolved county name, e.g. \"Los Angeles\"). Optional.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "zipCodes": {
                        "title": "ZIP codes",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Keep only labs whose ZIP starts with any of these values (full ZIP or prefix, e.g. \"900\" or \"90210\"). Optional.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "nameQuery": {
                        "title": "Lab name contains",
                        "type": "string",
                        "description": "Keep only labs whose name contains this text (case-insensitive). Optional."
                    },
                    "cliaNumbers": {
                        "title": "CLIA numbers (lookup)",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Look up specific labs by CLIA number (CMS Certification Number, e.g. \"05D0642245\"). When set, the state filter is ignored and only these labs are returned.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "activeOnly": {
                        "title": "Active labs only",
                        "type": "boolean",
                        "description": "Keep only labs with an active (non-terminated) CLIA certificate.",
                        "default": true
                    },
                    "withPhoneOnly": {
                        "title": "With phone only",
                        "type": "boolean",
                        "description": "Keep only labs that have a phone number.",
                        "default": false
                    },
                    "minTestVolume": {
                        "title": "Minimum annual test volume",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Keep only labs whose estimated annual test volume is at least this value (a proxy for lab size). Leave empty for no minimum."
                    },
                    "labSizeTiers": {
                        "title": "Lab size tiers",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Keep only labs in these size tiers. Allowed values: micro, small, medium, large, veryLarge. Leave empty for all.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "newLabWithinDays": {
                        "title": "New labs within N days",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Keep only labs first certified (original participation / certificate effective date) within the last N days — brand-new labs that need equipment, software and supplies. Leave empty to disable."
                    },
                    "ownershipChangedWithinDays": {
                        "title": "Ownership changed within N days",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Keep only labs whose most recent change of ownership was within the last N days — an M&A / new-decision-maker signal. Leave empty to disable."
                    },
                    "certificateExpiringWithinDays": {
                        "title": "Certificate expiring within N days",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Keep only labs whose CLIA certificate expires within the next N days — a renewal-timing / re-engagement signal. Leave empty to disable."
                    },
                    "notInComplianceOnly": {
                        "title": "Not-in-compliance only",
                        "type": "boolean",
                        "description": "Keep only labs flagged as not in compliance at their last certification survey — buyers of compliance, consulting and corrective-action services.",
                        "default": false
                    },
                    "multiSiteOnly": {
                        "title": "Multi-site labs only",
                        "type": "boolean",
                        "description": "Keep only labs operating under a multi-site CLIA certificate (chains / health systems).",
                        "default": false
                    },
                    "minLeadScore": {
                        "title": "Minimum lead score",
                        "minimum": 0,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Keep only labs with a lead score at or above this value (0-100)."
                    },
                    "sortBy": {
                        "title": "Sort by",
                        "enum": [
                            "leadScore",
                            "testVolumeHigh",
                            "newest",
                            "expiringSoon",
                            "name",
                            "source"
                        ],
                        "type": "string",
                        "description": "Order of the output.",
                        "default": "leadScore"
                    },
                    "maxResults": {
                        "title": "Max results",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Maximum number of lab records to return across all states.",
                        "default": 1000
                    },
                    "maxResultsPerState": {
                        "title": "Max results per state",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Optional cap on the number of labs returned from each state (useful for balanced multi-state pulls). Leave empty for no per-state cap."
                    },
                    "deduplicateResults": {
                        "title": "Deduplicate by CLIA number",
                        "type": "boolean",
                        "description": "Drop duplicate labs that share the same CLIA number.",
                        "default": true
                    },
                    "includeRawFields": {
                        "title": "Include raw source fields",
                        "type": "boolean",
                        "description": "Attach the raw CMS POS source row (all 100+ original columns) under sourceFields on each record.",
                        "default": true
                    },
                    "monitorMode": {
                        "title": "Monitoring mode (only new / changed)",
                        "type": "boolean",
                        "description": "Only return labs that are new or whose certificate, status or ownership changed since the last run with the same monitor key. Ideal on a Schedule to capture newly-certified labs each quarter.",
                        "default": false
                    },
                    "monitorKey": {
                        "title": "Monitor key",
                        "type": "string",
                        "description": "Namespace for monitoring mode so independent monitors don't collide. Use a distinct key per saved configuration.",
                        "default": "default"
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Optional. The CMS data API needs no proxy, so leave this off for the fastest queries.",
                        "default": {
                            "useApifyProxy": 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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
