# CMS Hospice Compare Scraper (`automation-lab/cms-hospice-compare-scraper`) Actor

🏥 Export CMS Care Compare hospice provider, ZIP, CAHPS, state, and national datasets. Schedule runs and download JSON, CSV, or Excel.

- **URL**: https://apify.com/automation-lab/cms-hospice-compare-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Business
- **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.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

## CMS Hospice Compare Scraper

Export CMS Care Compare hospice provider, ZIP service-area, CAHPS survey, state, and national quality datasets from the public CMS Provider Data API.

Use this actor when you need repeatable hospice provider data without manually downloading CMS CSV files or rebuilding API pagination logic.

### What does CMS Hospice Compare Scraper do?

CMS Hospice Compare Scraper collects structured records from CMS Provider Data hospice datasets.

It uses the public data.cms.gov API, not a browser session.

It can export provider listings, service ZIP rows, CAHPS survey rows, and aggregate quality tables.

Every row includes the CMS source dataset ID so you can audit where the data came from.

Optional raw records preserve CMS fields that may change over time.

### Who is it for?

Healthcare market researchers use it to monitor hospice provider coverage by geography.

Referral networks use it to build provider directories and operational snapshots.

Compliance teams use it to track CMS identifiers, ownership, and quality measures.

Private equity and roll-up analysts use it to map fragmented hospice markets.

Local lead-generation teams use it to find hospice facilities by state, county, or ZIP.

Data engineers use it as a scheduled CMS hospice extractor for warehouses and BI tools.

### Why use this actor?

CMS publishes useful data, but teams still need pagination, filters, normalized exports, and stable automation.

This actor wraps the CMS API in an Apify workflow that can be scheduled, integrated, and exported.

You can run small state pulls or larger recurring monitoring jobs.

You can keep raw CMS rows when downstream analysts need every original source column.

### Supported CMS hospice datasets

The default mode exports general hospice provider information.

`general_info` exports the CMS Hospice General Information table.

`provider_data` exports provider-level quality data.

`zip_data` exports ZIP service-area rows.

`provider_cahps` exports provider CAHPS survey rows.

`state_cahps` exports state CAHPS aggregates.

`national_cahps` exports national CAHPS aggregates.

`state_quality` exports state quality aggregates.

`national_quality` exports national quality aggregates.

### Data table

| Field | Description |
| --- | --- |
| `datasetMode` | Selected dataset mode |
| `datasetId` | CMS Provider Data dataset identifier |
| `datasetTitle` | Human-readable CMS dataset name |
| `cmsCertificationNumberCcn` | Hospice CMS certification number when available |
| `facilityName` | Hospice facility/provider name |
| `addressLine1` | Street address line 1 |
| `addressLine2` | Street address line 2 |
| `city` | City or town |
| `state` | State abbreviation |
| `zipCode` | ZIP code |
| `county` | County/parish |
| `telephoneNumber` | Provider phone number |
| `cmsRegion` | CMS region |
| `ownershipType` | Ownership classification |
| `certificationDate` | CMS certification date |
| `measureCode` | CMS measure code for quality rows |
| `measureName` | CMS measure name |
| `score` | Published score value |
| `footnote` | CMS footnote text or code |
| `measureDateRange` | Measurement date or date range |
| `sourceUrl` | CMS API source URL |
| `scrapedAt` | Actor extraction timestamp |
| `rawRecord` | Original CMS row when enabled |

### How much does it cost to extract CMS hospice data?

This actor uses pay-per-event pricing.

There is a small run-start charge plus a per-record charge for each CMS hospice row saved to the dataset.

The default input is intentionally small so first runs stay inexpensive.

Current event prices:

| Charge event | When it is charged | FREE | BRONZE | SILVER | GOLD | PLATINUM | DIAMOND |
| --- | --- | ---: | ---: | ---: | ---: | ---: | ---: |
| Run started | Once when the actor starts | $0.005 | $0.005 | $0.005 | $0.005 | $0.005 | $0.005 |
| Hospice record saved | Each CMS hospice row saved | $0.000022576 | $0.000019631 | $0.000015312 | $0.000011779 | $0.000010000 | $0.000010000 |

