# Medicare Revalidation Due Date Lookup (`actablesite/medicare-revalidation-lookup-actor`) Actor

Check up to 100 NPIs against the current public CMS Medicare Revalidation List. Returns established due dates, TBD, or not listed, with enrollment details and source revision. Does not show live PECOS case status.

- **URL**: https://apify.com/actablesite/medicare-revalidation-lookup-actor.md
- **Developed by:** [Shane Cheek](https://apify.com/actablesite) (community)
- **Categories:** Automation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $10.00 / 1,000 npi revalidation results

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

## Medicare Revalidation Due Date Lookup

Check **1 to 100 NPIs** against the current public CMS Medicare Revalidation List. Get one source-dated result per NPI: established due date, **TBD**, or not present on the current public list.

### What you get

Each dataset row includes:

- NPI and current public-list status
- earliest established due date, when present
- every matching Medicare enrollment ID
- provider or organization name, state, enrollment type, and specialty
- revalidation due date and adjusted due date
- lookup timestamp and CMS source-file revision

Results export as JSON, CSV, Excel, XML, or RSS.

### Ready-to-run examples

- [Credentialing roster check](https://apify.com/actablesite/medicare-revalidation-lookup-actor/examples/medicare-revalidation-roster-check-for-credentialing) — check a provider roster before credentialing follow-up.
- [Medical billing revalidation dates](https://apify.com/actablesite/medicare-revalidation-lookup-actor/examples/medicare-revalidation-dates-for-medical-billing) — export public due dates and TBD records for billing operations.

Each example opens with the NPI field and result table already configured. Apify duplicates the task into the user's own account, so the user's runs and datasets remain private.

### Compare a roster with the previous run

Turn on **Compare with the previous run** when you expect to check the same roster again.

- The first fully funded run creates a baseline for that exact NPI list.
- Each later fully funded run labels every row as unchanged, newly listed, no longer listed, due-date changed, status changed, or enrollment changed.
- The baseline is stored under the Apify user who ran the Actor and is not placed in the public dataset or logs.
- A partial run never replaces the prior full baseline.
- Save the input as an Apify task and schedule it to run again for unattended comparison and run history.

Comparison uses only the public CMS Medicare Revalidation List. It does not monitor PECOS submissions or contractor case status, and it does not send a separate email. Each scheduled run keeps the same per-result price.

### Price and run limit

- **$0.01 per returned NPI result**
- up to **100 unique NPIs per run**
- Apify's small synthetic start event may also apply
- platform usage is paid by the Actor user, not hidden inside the result price
- invalid NPI check digits are rejected before any paid result is created

The run's maximum-charge setting is respected. If it cannot cover the whole roster, the Actor returns only the funded portion and marks the run partial.

### Example input

```json
{
  "npis": [
    "1003002296",
    "1508860420"
  ]
}
````

### Status meanings

| Status | Meaning |
|---|---|
| `date_established` | At least one matching enrollment has a public due or adjusted-due date. |
| `tbd` | CMS lists the enrollment but has not established a public due date. |
| `not_on_current_public_list` | The valid NPI has no matching enrollment in the current public revalidation file. |

### Important limits

This Actor reads the public CMS Medicare Revalidation List. It **does not show live PECOS submission status**, Medicare Administrative Contractor case status, receipt, acceptance, completion, approval, enrollment, or billing privileges.

A public due date is not proof that revalidation was submitted or completed. A blank date means CMS has not established one in the current public file. Use PECOS and the responsible enrollment contractor for official case status.

### Source and reliability

The Actor queries the official CMS dataset directly, validates the returned schema, records the source CSV SHA-1 and modification time, and fails closed if the source revision changes during a multi-batch roster lookup.

- [Official CMS Medicare Revalidation List](https://data.cms.gov/tools/medicare-revalidation-list)
- [CMS dataset page](https://data.cms.gov/provider-characteristics/medicare-provider-supplier-enrollment/revalidation-due-date-list)

### Need change alerts instead of another point-in-time lookup?

[Medicare Roster Watch](https://actablesite.com/pending-medicare-roster-watch?utm_source=apify\&utm_medium=actor_readme\&utm_campaign=medicare_revalidation_actor) follows public revalidation records and pending-file membership for up to 20 NPIs. It is **$9 USD per month** and sends a dated baseline plus change-only email. It still does not monitor live PECOS or contractor case status.

### For developers

The Actor requires no external API key or customer credential. Source and tests are available in the linked GitHub repository under the MIT license.

# Actor input Schema

## `npis` (type: `array`):

One to 100 unique 10-digit NPIs. Each returned NPI row is one paid result. Example NPIs are included only to demonstrate dated and TBD output.

## `compareWithPrevious` (type: `boolean`):

For a roster you will run again. The first full run creates a baseline scoped to your Apify account and exact NPI list. Later full runs label public due-date, status, and enrollment changes. Each run keeps the same per-result price and still does not show live PECOS status.

## Actor input object example

```json
{
  "npis": [
    "1003002296",
    "1508860420"
  ],
  "compareWithPrevious": false
}
```

# 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/medicare-revalidation-lookup-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/medicare-revalidation-lookup-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/medicare-revalidation-lookup-actor --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Medicare Revalidation Due Date Lookup",
        "description": "Check up to 100 NPIs against the current public CMS Medicare Revalidation List. Returns established due dates, TBD, or not listed, with enrollment details and source revision. Does not show live PECOS case status.",
        "version": "0.0",
        "x-build-id": "ik83cBPouM7ZHNYdD"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/actablesite~medicare-revalidation-lookup-actor/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-actablesite-medicare-revalidation-lookup-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~medicare-revalidation-lookup-actor/runs": {
            "post": {
                "operationId": "runs-sync-actablesite-medicare-revalidation-lookup-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~medicare-revalidation-lookup-actor/run-sync": {
            "post": {
                "operationId": "run-sync-actablesite-medicare-revalidation-lookup-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",
                "required": [
                    "npis"
                ],
                "properties": {
                    "npis": {
                        "title": "NPIs",
                        "minItems": 1,
                        "maxItems": 100,
                        "uniqueItems": true,
                        "type": "array",
                        "description": "One to 100 unique 10-digit NPIs. Each returned NPI row is one paid result. Example NPIs are included only to demonstrate dated and TBD output.",
                        "items": {
                            "type": "string",
                            "pattern": "^\\d{10}$"
                        },
                        "default": [
                            "1003002296",
                            "1508860420"
                        ]
                    },
                    "compareWithPrevious": {
                        "title": "Compare with the previous run",
                        "type": "boolean",
                        "description": "For a roster you will run again. The first full run creates a baseline scoped to your Apify account and exact NPI list. Later full runs label public due-date, status, and enrollment changes. Each run keeps the same per-result price and still does not show live PECOS status.",
                        "default": false
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
