# CMS Inpatient Rehabilitation Utilization Scraper (`automation-lab/cms-inpatient-rehabilitation-utilization-scraper`) Actor

🏥 Extract official CMS IRF utilization, Medicare payment, beneficiary mix, provider geography, and service breakdown data.

- **URL**: https://apify.com/automation-lab/cms-inpatient-rehabilitation-utilization-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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/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/docs.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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

## CMS Inpatient Rehabilitation Utilization Scraper

Export official CMS Inpatient Rehabilitation Facility (IRF) utilization, payment, beneficiary mix, geography, provider, and service-breakdown data from the public CMS Data API.

This actor is built for analysts who need structured Medicare IRF rows without downloading CMS files manually, writing pagination code, or normalizing numeric healthcare fields by hand.

### What does CMS Inpatient Rehabilitation Utilization Scraper do?

It calls the official CMS Data API and saves clean dataset rows for Medicare Post-Acute Care Utilization — Inpatient Rehabilitation Facility data.

You can extract:

- 🏥 Provider-level IRF rows
- 🗺️ State and national summary rows
- 💵 Charges, allowed amounts, Medicare payments, and standardized payments
- 👥 Beneficiary counts and demographic percentages
- 📊 Optional service and case-mix breakdown rows
- 🔎 Raw CMS fields for auditability

### Who is it for?

This scraper is useful for healthcare and market-intelligence teams that need repeatable CMS IRF data exports.

Typical users include:

- 🏥 Post-acute-care operators benchmarking facilities
- 💼 Healthcare investors screening regional IRF markets
- 📈 Consultants preparing reimbursement and utilization studies
- 🧾 Payers analyzing Medicare utilization patterns
- 🗺️ Market strategy teams comparing states and providers
- 🧪 Data teams building healthcare dashboards

### Why use this actor?

CMS data is public, but production workflows still require paging, filtering, type conversion, and repeatable exports.

This actor handles those steps and returns analysis-ready rows in Apify datasets.

Benefits:

- No CMS login or API key required
- HTTP-only implementation, no browser overhead
- Official CMS source URLs included
- Numeric fields normalized to numbers
- Raw CMS row included for audit trails
- Works with Apify API, schedules, webhooks, and integrations

### Data source

The actor uses public CMS datasets:

- Medicare Post-Acute Care Utilization IRF by geography/provider
- Medicare Post-Acute Care Utilization IRF service/case-mix breakdown

The default dataset ID is `0d9eebff-7e23-4b1e-8e29-362eea132df5`.

The optional service-breakdown dataset ID is `62e62d07-1837-4dbf-bb4f-a4820e0c7b16`.

### What data can I extract?

The output includes provider identity, utilization metrics, payments, demographics, and service details.

| Field | Description |
| --- | --- |
| `recordType` | `utilization` or `service_breakdown` |
| `year` | CMS fiscal year |
| `summaryCategory` | CMS summary level such as STATE or PROVIDER |
| `providerId` | CMS provider identifier |
| `providerName` | Provider or geography name |
| `state` | Provider/geography state |
| `beneficiaries` | Distinct beneficiary count |
| `stays` | Total episode/stay count |
| `serviceDays` | Total service days |
| `totalCharges` | Total charges |
| `totalAllowedAmount` | Total allowed amount |
| `medicarePaymentAmount` | Total Medicare payment amount |
| `standardizedPaymentAmount` | Standardized Medicare payment amount |
| `dualEligiblePct` | Dual-eligible beneficiary percentage |
| `averageAge` | Average beneficiary age |
| `groupingDescription` | Service/case-mix group description |
| `raw` | Original CMS row |

### How much does it cost to scrape CMS inpatient rehabilitation utilization data?

This actor uses pay-per-event pricing.

You pay a small start fee plus a per-row charge for each saved CMS IRF dataset row.

Because the source is an official public JSON API, runs are usually inexpensive and do not require proxy traffic.

Use a low `maxItems` value for trial runs, then increase it for production exports.

### Input options

The actor accepts filters that map to CMS fields.

| Input | Description |
| --- | --- |
| `years` | Fiscal years to include |
| `states` | Two-letter state codes |
| `summaryCategories` | CMS summary levels such as `STATE` or `PROVIDER` |
| `providerIds` | Specific CMS provider IDs |
| `providerName` | Case-insensitive provider-name contains filter |
| `includeServiceBreakdown` | Also export service/case-mix rows |
| `maxItems` | Maximum saved rows |
| `pageSize` | CMS API page size |

### Example input

