# New Pending Medicare Behavioral Health Applicants (`actablesite/pending-medicare-behavioral-health-actor`) Actor

Twice-weekly CMS signal of behavioral-health NPIs newly added to pending first-time Medicare enrollment files, enriched from NPPES for credentialing, billing, EHR, and provider-network research. Pending does not mean approved. Free 10-row preview; $12 current edition.

- **URL**: https://apify.com/actablesite/pending-medicare-behavioral-health-actor.md
- **Developed by:** [Shane Cheek](https://apify.com/actablesite) (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

from $12.00 / current complete edition

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## New Pending Medicare Behavioral Health Applicants

Find behavioral-health clinicians newly added to CMS's **pending first-time Medicare enrollment** files since the prior publication. Built for credentialing, medical-billing, EHR, provider-network, and healthcare research teams.

> **Pending is not approved.** A row means a first-time Medicare enrollment application appeared in CMS's pending file. It does not prove enrollment, credentialing, licensure, a new practice, service availability, interest, or buying intent.

[Run the free 10-row preview on Apify](https://apify.com/actablesite/pending-medicare-behavioral-health-actor) with the default input. The same hosted Actor delivers the complete current edition after an intentional `$12` event authorization.

### Choose access intentionally

- **Free preview — no edition charge.** Get 10 current rows selected deterministically across states.
- **Full current edition — $12 once per run, plus buyer-paid Apify usage.** Get every validated behavioral-health row added since the prior CMS publication.

The Actor never turns a preview into a paid run. Set `preview` to `false` only when you intend to authorize the full-edition event.

### What the edition answers

- Which NPIs appeared in the newest CMS pending file but not the immediately prior file?
- Which of those NPIs have a disclosed behavioral-health taxonomy in the official NPPES Registry?
- What public name, credential, taxonomy, practice location, and telephone fields does NPPES currently report?
- Which CMS snapshots, URLs, row counts, and hashes produced the edition?

Use the queue for credentialing research, Medicare-enrollment operations, billing territory analysis, EHR market research, or provider-network research. Verify each record before any operational or contact decision.

### Output

Each dataset row includes:

- NPI, name, credential, and enumeration type;
- matched behavioral-health focus, taxonomy code, and taxonomy description;
- public NPPES practice address and telephone;
- NPI enumeration and last-update dates;
- physician or non-physician pending-file origin;
- current and prior snapshot dates;
- direct CMS source URL and NPPES Registry URL;
- the pending-status definition and material limitations.

The `OUTPUT` key-value-store record is the fulfillment receipt. It records source hashes and row counts, new-NPI counts by file, NPPES lookup success, selected counts, filters, state and specialty distributions, and delivered access level.

### How it works

1. Resolve the two newest CSV snapshots for both official CMS pending datasets.
2. Reject unexpected domains, paths, filenames, schemas, or source counts.
3. Diff each newest snapshot against its predecessor by NPI.
4. Look up each added NPI in the official NPPES Registry.
5. Keep only the disclosed behavioral-health taxonomy set and normalize location fields.
6. Reject implausible deltas, excessive lookup failures, or implausible selected counts.
7. For a full run, request one `current-edition` charge only after validation.
8. Write the dataset and source-linked fulfillment receipt automatically.

### Input

```json
{
  "preview": true,
  "states": ["CA", "TX"]
}
````

- `preview` defaults to `true`.
- `states` is optional. Use two-letter state or territory codes. Leave it empty for national results.
- A state filter can legitimately return zero rows; the receipt still reports the validated national count and exact filter.

### Behavioral-health taxonomy boundary

The initial conservative set includes mental-health counselor, professional counselor, behavior analyst, marriage and family therapist, psychologist, mental-health clinic, adult mental-health clinic, and community/behavioral-health codes. The exact codes are returned in every receipt.

This narrow set favors an explainable signal over broad claims. It does not include every specialty that could participate in behavioral health.

### Source and limitations

- [CMS Fee-for-Service Public Provider Enrollment methodology](https://data.cms.gov/resources/fee-for-service-public-provider-enrollment-methodology)
- [CMS public data catalog](https://data.cms.gov/data.json)
- [NPPES NPI Registry](https://npiregistry.cms.hhs.gov/)

The CMS pending files contain NPI and applicant name only. Enrichment comes from the separately published NPPES Registry. Public address and telephone fields may be old, shared, or operational. Names may change between the pending snapshot and the current NPPES record. No outreach is performed by this Actor.

### Failure contract

The run fails without charging the edition event when a source is missing or untrusted, its schema changes, row or delta counts are implausible, more than 5% of NPPES lookups fail, or the national behavioral-health result falls outside the safety range. A full edition is not delivered when the run's maximum charge cannot authorize the event.

# Actor input Schema

## `preview` (type: `boolean`):

Keep enabled for a deterministic 10-row preview. Disable only when you intend to authorize the $12 full-edition event.

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

Optional two-letter state or territory codes. Leave empty for national results.

## Actor input object example

```json
{
  "preview": true,
  "states": []
}
```

# Actor output Schema

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

No description

## `output` (type: `string`):

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

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

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {};

// Run the Actor and wait for it to finish
const run = await client.actor("actablesite/pending-medicare-behavioral-health-actor").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {}

# Run the Actor and wait for it to finish
run = client.actor("actablesite/pending-medicare-behavioral-health-actor").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{}' |
apify call actablesite/pending-medicare-behavioral-health-actor --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=actablesite/pending-medicare-behavioral-health-actor",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "New Pending Medicare Behavioral Health Applicants",
        "description": "Twice-weekly CMS signal of behavioral-health NPIs newly added to pending first-time Medicare enrollment files, enriched from NPPES for credentialing, billing, EHR, and provider-network research. Pending does not mean approved. Free 10-row preview; $12 current edition.",
        "version": "0.0",
        "x-build-id": "hSgWjodrfnawA5Fs4"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/actablesite~pending-medicare-behavioral-health-actor/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-actablesite-pending-medicare-behavioral-health-actor",
                "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/actablesite~pending-medicare-behavioral-health-actor/runs": {
            "post": {
                "operationId": "runs-sync-actablesite-pending-medicare-behavioral-health-actor",
                "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/actablesite~pending-medicare-behavioral-health-actor/run-sync": {
            "post": {
                "operationId": "run-sync-actablesite-pending-medicare-behavioral-health-actor",
                "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": {
                    "preview": {
                        "title": "Free preview",
                        "type": "boolean",
                        "description": "Keep enabled for a deterministic 10-row preview. Disable only when you intend to authorize the $12 full-edition event.",
                        "default": true
                    },
                    "states": {
                        "title": "States",
                        "type": "array",
                        "description": "Optional two-letter state or territory codes. Leave empty for national results.",
                        "items": {
                            "type": "string",
                            "pattern": "^[A-Za-z]{2}$"
                        },
                        "default": []
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