Example cost estimates before Apify platform fees or plan-specific billing details:

| Example run | Input pattern | Approximate actor charges |
| --- | --- | ---: |
| Arizona provider directory | `general_info`, `AZ`, 100 records | about $0.0073 |
| Texas CAHPS export | `provider_cahps`, `TX`, 500 records | about $0.0148 on BRONZE |
| National quality benchmark pull | aggregate quality tables, 1,000 records | about $0.0246 on BRONZE |

Use `maxItems` to cap spend on exploratory runs, then increase it for recurring exports once the fields match your workflow.

### Input options

`datasetModes` chooses one or more CMS hospice tables.

`states` filters by two-letter state abbreviation.

`zipCodes` filters by ZIP code when the selected table has ZIP data.

`counties` filters rows by county name after data is returned from CMS.

`providerCcns` filters by CMS certification number.

`maxItems` caps the total number of rows saved across all selected datasets.

`includeRawRecord` keeps the original CMS row for audit and schema-change resilience.

### Example input: Arizona provider directory

```json
{
  "datasetModes": ["general_info"],
  "states": ["AZ"],
  "maxItems": 100,
  "includeRawRecord": true
}
````

### Example input: Texas CAHPS rows

```json
{
  "datasetModes": ["provider_cahps"],
  "states": ["TX"],
  "maxItems": 500,
  "includeRawRecord": false
}
```

### Example input: national monitoring

```json
{
  "datasetModes": ["national_cahps", "national_quality"],
  "maxItems": 1000,
  "includeRawRecord": true
}
```

### Output example

```json
{
  "datasetMode": "general_info",
  "datasetId": "yc9t-dgbk",
  "datasetTitle": "Hospice General Information",
  "cmsCertificationNumberCcn": "001500",
  "facilityName": "AGAVE HOSPICE AND PALLIATIVE CARE",
  "city": "PHOENIX",
  "state": "AZ",
  "zipCode": "85032",
  "county": "Maricopa",
  "ownershipType": "For-Profit",
  "sourceUrl": "https://data.cms.gov/provider-data/api/1/datastore/query/yc9t-dgbk/0"
}
```

### How to run

Open the actor on Apify.

Choose one or more dataset modes.

Add state, ZIP, county, or CCN filters if needed.

Set `maxItems` based on the export size you want.

Run the actor and download the dataset as JSON, CSV, Excel, or through the API.

### Scheduling tips

Schedule weekly or monthly runs to monitor changes in hospice provider data.

Use a state filter for regional monitoring.

Use provider CCNs for a watchlist of specific hospices.

Keep `rawRecord` enabled for warehouse ingestion jobs that must preserve every CMS field.

### Integrations

Send results to Google Sheets for regional provider lists.

Load CSV exports into Airtable for operations teams.

Sync JSON records into Snowflake, BigQuery, or Postgres through Apify integrations.

Trigger webhooks when scheduled runs complete.

Use Apify datasets as a stable API for downstream dashboards.

### API usage with Node.js

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/cms-hospice-compare-scraper').call({
  datasetModes: ['general_info'],
  states: ['AZ'],
  maxItems: 100,
});
console.log(run.defaultDatasetId);
```

### API usage with Python

```python
from apify_client import ApifyClient

client = ApifyClient('APIFY_TOKEN')
run = client.actor('automation-lab/cms-hospice-compare-scraper').call(run_input={
    'datasetModes': ['general_info'],
    'states': ['AZ'],
    'maxItems': 100,
})
print(run['defaultDatasetId'])
```

### API usage with cURL

```bash
curl -X POST 'https://api.apify.com/v2/acts/automation-lab~cms-hospice-compare-scraper/runs?token=APIFY_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"datasetModes":["general_info"],"states":["AZ"],"maxItems":100}'
```

