# Medicare Cost Report Data — Hospital, SNF & Home Health (HCRIS) (`nexgensignal/us-medicare-cost-report-records`) Actor

CMS Medicare cost reports for hospitals, skilled nursing facilities and home health agencies: beds, days, discharges, costs, revenue, balance sheet and net income per facility per year. Part of NexGen Signal — official-source data products

- **URL**: https://apify.com/nexgensignal/us-medicare-cost-report-records.md
- **Developed by:** [NexGen Signal](https://apify.com/nexgensignal) (community)
- **Categories:** Lead generation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $33.50 / 1,000 medicare cost report records

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## How to integrate an Actor?

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

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Medicare Cost Report Data — Hospital, SNF & Home Health (HCRIS)

**Official source. No API key. Pay per record.**

This actor gives you the Centers for Medicare & Medicaid Services (CMS) **Medicare cost reports** as structured records — the annual financial and operating reports that every Medicare-certified hospital, skilled nursing facility (SNF) and home health agency (HHA) must file. Each record is one facility's cost report for one reporting period, with every column CMS publishes: beds, patient days and discharges by payer, staffing, costs and charges, charity care and bad debt, the full balance sheet, revenue and net income.

It reads CMS's own data API on data.cms.gov and resolves the yearly files from the CMS data catalogue on every run, so new years appear as soon as CMS publishes them. On 27 September 2026 CMS had published:

| Facility type | CMS file years | Reports in the latest year | Columns |
|---|---|---|---|
| Hospitals | 2011–2023 | 6,103 (2023) | 117 |
| Skilled nursing facilities | 2011–2023 | 14,933 (2023) | 122 |
| Home health agencies | 2020–2023 | 10,715 (2023) | 201 |

### Who buys this and for what job

- **Healthcare investors, lenders and M\&A teams** screening hospitals, nursing homes and home health agencies on size, margins, payer mix and balance-sheet strength.
- **Healthcare consultants and revenue-cycle firms** benchmarking a client against peers by state, bed size or type of control.
- **Medtech, pharma and healthcare-services sales teams** sizing and prioritising accounts (beds, discharges, costs).
- **Policy researchers and journalists** studying charity care, uncompensated care, Medicare dependence and facility finances.
- **Data teams** who want HCRIS-derived figures without parsing CMS's raw cost report files.

### Sample output

![Sample output — Medicare Cost Reports](https://api.apify.com/v2/key-value-stores/IXCaMKjxSmUTLHhmq/records/us-medicare-cost-report-records.png)

An abridged hospital record (the real record carries all 117 CMS columns):

```json
{
  "record_id": "CMS-CR:hospital:2023:804917",
  "facility_type": "Hospital",
  "cms_file_year": 2023,
  "provider_ccn": "050454",
  "provider_name": "UCSF MEDICAL CENTER",
  "state_code": "CA",
  "fiscal_year_begin_date": "2023-07-01",
  "fiscal_year_end_date": "2024-06-30",
  "rpt_rec_num": "804917",
  "Provider CCN": "050454",
  "Hospital Name": "UCSF MEDICAL CENTER",
  "Street Address": "505 PARNASSUS",
  "City": "SAN FRANCISCO",
  "State Code": "CA",
  "CCN Facility Type": "STH",
  "Type of Control": "10",
  "FTE - Employees on Payroll": "13208",
  "Number of Beds": "887",
  "Cost of Charity Care": "78449295",
  "Total Costs": "4252897828",
  "Total Assets": "8159586236",
  "Net Patient Revenue": "6146359372",
  "Net Income": "414296965",
  "cms_dataset": "Hospital Provider Cost Report",
  "cms_file_version": "Hospital Provider Cost Report : 2023-12-04",
  "api_url": "https://data.cms.gov/data-api/v1/dataset/cb8d0018-1bbe-4559-91bf-9429ac344b48/data",
  "source": "Centers for Medicare & Medicaid Services — Hospital Provider Cost Report (https://data.cms.gov/provider-compliance/cost-reports/hospital-provider-cost-report)",
  "licence": "US Government work (Centers for Medicare & Medicaid Services) — not subject to copyright in the US (17 U.S.C. § 105; https://www.usa.gov/government-works). The CMS data catalogue carried that licence link until its September 2026 restructure; its entries now carry no licence field.",
  "attribution": "Source: Centers for Medicare & Medicaid Services (CMS), data.cms.gov; reformatted by NexGen Signal.",
  "observed_at": "2026-09-27T16:56:34Z"
}
```

### Pricing

| Apify plan | Price per record |
|---|---|
| Free | $0.05 |
| Bronze | $0.045 |
| Silver | $0.04 |
| Gold and above | $0.0335 |

You pay only for records delivered to your dataset — one record per cost report, whatever the number of columns. `maxRecords` caps what a run can cost: 500 records cost $25 on the Free plan. Filtering is free.

### Input

| Field | What it does | Default |
|---|---|---|
| `facilityType` | `hospital`, `snf` (skilled nursing facilities) or `hha` (home health agencies) | hospital |
| `years` | CMS file years to read, e.g. `[2023, 2022]` | the latest year CMS has published |
| `states` | Only facilities in these states, e.g. `CA`, `TX` | all |
| `ccns` | Only these CMS Certification Numbers (up to 20,000) | all |
| `nameContains` | Only facility names containing this text, e.g. `MEMORIAL` | none |
| `maxRecords` | Maximum records delivered and billed | 10 |

**Default changed on 30 Sep 2026:** if you leave `maxRecords` out, a run now returns up to **10** records (it was 500). Set `maxRecords` yourself to get more — the maximum is unchanged.

Example — every Texas nursing facility in the latest year:

```json
{"facilityType": "snf", "states": ["TX"], "maxRecords": 5000}
```

Example — two hospitals over two years:

```json
{"facilityType": "hospital", "years": [2023, 2022], "ccns": ["110130", "050454"]}
```

(That returned four reports on 27 September 2026. A CCN with no report in the years read is listed in the run receipt.)

### Output

| Field | Meaning |
|---|---|
| `record_id` | `CMS-CR:<type>:<CMS file year>:<rpt_rec_num>` — unique per cost report |
| `facility_type`, `cms_file_year` | Hospital, Skilled nursing facility or Home health agency; the CMS annual file |
| `provider_ccn`, `provider_name`, `state_code` | Copies of CMS's CCN, name and state columns, under one name for all three types |
| `fiscal_year_begin_date`, `fiscal_year_end_date` | Copies of the reporting period columns |
| *every CMS column* | Under its CMS name (`Total Costs`, `Net Income`, `Number of Beds`, …) with its value exactly as CMS publishes it |
| `cms_dataset`, `cms_file_version`, `api_url` | Which CMS file the record came from |
| `source`, `licence`, `attribution`, `observed_at` | Provenance on every record |

CMS publishes every value as text (for example `"4252897828"`), and blank cells as empty text; the actor keeps them that way rather than guessing types. Codes such as `Type of Control` and `CCN Facility Type` are CMS's; CMS's data dictionary explains them (linked in the run receipt).

### Cost guidance

A state's hospitals for one year are typically tens to a few hundred records. The whole country's hospitals for one year are about 6,100 records ($204 on Gold); nursing facilities about 15,000 ($500); home health agencies about 10,700 ($359). A watch-list of CCNs costs only the reports found. Filter by state or CCN first, then widen.

### Tips

- **Start narrow:** a state or a CCN list first, then widen to the country once you know which columns you need.
- **Trends:** pass several years (`[2023, 2022, 2021]`) with a CCN list to follow the same facilities over time; `provider_ccn` and `fiscal_year_end_date` line the periods up.
- **Numbers as text:** convert the columns you use to numbers in your own tool; blank means CMS published no value.
- **Codes:** `Type of Control` and similar codes are explained in CMS's data dictionary, linked from each dataset page.

### How a run works

The actor reads data.cms.gov's robots.txt and honours its **Crawl-delay of 10 seconds** between requests. It reads the CMS data catalogue, finds the yearly API file for the chosen facility type (since September 2026 CMS lists one dataset per year, grouped under a named dataset series; the actor finds them by that series, not by display title, and still understands the older single-dataset layout), asks CMS how many rows that file holds, and reads it 5,000 rows at a time, filtering as it goes. Each year is checked against CMS's own row count, with one re-read if anything is missing; in testing every full read matched (for example 14,933 of 14,933 nursing-facility reports for 2023, 6,103 of 6,103 hospital reports). Records are pushed to your dataset first and charged only after they are delivered; if you set a maximum charge, the run stops cleanly when it is reached. Test runs that read a full year took 24–65 seconds. If you ask for a year CMS has not published, the run says so and charges nothing. If data.cms.gov cannot be reached after several retries, the run ends with a clear message and nothing is charged.

### Honest limitations

- **CMS's selected measures, not the full cost report.** These files carry the measures CMS chose to publish (117–201 columns). Worksheet-level detail from the raw HCRIS files is not included.
- **Annual files lag.** The latest CMS file year on 27 September 2026 was 2023. CMS also re-issues past years' files (the hospital files for 2011–2022 were re-published in November 2025), so figures for a past year can change.
- **File year is CMS's grouping.** A report's actual period is in its fiscal year begin and end dates; some periods are short (Irwin County Hospital's report in the 2023 file covers two months, 1 December 2022 to 31 January 2023).
- **Several reports per facility per year are possible** (changes of ownership, short periods). Use `rpt_rec_num` to tell them apart.
- **As filed.** Cost reports are self-reported by providers; CMS publishes them as reported, and some values are blank or implausible.
- **Facilities only.** The files describe facilities; they contain no patient data.

### Licence and attribution

These files are a US Government work (Centers for Medicare & Medicaid Services), not subject to copyright in the US (17 U.S.C. § 105; **https://www.usa.gov/government-works**). The CMS data catalogue carried that licence link until its September 2026 restructure; its entries now carry no licence field. Every record carries the credit *Source: Centers for Medicare & Medicaid Services (CMS), data.cms.gov; reformatted by NexGen Signal.* This actor is not affiliated with or endorsed by CMS.

### Differentiation

malekh/hcris-hospital-cost-report looks up hospital cost and charge figures, and general CMS actors such as parseforge/cms-medicare-scraper expose data.cms.gov datasets generically. This actor is built for the three cost report datasets: it resolves every published year from the CMS catalogue, keeps every CMS column under its CMS name, covers hospitals, nursing facilities and home health agencies in one input, supports CCN watch-lists across years, and checks every full read against CMS's own row count.

### The NexGen Signal family

Part of NexGen Signal — official-source data products, no API keys, pay per record. Related actors:

- [US Hospital Ownership Records — CMS Owner Organizations](https://apify.com/nexgensignal/us-hospital-ownership-records)
- [Medicare Reimbursement by HCPCS & Locality — CMS](https://apify.com/nexgensignal/cms-procedure-reimbursement-records)
- [CMS Part D Drug Spending — by Drug & Maker](https://apify.com/nexgensignal/cms-part-d-drug-spending-records)
- [US IRS Exempt Organization Master File (EO BMF)](https://apify.com/nexgensignal/us-exempt-organization-master-records)
- [FDA Device Clearance Records — 510(k) via openFDA](https://apify.com/nexgensignal/fda-device-clearance-records)

# Actor input Schema

## `facilityType` (type: `string`):

Which CMS cost report to read.

## `years` (type: `array`):

CMS annual files to read, e.g. \[2023, 2022]. Leave empty for the latest year CMS has published.

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

Only facilities in these states, e.g. CA, TX.

## `ccns` (type: `array`):

Only these providers, e.g. 050454. CCNs with no report in the years read are listed in the run receipt.

## `nameContains` (type: `string`):

Only facilities whose name contains this text (not case-sensitive), e.g. MEMORIAL.

## `maxRecords` (type: `integer`):

Maximum records delivered and billed in this run. One record = one cost report. A hospital year is about 6,100 reports; a nursing-facility year about 15,000.

## Actor input object example

```json
{
  "facilityType": "hospital",
  "years": [
    2023
  ],
  "states": [],
  "ccns": [],
  "maxRecords": 10
}
```

# Actor output Schema

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

The delivered records.

# 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 = {
    "facilityType": "hospital",
    "years": [
        2023
    ],
    "maxRecords": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("nexgensignal/us-medicare-cost-report-records").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 = {
    "facilityType": "hospital",
    "years": [2023],
    "maxRecords": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("nexgensignal/us-medicare-cost-report-records").call(run_input=run_input)

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

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

```

## CLI example

```bash
echo '{
  "facilityType": "hospital",
  "years": [
    2023
  ],
  "maxRecords": 10
}' |
apify call nexgensignal/us-medicare-cost-report-records --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,nexgensignal/us-medicare-cost-report-records"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/zjuRnUn9hce7g2gou/builds/kJnxUPB1l4mhAnSds/openapi.json