```json
{
  "years": [2023],
  "states": ["CA", "TX"],
  "summaryCategories": ["STATE", "PROVIDER"],
  "includeServiceBreakdown": false,
  "maxItems": 100,
  "pageSize": 500
}
````

### Output example

```json
{
  "recordType": "utilization",
  "year": 2023,
  "summaryCategory": "PROVIDER",
  "providerId": "050006",
  "providerName": "Providence St Joseph Hospital",
  "providerCity": "Eureka",
  "state": "CA",
  "beneficiaries": 180,
  "stays": 183,
  "serviceDays": 2121,
  "totalCharges": 18843948,
  "medicarePaymentAmount": 4989503,
  "scrapedAt": "2026-07-09T00:00:00.000Z"
}
```

### How to run the scraper

1. Open the actor on Apify.
2. Select fiscal years, states, and summary categories.
3. Keep `maxItems` low for a first test.
4. Enable service breakdown only when you need case-mix details.
5. Start the run.
6. Download the dataset as JSON, CSV, Excel, or via API.

### Tips for better results

- Use `summaryCategories: ["PROVIDER"]` for facility-level rows.
- Use `summaryCategories: ["STATE"]` for state totals.
- Add `providerIds` when monitoring known facilities.
- Use `providerName` for quick provider discovery.
- Increase `pageSize` for faster large exports.
- Lower `pageSize` if you use a narrow provider-name text filter.

### Integrations

You can connect results to healthcare analytics workflows.

Examples:

- Send provider benchmark rows to Google Sheets.
- Load CMS IRF utilization into BigQuery or Snowflake.
- Trigger a webhook when new CMS runs complete.
- Schedule monthly exports for reimbursement dashboards.
- Combine facility utilization with internal CRM or market data.

### API usage with Node.js

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/cms-inpatient-rehabilitation-utilization-scraper').call({
  years: [2023],
  states: ['CA'],
  summaryCategories: ['PROVIDER'],
  maxItems: 100,
});
console.log(run.defaultDatasetId);
```

### API usage with Python

```python
from apify_client import ApifyClient

client = ApifyClient('MY-APIFY-TOKEN')
run = client.actor('automation-lab/cms-inpatient-rehabilitation-utilization-scraper').call(run_input={
    'years': [2023],
    'states': ['CA'],
    'summaryCategories': ['PROVIDER'],
    'maxItems': 100,
})
print(run['defaultDatasetId'])
```

### API usage with cURL

```bash
curl -X POST "https://api.apify.com/v2/acts/automation-lab~cms-inpatient-rehabilitation-utilization-scraper/runs?token=$APIFY_TOKEN" \
  -H 'Content-Type: application/json' \
  -d '{"years":[2023],"states":["CA"],"summaryCategories":["PROVIDER"],"maxItems":100}'
```

### MCP usage

Use this actor from Claude Desktop or Claude Code through the Apify MCP server.

MCP URL:

```text
https://mcp.apify.com/?tools=automation-lab/cms-inpatient-rehabilitation-utilization-scraper
```

Claude Code setup:

```bash
claude mcp add apify-cms-irf https://mcp.apify.com/?tools=automation-lab/cms-inpatient-rehabilitation-utilization-scraper
```

Claude Desktop JSON configuration:

```json
{
  "mcpServers": {
    "apify-cms-irf": {
      "url": "https://mcp.apify.com/?tools=automation-lab/cms-inpatient-rehabilitation-utilization-scraper"
    }
  }
}
```

Example prompts:

- "Export 2023 CMS IRF provider utilization rows for California."
- "Get CMS inpatient rehab service-breakdown data for Texas and summarize payment per stay."
- "Compare IRF Medicare payment amounts across CA and NY providers."

### Scheduling

You can schedule this actor to refresh CMS exports periodically.

Useful schedules include:

- Monthly provider-monitoring exports
- Quarterly market-sizing snapshots
- Annual CMS data refresh checks
- Pre-investment diligence data pulls

### Service-breakdown mode

Set `includeServiceBreakdown` to `true` to add case-mix and service grouping rows.

Service-breakdown rows include fields such as:

- `groupingCode`
- `groupingDescription`
- `caseMix`
- `avgChargePerStay`
- `avgPaymentPerStay`
- `caseMixDayPct`

When service breakdown is enabled, the actor splits the requested `maxItems` between utilization and service rows so the dataset includes both types.

### Legality

This actor uses official public CMS API endpoints that do not require login or private credentials.

You are responsible for using exported data in compliance with applicable laws, CMS terms, privacy obligations, and your organization's policies.

The actor does not attempt to access private patient information.

### FAQ

#### Is this CMS IRF scraper using an official source?

Yes. It uses official public CMS Data API endpoints for Medicare Post-Acute Care Utilization IRF datasets.

#### Can I scrape provider-level inpatient rehabilitation rows?

Yes. Set `summaryCategories` to `PROVIDER` and optionally filter by `states`, `years`, or `providerIds`.

### Troubleshooting

#### Why did I get zero rows?

Check that your year, state, provider ID, and summary category combination exists in CMS data. For provider-level rows, use `PROVIDER`.

#### Why are some fields null?

CMS publishes different columns for utilization and service-breakdown rows. Fields not present in a source row are returned as null.

#### Why does service-breakdown output show fewer utilization rows?

When service breakdown is enabled, `maxItems` is shared across both record types so you can inspect both datasets in one run.

### Related scrapers

Explore related automation-lab healthcare and data actors:

- https://apify.com/automation-lab/cms-hospital-compare-scraper
- https://apify.com/automation-lab/cms-nursing-home-compare-scraper
- https://apify.com/automation-lab/medicare-care-compare-scraper

