# Medicare Tools: Reimbursement Calculator (`iceni-data/medicare-reimbursement-calculator`) Actor

Allowed amount, Medicare payment, patient coinsurance, sequestration, and modifier effects for any CPT by locality and site of service. Built on current CMS fee schedule files.

- **URL**: https://apify.com/iceni-data/medicare-reimbursement-calculator.md
- **Developed by:** [Martyn Gross](https://apify.com/iceni-data) (community)
- **Categories:**
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $20.00 / 1,000 reimbursement calculations

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/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

*Part of Iceni Data · Medicare Tools*

## Medicare Tools: Reimbursement Calculator

**Prices any HCPCS/CPT code against the Medicare Physician Fee Schedule (PFS) for a given locality, site of service, and modifiers** — allowed amount, the Medicare/patient split, sequestration, and (for non-participating providers) the limiting charge. Built on the CMS [PFS Relative Value Files](https://www.cms.gov/medicare/payment/fee-schedules/physician/pfs-relative-value-files) (RVUs, GPCIs, and conversion factors), kept current in this Actor's own named key-value store cache. Runs on the [Apify platform](https://apify.com), so you get scheduling, an API, webhooks, and monitoring for free.

### What does Medicare Reimbursement Calculator do?

It looks up a code's work/practice-expense/malpractice RVUs and a locality's GPCIs, applies the national conversion factor, and walks the result through whichever modifiers, unit count, participation status, and sequestration setting you specify — one output row per HCPCS code x locality pair. Every rule a given row actually used (which conversion factor, which modifier math, whether sequestration was cut) is written into that row's own `assumptions` list, so you never have to guess what was assumed.

### What this does not compute

This is a fee-schedule calculator, not a claims adjudicator. It deliberately does **not**:

- Apply **MAC-specific (contractor-specific) pricing** — only the national RVU/GPCI/conversion-factor formula, no local MAC pricing overrides or LCD/NCD medical-necessity determinations.
- Track a patient's **deductible** — `patient_coinsurance` assumes the deductible has already been met.
- Enforce **NCCI edits or bundling** — it prices the one code you give it in isolation; it doesn't know whether that code would deny or bundle against another code on the same claim.
- Enforce **MUE (Medically Unlikely Edit) unit limits** — it will happily price 50 units of a code CMS would actually cap at 1.
- Rank multiple procedures on the same claim for the **real multiple-procedure sequence** (100%/50%/50%/50%/50% by descending RVU) — modifier 51 is applied as a flat 50% reduction instead, since this calculator prices one code at a time (see the code's own `assumptions` for the caveat).
- Reconstruct **modifier-specific RVUs** for 26/professional-component and TC/technical-component splits from CMS's own per-modifier PPRRVU rows — it derives them formulaically from the single global RVU row instead (work+malpractice for 26, practice-expense for TC), which is why a 26/TC pair always sums back to exactly the global amount.

### Why use Medicare Reimbursement Calculator?

- **Front-desk and billing staff** can sanity-check an EOB or a payer estimate against the published fee schedule before appealing a denial, without a coding consultant.
- **Practice administrators** evaluating whether to add a new CPT code, take on non-participating status, or move a service from the office to a facility setting get an instant side-by-side of the dollar impact.
- **Health-tech builders** get a scriptable API/webhook-friendly pricing engine instead of hand-copying numbers out of CMS's own PDFs and spreadsheets — schedule it, call it from your own app via the Apify API, or feed its output straight into a billing system.

### How to use Medicare Reimbursement Calculator

1. Click **Try for free** (or **Start**) on this Actor's page.
2. In the **Input** tab, set at least `hcpcs` and `locality` (comma- or newline-separated for more than one), plus `site_of_service`, any `modifiers`, and the participation/sequestration flags.
3. Click **Start**. When the run finishes, open the **Dataset** tab to view, filter, or export the results (JSON, CSV, Excel, HTML, and more).
4. The underlying CMS lookup table (RVUs, GPCIs, conversion factors) refreshes itself automatically whenever it's missing or more than 30 days old — you don't need to do anything for that. To force an immediate refresh instead of pricing anything, run this Actor once with `refresh_cache: true` (owner-only).

### Input

All fields are described with an example in the **Input** tab. Full schema: [`.actor/input_schema.json`](.actor/input_schema.json).

| Field | Type | Description |
|---|---|---|
| `hcpcs` | string | One or more HCPCS/CPT codes, comma- or newline-separated. |
| `locality` | string | One or more CMS locality codes (e.g. `CA-05`) or two-letter states (e.g. `CA`), comma- or newline-separated. A bare state resolves to its statewide locality (`-00`) if one exists, else its lowest-numbered locality. |
| `site_of_service` | string | `"office"` (non-facility PE RVU) or `"facility"` (facility PE RVU). Default `"office"`. |
| `modifiers` | array | Any of `26`, `TC`, `50`, `51`, `80`, `81`, `82`. Default `[]`. |
| `units` | integer | Units billed. Default `1`. |
| `apm_qualifying` | boolean | Use the QP APM conversion factor instead of the standard one. Default `false`. |
| `participating` | boolean | Participating provider (95% reduction + limiting charge when `false`). Default `true`. |
| `apply_sequestration` | boolean | Apply the 2% Medicare sequestration cut. Default `true`. |
| `refresh_cache` | boolean | Maintenance mode: refresh the shared CMS lookup cache and exit. No rows, no charges. Owner-only. Default `false`. |

#### Three worked inputs

**1. The default case — an office visit:**

```json
{
  "hcpcs": "99213",
  "locality": "CA-05",
  "site_of_service": "office"
}
```

Priced against the cached 2026 RVU26D/GPCI files, this returns `allowed_amount: 117.58`. The same code with `"site_of_service": "facility"` returns `allowed_amount: 64.37` — the office rate is higher because the non-facility PE RVU (1.46) bakes in overhead the facility rate (0.33) assumes the facility itself absorbs.

**2. A professional/technical component split:**

```json
{
  "hcpcs": "99213",
  "locality": "CA-05",
  "site_of_service": "office",
  "modifiers": ["26"]
}
```

Run once with `modifiers: ["26"]` (`allowed_amount: 48.82`) and once with `modifiers: ["TC"]` (`allowed_amount: 68.76`) for the same code/locality — the two sum to exactly the global `117.58` from example 1, by construction (see "What this does not compute" above).

**3. A non-participating, non-office, batch case:**

```json
{
  "hcpcs": "99213, 99214",
  "locality": "CA-05, NY-01",
  "site_of_service": "facility",
  "modifiers": ["51"],
  "units": 1,
  "participating": false,
  "apply_sequestration": true
}
```

Produces 4 rows (2 codes x 2 localities), each non-participating (95% reduction, `limiting_charge` reported) with a 50% multiple-procedure reduction applied.

### Output

One flat JSON object per HCPCS x locality pair, pushed to the default dataset. You can download it as JSON, CSV, Excel, HTML, XML, or RSS from the **Export results** button. Missing values are `null`, never empty strings.

#### Example output row

Real output from the cached 2026 RVU26D/GPCI files, for `hcpcs: "99213"`, `locality: "CA-05"`, `site_of_service: "office"`, no modifiers, participating, with sequestration applied:

```json
{
  "hcpcs": "99213",
  "hcpcs_description": "Office o/p est low 20 min",
  "locality": "CA-05",
  "locality_name": "SAN FRANCISCO-OAKLAND-BERKELEY (SAN FRANCISCO/SAN MATEO/ALAMEDA/CONTRA COSTA CNTY)",
  "site_of_service": "office",
  "modifiers": [],
  "units": 1,
  "apm_qualifying": false,
  "participating": true,
  "apply_sequestration": true,
  "conversion_factor_type": "standard",
  "conversion_factor": 33.4009,
  "work_rvu": 1.3,
  "pe_rvu": 1.46,
  "mp_rvu": 0.09,
  "allowed_amount": 117.58,
  "medicare_pays": 92.18,
  "patient_coinsurance": 23.52,
  "sequestration_adjustment": 1.88,
  "net_to_provider": 115.7,
  "limiting_charge": null,
  "adjustments": [],
  "assumptions": [
    "Used the standard national conversion factor ($33.4009); no MAC-specific or locality-specific conversion factor variation applied.",
    "Allowed amount = (work RVU x work GPCI + practice-expense RVU x PE GPCI + malpractice RVU x MP GPCI) x conversion factor, per CMS Physician Fee Schedule methodology.",
    "Practice-expense RVU selected for site of service 'office' (non-facility PE RVU).",
    "1 unit(s) billed; the per-unit fee schedule amount was multiplied by units.",
    "Medicare pays 80% of the allowed amount and the patient owes the standard 20% Part B coinsurance; the patient's deductible status was not tracked.",
    "The mandatory 2% Medicare sequestration cut was applied to Medicare's payment only, not to the patient's coinsurance.",
    "Net to provider assumes the provider accepts assignment; it does not model non-assigned balance billing up to the limiting charge."
  ],
  "data_as_of": "2026-09-04",
  "source_urls": ["https://www.cms.gov/files/zip/rvu26d-updated-08-26-2026.zip"],
  "partial_data": false
}
```

#### Data table

| Field | Type | Description |
|---|---|---|
| `hcpcs` | string | The HCPCS/CPT code priced. |
| `hcpcs_description` | string or null | CMS's short description of the code. |
| `locality` | string or null | Resolved CMS locality code (e.g. `CA-05`). |
| `locality_name` | string or null | Human-readable locality name. |
| `site_of_service` | string | `"office"` or `"facility"`. |
| `modifiers` | array of strings | Modifiers requested on input. |
| `units` | integer | Units billed. |
| `apm_qualifying` | boolean | Whether the QP APM conversion factor was requested. |
| `participating` | boolean | Whether the billing provider participates in Medicare. |
| `apply_sequestration` | boolean | Whether the 2% sequestration cut was applied. |
| `conversion_factor_type` | string or null | `"standard"` or `"qp_apm"`. |
| `conversion_factor` | number or null | National conversion factor used, in dollars. |
| `work_rvu`, `pe_rvu`, `mp_rvu` | number or null | The RVU components used (PE RVU is site-of-service-specific). |
| `allowed_amount` | number or null | Medicare-recognized allowed amount, in dollars. |
| `medicare_pays` | number or null | Medicare's 80% share, after sequestration if applied. |
| `patient_coinsurance` | number or null | Patient's 20% coinsurance share. |
| `sequestration_adjustment` | number or null | Amount withheld from Medicare's payment by sequestration. |
| `net_to_provider` | number or null | `medicare_pays + patient_coinsurance`. |
| `limiting_charge` | number or null | Non-participating limiting charge (115% of the reduced allowed amount); `null` when participating. |
| `adjustments` | array | One entry per modifier actually applied, with its effect on the amount. |
| `assumptions` | array of strings | Every rule this row actually applied. |
| `data_as_of` | string (date) | Date the underlying CMS data was fetched. |
| `source_urls` | array of strings | URL(s) the row was built from. |
| `partial_data` | boolean | `true` if the HCPCS/locality couldn't be found or a modifier was unsupported. |

### Pricing / Cost estimation

This Actor charges per row returned (the `calculation` event), via `Actor.push_data(rows, charged_event_name='calculation')`. Free-plan users are capped at 25 rows per run (`my_actor/common/free_tier.py`); paying users are uncapped. A single HCPCS x locality lookup is one row; a batch of, say, 5 codes x 5 localities is 25 rows.

### Tips / Advanced options

- Batch codes and localities in one run (comma- or newline-separated in `hcpcs`/`locality`) instead of one run per pair — it's the same shared CMS lookup table either way, so batching avoids redundant cache reads.
- The CMS lookup table is cached in this Actor's own named key-value store (`cms-reimb-calc-cache`) and shared across every run of this Actor, refreshed automatically when it's stale (>30 days) or CMS publishes a new quarterly release — most runs don't pay any fetch cost at all. Named key-value stores are permission-scoped per Actor on the Apify platform, so this cache is not shared with any other Actor, including the companion medicare-fee-coverage-lookup Actor — each maintains its own independent copy.
- Check `assumptions` on any row before trusting a number for anything consequential — it tells you exactly which simplifications (see "What this does not compute") applied to that specific code/modifier combination.

### FAQ, disclaimers, and support

This tool estimates Medicare Part B fee-schedule reimbursement using CMS's own published RVU, GPCI, and conversion-factor files; it is not medical, legal, or billing advice, and CMS payment rules (MAC-specific pricing, NCCI edits, LCD/NCD coverage, deductibles) can change what a real claim actually pays. See "What this does not compute" above for the full list of known limitations. Found a discrepancy or have a request? Use this Actor's **Issues** tab — custom pricing logic (e.g. contractor-specific pricing, real multiple-procedure ranking across a full claim) is available on request.

### Related tools

Part of the **Medicare Tools** family on Apify:

- [Medicare Fee Coverage Lookup](https://apify.com/iceni-data/medicare-fee-coverage-lookup) — batch-prices codes across every locality in a state and attaches NCD/LCD coverage matches.

# Actor input Schema

## `hcpcs` (type: `string`):

One or more HCPCS/CPT codes to price, separated by commas or newlines (e.g. "99213, 99214"). Every code is priced against every locality below.

## `locality` (type: `string`):

One or more CMS locality codes (e.g. "CA-05") or two-letter state codes (e.g. "CA"), separated by commas or newlines. A bare state resolves to that state's statewide locality ("-00") when one exists, otherwise its lowest-numbered locality — see the row's `assumptions` for which one was used.

## `site_of_service` (type: `string`):

Which practice-expense RVU to use: "office" (non-facility, e.g. a physician's own office) or "facility" (hospital, ASC, or other facility setting where the facility bears some of the overhead cost).

## `modifiers` (type: `array`):

CPT/HCPCS modifiers to apply. Supported: 26 (professional component), TC (technical component), 50 (bilateral procedure, 150%), 51 (multiple-procedure reduction, 50%), 80/81/82 (assistant at surgery, 16%). Any other modifier is ignored and flagged in the row's `assumptions`.

## `units` (type: `integer`):

Number of units billed. The per-unit fee schedule amount is multiplied by this value.

## `apm_qualifying` (type: `boolean`):

Use the (slightly higher) Qualifying APM Participant conversion factor instead of the standard one.

## `participating` (type: `boolean`):

Whether the billing provider participates in Medicare. Non-participating providers are paid at 95% of the fee schedule amount, and the row reports the limiting charge (115% of that reduced amount).

## `apply_sequestration` (type: `boolean`):

Apply the mandatory 2% Medicare sequestration cut to Medicare's payment share (not the patient's coinsurance).

## `refresh_cache` (type: `boolean`):

Force-refresh the shared CMS lookup table (RVUs, GPCI, conversion factors) instead of pricing anything. Restricted to this Actor's owner. Every normal run already auto-refreshes this cache when it's missing or older than 30 days, so you only need this to refresh on demand.

## Actor input object example

```json
{
  "hcpcs": "99213",
  "locality": "CA-05",
  "site_of_service": "office",
  "modifiers": [],
  "units": 1,
  "apm_qualifying": false,
  "participating": true,
  "apply_sequestration": true,
  "refresh_cache": false
}
```

# Actor output Schema

## `dataset` (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 = {
    "hcpcs": "99213",
    "locality": "CA-05",
    "site_of_service": "office"
};

// Run the Actor and wait for it to finish
const run = await client.actor("iceni-data/medicare-reimbursement-calculator").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 = {
    "hcpcs": "99213",
    "locality": "CA-05",
    "site_of_service": "office",
}

# Run the Actor and wait for it to finish
run = client.actor("iceni-data/medicare-reimbursement-calculator").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 '{
  "hcpcs": "99213",
  "locality": "CA-05",
  "site_of_service": "office"
}' |
apify call iceni-data/medicare-reimbursement-calculator --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,iceni-data/medicare-reimbursement-calculator"
        }
    }
}

```

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/oWJiAZCpKo6PKl33k/builds/V2kj77wnastCpyimF/openapi.json