# US Hospital Ownership Records — CMS Owner Edges (`nexgensignal/us-hospital-ownership-records`) Actor

Keyless, pay-per-record CMS hospital ownership edges — one row per organization-to-facility ownership with percentage, role and owner-type flags (PE, REIT, holding). Public-domain; organization owners only, no person data.

- **URL**: https://apify.com/nexgensignal/us-hospital-ownership-records.md
- **Developed by:** [NexGen Signal](https://apify.com/nexgensignal) (community)
- **Categories:** Business, News, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $33.50 / 1,000 ownership 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?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

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

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

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

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

# README

## US Hospital Ownership Records — CMS Owner Edges

**Keyless. Pay per record. Who owns America's hospitals — organization by organization.**

This actor turns the **US CMS** (Centers for Medicare & Medicaid Services) provider-ownership file into clean, per-edge records — the official map of which **organizations** own which Medicare-enrolled hospitals and facilities. Each run reads CMS's keyless data API and delivers one row per ownership relationship: the facility, the owning organization, the ownership percentage and role, the association date, and a full set of owner-type flags (for-profit, non-profit, private equity, REIT, holding company, investment firm, and more). Organization-to-facility grain, structured for engineering use, in the public domain, with a **hard person-gate: only organization owners are emitted, and every natural-person name, title, and street-address field is structurally excluded.**

### What this is, in one paragraph

CMS requires Medicare-enrolled hospitals and facilities to report their owners. This actor reads that file, keeps **only the organization owners** (owner TYPE = O), and flattens each into a single analysis-ready ownership **edge**: which organization owns which facility, at what percentage, in what role, since when — plus the owner's self-declared type flags that reveal private-equity, REIT, holding-company, and investment-firm ownership. This is the ownership/M\&A layer of US healthcare, not a quality-ratings dataset. Values are exactly as reported to CMS. You are billed only for records actually delivered.

### Who buys this and for what job

- **Healthcare M\&A, private-equity, and investment analysts** tracking who owns which facilities, private-equity and REIT penetration, and consolidation by chain.
- **Policy researchers and journalists** studying hospital consolidation, PE ownership, and holding-company structures.
- **Payers, competitors, and diligence teams** mapping the ownership tree behind a facility before contracting or a transaction.
- **Data engineers** who want the CMS ownership edges as clean rows without paging the raw API and filtering owner types by hand.

### Public-domain data — organization owners only

Two honesty riders travel on every record. First, **licensing**: CMS provider-ownership data is a **work of the US federal government** — no copyright, **public domain** under 17 U.S.C. §105 — free to reuse with attribution to CMS. Second, **fitness**: each row is one ownership relationship **as self-reported to CMS Medicare enrollment**; ownership percentages and type flags are as reported, and this is not a verified corporate-registry record or a legal determination.

### Hard person-gate — no individual owners, no person fields

The source file contains **individual** owners (real people, with first/middle/last name, title, and home address) alongside organization owners. This actor emits **only organization owners** (owner TYPE = O): every individual-owner row is dropped, and every natural-person field — owner first/middle/last name, title, and street address — is excluded structurally (those source columns are not in the field map at all), with a person-key guard on every record as a backstop. The acceptance suite feeds an individual-owner row carrying a real person's name, title, and street address and asserts none of it can ever appear in output.

### Pricing

| Event | Free plan | Bronze | Silver | Gold / Platinum / Diamond |
|-------|-----------|--------|--------|---------------------------|
| `ownership_record` | $0.05 | $0.045 | $0.04 | $0.0335 |

Delivered before charged. Blocked runs and empty results cost nothing.

### Input

| Field | Type | Default | Description |
|-------|------|---------|-------------|
| `state` | string | — | Optional. Keep only owners in this 2-letter state (e.g. TN, TX). |
| `privateEquityOnly` | boolean | false | If true, keep only owners flagged as a private-equity company. |
| `maxRecords` | integer | 500 | Ceiling on records delivered and billed. |

### Output

One JSON object per organization-to-facility ownership edge. Real example (values as reported to CMS):

```json
{
  "record_id": "O20020812000015:0244144871",
  "enrollment_id": "O20020812000015",
  "provider_organization_name": "SOUTHERN TENNESSEE MEDICAL CENTER LLC",
  "owner_associate_id": "0244144871",
  "owner_organization_name": "LIFEPOINT HOLDINGS 2 LLC",
  "owner_role_text": "5% OR GREATER INDIRECT OWNERSHIP INTEREST",
  "owner_association_date": "2025-03-01",
  "owner_city": "BRENTWOOD",
  "owner_state": "TN",
  "percentage_ownership": 80.0,
  "owner_is_for_profit": "Y",
  "owner_is_private_equity": null,
  "owner_is_holding_company": "N",
  "owner_type": "Organization",
  "source": "US CMS provider ownership file",
  "licence": "US CMS ... public domain (17 U.S.C. §105) ...",
  "disclaimer": "One organization-to-facility ownership relationship ... individual-owner rows ... excluded ...",
  "observed_at": "2026-08-21T00:00:00Z"
}
```

An unbilled `RUN_RECEIPT` records the robots check, the filters, source rows seen, organization owners matched and delivered, whether charged equals delivered, and a note that individual owners and person fields are excluded.

### Field reference

Each record is one ownership edge. Facility: `enrollment_id`, `provider_associate_id`, and `provider_organization_name`. Owner: `owner_associate_id`, `owner_organization_name`, `owner_doing_business_as`, `owner_city`, `owner_state`, and `owner_zip`. Relationship: `owner_role_code`, `owner_role_text`, `owner_association_date`, `percentage_ownership`, and `created_for_acquisition`. Owner type flags (Y/N): `owner_is_corporation`, `owner_is_llc`, `owner_is_medical_provider`, `owner_is_management_services`, `owner_is_medical_staffing`, `owner_is_holding_company`, `owner_is_investment_firm`, `owner_is_financial_institution`, `owner_is_consulting_firm`, `owner_is_for_profit`, `owner_is_non_profit`, `owner_is_private_equity`, `owner_is_reit`, `owner_is_chain_home_office`, `owner_is_other_type`, `owner_other_type_text`, and `owner_owned_by_another`. Provenance: `owner_type`, `source`, `source_url`, `licence`, `attribution`, `disclaimer`, and `observed_at`.

### How a run works

A run first re-reads the source host's robots posture from your runtime — CMS's data host serves no directives, a no-policy posture — and paces requests conservatively regardless. It then pages the CMS ownership dataset through the data API, and for each row keeps **only** organization owners (TYPE = O), applying your optional `state` and `privateEquityOnly` filters before delivery. Each matching edge is flattened to one record — reading only organization and relationship fields, **never** a person name, title, or street address — and delivered **before** it is charged, so a blocked or empty run costs you nothing. The actor stops at your `maxRecords` ceiling and records `charge_equals_delivered` in the receipt.

### Coverage and scope

The ownership file holds well over a hundred thousand owner relationships across US Medicare-enrolled hospitals and facilities; the organization-owner subset this actor emits is tens of thousands of edges. Because each edge carries the owner-type flags, the private-equity, REIT, investment-firm, and holding-company relationships are trivial to surface — pass `privateEquityOnly` for the PE map, or a `state` for a regional consolidation view. Ownership trees are visible through `owner_owned_by_another` and the `owner_organization_name` chain.

### Cost guidance

One `ownership_record` per delivered edge: cost = edges delivered × your plan's per-record price. Scope with `state` or `privateEquityOnly` to keep runs bounded — one state's ownership edges is typically a few hundred to a few thousand. 1,000 edges is **$50** (Free) / **$33.50** (Gold).

### Honest limitations

- **As self-reported.** Ownership percentages, roles, and type flags are as reported to CMS Medicare enrollment, not independently verified.
- **Organization owners only.** Individual owners are excluded by design — this is the organization/entity ownership layer, not a person dataset.
- **Ownership, not quality.** This is the ownership/M\&A layer; facility quality, ratings, and outcomes are a separate CMS product.
- **Edge grain.** One row is one owner-to-facility relationship; a facility with several owners appears as several edges.
- **No person data** — individual owners and every name/title/street-address field are excluded.

### Differentiation

The NexGenData fleet ships **cms-hospital-compare** (facility quality, ratings, and characteristics) and other CMS facility/quality cells. This actor is a different job on a different CMS file: the **ownership / M\&A edge layer** — which organization owns which facility, at what percentage, and of what type (private equity, REIT, holding company). Quality ratings ≠ ownership edges; this cell answers "who owns it and how," not "how good is it," and names the quality sibling so buyers pick the right one.

### The NexGen Signal family

Part of the NexGen Signal family of pay-per-record data products:

- [Mine Operator & Safety Records — US MSHA](https://apify.com/nexgensignal/mine-operator-safety-records)
- [Airport Facility Records — US FAA NASR](https://apify.com/nexgensignal/airport-facility-records)
- [EPA Facility Compliance Records — Envirofacts](https://apify.com/nexgensignal/epa-facility-compliance-records)
- [Organization Sanctions & LEI Risk](https://apify.com/nexgensignal/organization-sanctions-lei-risk)
- [Higher-Ed Institution Records — US IPEDS](https://apify.com/nexgensignal/higher-education-institution-records)

*Source: US CMS provider-ownership file (data.cms.gov). CMS data is a work of the US federal government, no copyright, public domain (17 U.S.C. §105); free to reuse with attribution to CMS. Organization owners only; individual owners and all natural-person name/title/street-address fields are structurally excluded and never emitted. Ownership as self-reported, not a verified registry or legal determination.*

# Actor input Schema

## `state` (type: `string`):

Optional. Keep only owners in this 2-letter state (e.g. TN, TX).

## `privateEquityOnly` (type: `boolean`):

If true, keep only owners flagged as a private-equity company.

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

Maximum records delivered and billed.

## Actor input object example

```json
{
  "privateEquityOnly": false,
  "maxRecords": 500
}
```

# Actor output Schema

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

The delivered CMS ownership 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 = {
    "maxRecords": 500
};

// Run the Actor and wait for it to finish
const run = await client.actor("nexgensignal/us-hospital-ownership-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 = { "maxRecords": 500 }

# Run the Actor and wait for it to finish
run = client.actor("nexgensignal/us-hospital-ownership-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 '{
  "maxRecords": 500
}' |
apify call nexgensignal/us-hospital-ownership-records --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,nexgensignal/us-hospital-ownership-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/2tpc4ekccTzamqTlz/builds/iUFvat4tNNOC1dcPx/openapi.json