### Version notes

Initial version focuses on official CMS IRF utilization and optional service-breakdown datasets.

Future versions may add more CMS post-acute care datasets if users request them.

# Actor input Schema

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

CMS fiscal years to include. Leave empty for all available years.

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

Two-letter state codes to include, such as CA, TX, or NY. Leave empty for national/all-state rows.

## `summaryCategories` (type: `array`):

CMS summary levels such as NATION, STATE, or PROVIDER. PROVIDER gives facility-level rows.

## `providerIds` (type: `array`):

Optional CMS provider IDs. Leave empty to export all matching providers/geographies.

## `providerName` (type: `string`):

Optional case-insensitive text filter applied to PRVDR\_NAME after CMS API paging.

## `includeServiceBreakdown` (type: `boolean`):

Also export the CMS IRF service/case-mix breakdown dataset after utilization rows.

## `maxItems` (type: `integer`):

Maximum dataset rows to save across utilization and optional service-breakdown records.

## `pageSize` (type: `integer`):

Rows requested per CMS API page. Advanced users can reduce this for narrow name filters.

## Actor input object example

```json
{
  "years": [
    2023
  ],
  "states": [
    "CA",
    "TX"
  ],
  "summaryCategories": [
    "STATE",
    "PROVIDER"
  ],
  "providerIds": [],
  "includeServiceBreakdown": false,
  "maxItems": 20,
  "pageSize": 500
}
```

# Actor output Schema

## `overview` (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 = {
    "years": [
        2023
    ],
    "states": [
        "CA",
        "TX"
    ],
    "summaryCategories": [
        "STATE",
        "PROVIDER"
    ],
    "providerIds": [],
    "providerName": "",
    "includeServiceBreakdown": false,
    "maxItems": 20,
    "pageSize": 500
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/cms-inpatient-rehabilitation-utilization-scraper").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 = {
    "years": [2023],
    "states": [
        "CA",
        "TX",
    ],
    "summaryCategories": [
        "STATE",
        "PROVIDER",
    ],
    "providerIds": [],
    "providerName": "",
    "includeServiceBreakdown": False,
    "maxItems": 20,
    "pageSize": 500,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/cms-inpatient-rehabilitation-utilization-scraper").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 '{
  "years": [
    2023
  ],
  "states": [
    "CA",
    "TX"
  ],
  "summaryCategories": [
    "STATE",
    "PROVIDER"
  ],
  "providerIds": [],
  "providerName": "",
  "includeServiceBreakdown": false,
  "maxItems": 20,
  "pageSize": 500
}' |
apify call automation-lab/cms-inpatient-rehabilitation-utilization-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=automation-lab/cms-inpatient-rehabilitation-utilization-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "CMS Inpatient Rehabilitation Utilization Scraper",
        "description": "🏥 Extract official CMS IRF utilization, Medicare payment, beneficiary mix, provider geography, and service breakdown data.",
        "version": "0.1",
        "x-build-id": "sEp4tGEVhp4lAvPh7"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~cms-inpatient-rehabilitation-utilization-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-cms-inpatient-rehabilitation-utilization-scraper",
                "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/automation-lab~cms-inpatient-rehabilitation-utilization-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-cms-inpatient-rehabilitation-utilization-scraper",
                "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/automation-lab~cms-inpatient-rehabilitation-utilization-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-cms-inpatient-rehabilitation-utilization-scraper",
                "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": {
                    "years": {
                        "title": "Fiscal years",
                        "type": "array",
                        "description": "CMS fiscal years to include. Leave empty for all available years.",
                        "items": {
                            "type": "integer"
                        }
                    },
                    "states": {
                        "title": "States",
                        "type": "array",
                        "description": "Two-letter state codes to include, such as CA, TX, or NY. Leave empty for national/all-state rows.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "summaryCategories": {
                        "title": "Summary categories",
                        "type": "array",
                        "description": "CMS summary levels such as NATION, STATE, or PROVIDER. PROVIDER gives facility-level rows.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "providerIds": {
                        "title": "Provider IDs",
                        "type": "array",
                        "description": "Optional CMS provider IDs. Leave empty to export all matching providers/geographies.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "providerName": {
                        "title": "Provider name contains",
                        "type": "string",
                        "description": "Optional case-insensitive text filter applied to PRVDR_NAME after CMS API paging."
                    },
                    "includeServiceBreakdown": {
                        "title": "Include service breakdown",
                        "type": "boolean",
                        "description": "Also export the CMS IRF service/case-mix breakdown dataset after utilization rows.",
                        "default": false
                    },
                    "maxItems": {
                        "title": "Maximum rows",
                        "minimum": 1,
                        "maximum": 100000,
                        "type": "integer",
                        "description": "Maximum dataset rows to save across utilization and optional service-breakdown records.",
                        "default": 20
                    },
                    "pageSize": {
                        "title": "CMS API page size",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Rows requested per CMS API page. Advanced users can reduce this for narrow name filters.",
                        "default": 500
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