### Use with AI agents via MCP

CMS Hospice Compare Scraper is available as a tool for AI assistants that support the Model Context Protocol (MCP).

Add the Apify MCP server to your AI client to access this actor and other Apify actors.

**Setup for Claude Code**

```bash
claude mcp add --transport http apify "https://mcp.apify.com?tools=automation-lab/cms-hospice-compare-scraper"
```

**Setup for Claude Desktop, Cursor, or VS Code**

Add this actor-scoped MCP server URL to your MCP config file:

```json
{
  "mcpServers": {
    "apify-cms-hospice": {
      "url": "https://mcp.apify.com?tools=automation-lab/cms-hospice-compare-scraper"
    }
  }
}
```

Your AI assistant will use OAuth to authenticate with your Apify account on first use.

Example prompts:

- "Use automation-lab/cms-hospice-compare-scraper to export Arizona hospice provider records from CMS."
- "Get national hospice CAHPS rows and summarize the measures for a benchmark memo."
- "Build a provider CCN watchlist from CMS hospice data and identify ownership fields."

### Best practices

Start with one dataset mode until you confirm the field shape you need.

Use `maxItems` to control cost and export size.

Use state filters for large provider-level datasets.

Enable `rawRecord` when CMS column changes matter to your workflow.

Use aggregate national datasets for benchmark dashboards.

### Troubleshooting

If a state run returns fewer records than expected, verify the selected CMS dataset actually has state values.

If ZIP filters return no rows, use `zip_data` or provider tables with ZIP columns.

If you need every CMS column, enable `includeRawRecord`.

If a run is slow, reduce selected datasets or add state/provider filters.

### Legality

This actor reads public CMS Provider Data API endpoints.

Always use the exported data in accordance with CMS terms, Apify terms, and applicable healthcare data rules.

Do not treat scraped/public provider data as medical advice.

Verify critical compliance decisions against official CMS sources.

### Related scrapers

Use these automation-lab actors for complementary healthcare, lead enrichment, and territory-planning workflows:

- [NPI Registry Provider Scraper](https://apify.com/automation-lab/npi-registry-provider-scraper) — enrich hospice organizations and clinicians with NPI registry identifiers and taxonomy data.
- [Website Contact Finder](https://apify.com/automation-lab/website-contact-finder) — turn CMS provider websites into outreach-ready emails, phone numbers, and contact pages.
- [Email Finder](https://apify.com/automation-lab/email-finder) — find likely email addresses for provider domains after you build a hospice target list.
- [Google Maps Lead Finder](https://apify.com/automation-lab/google-maps-lead-finder) — expand CMS state exports with local map listings and territory-level business signals.
- [ClinicalTrials.gov Studies Scraper](https://apify.com/automation-lab/clinicaltrials-gov-studies-scraper) — monitor healthcare research activity for adjacent market and compliance analysis.

Combine CMS hospice data with website and NPI enrichment when you need outreach-ready provider lists.

Combine state exports with map or local lead actors when you need local territory planning.

### FAQ

#### Does this actor require a CMS login?

No. It uses public CMS Provider Data API endpoints.

#### Does it use a browser?

No. It is an API-first actor and does not need Playwright.

#### Can it preserve fields not listed in the schema?

Yes. Enable `includeRawRecord` to keep the original CMS row.

#### Can I export multiple tables in one run?

Yes. Select multiple `datasetModes`; rows include `datasetMode` and `datasetId`.

#### Can I monitor just one provider?

Yes. Add one or more CMS certification numbers in `providerCcns`.

#### Why are some fields null?

CMS hospice tables differ. Aggregate rows do not always have provider addresses, while provider rows do not always have measure scores.

### Changelog

Initial version exports public CMS hospice datasets with filters, normalized fields, and raw CMS row preservation.

# Actor input Schema

## `datasetModes` (type: `array`):

Choose one or more CMS Provider Data hospice datasets to export.

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

Optional list of 2-letter state abbreviations, such as AZ, TX, or FL. Leave empty for all states.

## `zipCodes` (type: `array`):

Optional list of 5-digit ZIP codes. Best for service-area ZIP dataset exports.

## `counties` (type: `array`):

Optional county names. Matching is case-insensitive and supports partial names.

## `providerCcns` (type: `array`):

Optional hospice provider CCN values for targeted provider exports.

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

Maximum dataset rows to save across all selected CMS hospice datasets.

## `includeRawRecord` (type: `boolean`):

Keep the original CMS API row in rawRecord so new or changing CMS fields are preserved.

## Actor input object example

```json
{
  "datasetModes": [
    "general_info"
  ],
  "states": [
    "AZ"
  ],
  "zipCodes": [],
  "counties": [],
  "providerCcns": [],
  "maxItems": 20,
  "includeRawRecord": true
}
```

# 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 = {
    "datasetModes": [
        "general_info"
    ],
    "states": [
        "AZ"
    ],
    "zipCodes": [],
    "counties": [],
    "providerCcns": [],
    "maxItems": 20,
    "includeRawRecord": true
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/cms-hospice-compare-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 = {
    "datasetModes": ["general_info"],
    "states": ["AZ"],
    "zipCodes": [],
    "counties": [],
    "providerCcns": [],
    "maxItems": 20,
    "includeRawRecord": True,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/cms-hospice-compare-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 '{
  "datasetModes": [
    "general_info"
  ],
  "states": [
    "AZ"
  ],
  "zipCodes": [],
  "counties": [],
  "providerCcns": [],
  "maxItems": 20,
  "includeRawRecord": true
}' |
apify call automation-lab/cms-hospice-compare-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "CMS Hospice Compare Scraper",
        "description": "🏥 Export CMS Care Compare hospice provider, ZIP, CAHPS, state, and national datasets. Schedule runs and download JSON, CSV, or Excel.",
        "version": "0.1",
        "x-build-id": "ALeRpxD9HmBkzmUvQ"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~cms-hospice-compare-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-cms-hospice-compare-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-hospice-compare-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-cms-hospice-compare-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-hospice-compare-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-cms-hospice-compare-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": {
                    "datasetModes": {
                        "title": "Datasets to export",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Choose one or more CMS Provider Data hospice datasets to export.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "general_info",
                                "provider_data",
                                "zip_data",
                                "provider_cahps",
                                "state_cahps",
                                "national_cahps",
                                "state_quality",
                                "national_quality"
                            ],
                            "enumTitles": [
                                "General hospice provider information",
                                "Provider quality data",
                                "ZIP service-area data",
                                "Provider CAHPS survey data",
                                "State CAHPS survey data",
                                "National CAHPS survey data",
                                "State quality aggregates",
                                "National quality aggregates"
                            ]
                        },
                        "default": [
                            "general_info"
                        ]
                    },
                    "states": {
                        "title": "State abbreviations",
                        "type": "array",
                        "description": "Optional list of 2-letter state abbreviations, such as AZ, TX, or FL. Leave empty for all states.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "zipCodes": {
                        "title": "ZIP codes",
                        "type": "array",
                        "description": "Optional list of 5-digit ZIP codes. Best for service-area ZIP dataset exports.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "counties": {
                        "title": "County names",
                        "type": "array",
                        "description": "Optional county names. Matching is case-insensitive and supports partial names.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "providerCcns": {
                        "title": "CMS certification numbers (CCNs)",
                        "type": "array",
                        "description": "Optional hospice provider CCN values for targeted provider exports.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxItems": {
                        "title": "Maximum records",
                        "minimum": 1,
                        "maximum": 100000,
                        "type": "integer",
                        "description": "Maximum dataset rows to save across all selected CMS hospice datasets.",
                        "default": 20
                    },
                    "includeRawRecord": {
                        "title": "Include raw CMS row",
                        "type": "boolean",
                        "description": "Keep the original CMS API row in rawRecord so new or changing CMS fields are preserved.",
                        "default": true
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
