# CMS Medicare Provider Scraper (`automation-lab/cms-medicare-provider-scraper`) Actor

Extract CMS Medicare provider and facility datasets with identifiers, addresses, ratings, metadata, raw fields, and source API URLs.

- **URL**: https://apify.com/automation-lab/cms-medicare-provider-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Lead generation
- **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 Medicare Provider Scraper

Extract public Medicare provider and facility records from the CMS Provider Data API.

Use this Apify Actor to search CMS Provider Data datasets, fetch rows in bulk, normalize common provider/facility fields, and keep raw CMS columns for deeper analytics.

### What does CMS Medicare Provider Scraper do?

CMS Medicare Provider Scraper is an API-first extractor for public datasets hosted on `data.cms.gov/provider-data`.

It helps you collect Medicare facility and provider records such as dialysis facilities, hospitals, home health agencies, hospices, nursing homes, quality measures, ratings, addresses, and contact fields when those columns exist in the selected CMS dataset.

The actor does not require a CMS login.

It uses the public CMS Provider Data metastore and datastore endpoints.

### Who is it for?

🏥 Healthcare sales teams use it to build facility and provider lead lists.

📍 Provider-directory teams use it to enrich addresses, phone numbers, identifiers, and CMS dataset context.

📊 Market analysts use it to compare public Medicare facility coverage and quality attributes by state or dataset.

✅ Compliance and diligence teams use it to preserve public CMS source fields with source URLs and timestamps.

🧩 Data engineers use it as a repeatable Apify job that exports clean JSON, CSV, Excel, or API results.

### Why use this Medicare provider scraper?

CMS exposes many healthcare datasets, but the schemas vary.

This actor normalizes common columns into stable field names.

It also preserves the original CMS row under `raw` so you do not lose dataset-specific quality, rating, or operational columns.

You can search datasets by keyword or pin exact CMS dataset IDs.

You can limit rows per dataset to keep test runs cheap.

### Source data

The source is CMS Provider Data.

Catalog endpoint:

`https://data.cms.gov/provider-data/api/1/metastore/schemas/dataset/items`

Row endpoint pattern:

`https://data.cms.gov/provider-data/api/1/datastore/query/{datasetId}/0?offset={offset}&limit={limit}`

CMS controls the dataset contents, update cadence, and column names.

### What data can you extract?

The actor can extract rows from CMS Provider Data datasets that are available through the public datastore API.

Examples include facility listings, hospital quality datasets, dialysis datasets, state/national averages, and other provider-data resources.

You can start with the prefilled dialysis facility listing dataset ID `23ew-n7w9`.

You can also search terms like `hospital quality`, `home health`, `hospice`, `nursing facility`, or `provider`.

### Data table

| Field | Description |
| --- | --- |
| `datasetId` | CMS Provider Data dataset identifier |
| `datasetTitle` | CMS dataset title |
| `providerId` | Best available provider/facility identifier |
| `npi` | National Provider Identifier when present |
| `ccn` | CMS Certification Number when present |
| `name` | Provider, organization, hospital, or facility name |
| `providerType` | Provider/facility type when present |
| `specialty` | Specialty/taxonomy when present |
| `ownership` | Ownership, chain, or profit status when present |
| `rating` | Common quality/rating field when present |
| `addressLine1` | Street address line 1 |
| `addressLine2` | Street address line 2 |
| `city` | City or town |
| `state` | State abbreviation |
| `zipCode` | ZIP code |
| `county` | County/parish |
| `phone` | Telephone number |
| `sourceApiUrl` | CMS API URL used for the row page |
| `sourceRowIndex` | Source row index within the selected CMS dataset |
| `scrapedAt` | ISO timestamp for extraction |
| `dataset` | Optional compact CMS dataset metadata |
| `raw` | Optional original CMS row fields |

### How much does it cost to scrape CMS Medicare provider data?

This actor uses pay-per-event pricing.

There is a small run-start event and a per-row `item` event.

The per-row `item` event is formula-priced from cloud cost measurements. Current BRONZE per-row price is $0.000027457, with lower prices on higher Apify subscription tiers.

For small tests, keep `maxRows` low.

For production exports, raise `maxRows` and use exact `datasetIds` when you already know the CMS dataset you need.

### Input options

`datasetIds` lets you provide exact CMS dataset identifiers.

`datasetSearch` finds datasets by terms in CMS metadata.

`maxRows` limits total rows saved across all selected datasets.

`rowsPerDataset` limits rows saved from each selected dataset.

`pageSize` controls CMS API request size.

`state` filters common state fields.

`city` filters common city/town fields.

`nameContains` filters common provider/facility name fields.

`includeRawFields` preserves all original CMS columns.

`includeDatasetMetadata` attaches CMS dataset title, description, keywords, and modified date.

### Example input: exact dataset

```json
{
  "datasetIds": ["23ew-n7w9"],
  "maxRows": 100,
  "rowsPerDataset": 100,
  "pageSize": 100,
  "includeRawFields": true,
  "includeDatasetMetadata": true
}
````

### Example input: search datasets

```json
{
  "datasetSearch": "hospital quality",
  "maxRows": 250,
  "rowsPerDataset": 50,
  "pageSize": 100,
  "state": "CA",
  "includeRawFields": false,
  "includeDatasetMetadata": true
}
```

### Example output

```json
{
  "datasetId": "23ew-n7w9",
  "datasetTitle": "Dialysis Facility - Listing by Facility",
  "providerId": "012306",
  "ccn": "012306",
  "name": "CHILDRENS HOSPITAL DIALYSIS",
  "ownership": "Non-profit",
  "addressLine1": "1600 7TH AVENUE SOUTH",
  "city": "BIRMINGHAM",
  "state": "AL",
  "zipCode": "35233",
  "county": "Jefferson",
  "phone": "(205) 638-9275",
  "sourceApiUrl": "https://data.cms.gov/provider-data/api/1/datastore/query/23ew-n7w9/0?offset=0&limit=100",
  "sourceRowIndex": 0,
  "scrapedAt": "2026-06-28T00:00:00.000Z"
}
```

### How to use this actor

1. Open the actor on Apify.

2. Choose exact `datasetIds` or enter `datasetSearch` terms.

3. Set `maxRows` and `rowsPerDataset`.

4. Add optional filters such as `state` or `nameContains`.

5. Run the actor.

6. Export the dataset as JSON, CSV, Excel, XML, RSS, or HTML.

### Tips for best results

Use exact CMS dataset IDs for repeatable production jobs.

Use search terms when discovering useful datasets.

Keep `includeRawFields` enabled if you need quality measures, rating details, dates, or dataset-specific columns.

Disable `includeRawFields` if you only need the normalized contact and identifier fields.

Start with a small `maxRows` to validate the dataset and filters.

### Integrations

Send extracted rows to a CRM for healthcare lead enrichment.

Load rows into a data warehouse for provider network analysis.

Schedule recurring runs to monitor public CMS dataset updates.

Use webhooks to trigger downstream validation workflows after each run.

Combine results with your NPI, claims, licensing, or facility-reference 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-medicare-provider-scraper').call({
  datasetIds: ['23ew-n7w9'],
  maxRows: 100,
  includeRawFields: true
});
console.log(run.defaultDatasetId);
```

### API usage with Python

```python
from apify_client import ApifyClient
import os

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/cms-medicare-provider-scraper').call(run_input={
    'datasetIds': ['23ew-n7w9'],
    'maxRows': 100,
    'includeRawFields': True,
})
print(run['defaultDatasetId'])
```

### API usage with cURL

```bash
curl -X POST 'https://api.apify.com/v2/acts/automation-lab~cms-medicare-provider-scraper/runs?token=YOUR_APIFY_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"datasetIds":["23ew-n7w9"],"maxRows":100,"includeRawFields":true}'
```

### MCP usage

Use the Apify MCP server with this actor when you want Claude or another MCP client to run CMS provider-data extraction.

MCP URL:

`https://mcp.apify.com/?tools=automation-lab/cms-medicare-provider-scraper`

Claude Code setup:

```bash
claude mcp add apify-cms-medicare-provider-scraper https://mcp.apify.com/?tools=automation-lab/cms-medicare-provider-scraper
```

JSON MCP configuration:

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

Example prompts:

- "Run the CMS Medicare Provider Scraper for dialysis facility dataset 23ew-n7w9 and return 100 Alabama rows."
- "Find CMS hospital quality datasets and export the first 250 rows with raw fields disabled."
- "Extract Medicare provider/facility records for CA and summarize the available dataset titles."

### Related scrapers

Use `https://apify.com/automation-lab/npi-registry-provider-scraper` when you specifically need NPI Registry records.

Use `https://apify.com/automation-lab/fda-openfda-scraper` when you need FDA/OpenFDA public datasets.

Use this actor when the source of truth should be CMS Provider Data datasets.

### Legality and responsible use

CMS Provider Data is public government data.

You are responsible for using the extracted data in compliance with applicable laws, contracts, and internal policies.

Do not treat public records as a substitute for legal, compliance, or clinical advice.

Respect CMS source attribution and dataset documentation.

### Troubleshooting

If no rows are returned, check whether your `datasetIds` are valid CMS Provider Data identifiers.

If search returns an unexpected dataset, use exact `datasetIds` instead of broad search terms.

If normalized fields are empty, inspect the `raw` object because CMS source schemas differ by dataset.

If filters remove too many rows, test without `state`, `city`, or `nameContains` first.

### FAQ

#### Does this require a CMS account?

No. It uses public CMS Provider Data API endpoints.

#### Can I scrape all CMS Provider Data datasets?

Yes, but start with specific datasets and bounded `maxRows` values. CMS schemas vary and very large exports should be split into predictable jobs.

#### Why are some fields missing?

Different CMS datasets expose different columns. The actor fills normalized fields when matching source columns exist and can preserve all original fields under `raw`.

#### Can I filter by specialty?

The current actor normalizes specialty when present, but specialty filtering depends on the selected CMS dataset's columns. Use raw output to inspect exact field names.

#### Is this the same as an NPI Registry scraper?

No. It targets CMS Provider Data datasets. For NPI Registry-specific search, use an NPI-focused actor.

### Changelog

Initial version extracts CMS Provider Data catalog-backed rows, normalizes common provider/facility fields, and preserves raw CMS columns.

# Actor input Schema

## `datasetSearch` (type: `string`):

Terms matched against CMS Provider Data dataset titles, descriptions, keywords, and identifiers. Ignored when datasetIds are provided.

## `datasetIds` (type: `array`):

Optional exact CMS Provider Data dataset identifiers, for example 23ew-n7w9 for Dialysis Facility - Listing by Facility. Leave empty to use dataset search.

## `maxRows` (type: `integer`):

Maximum total provider/facility rows to save across all selected datasets.

## `rowsPerDataset` (type: `integer`):

Maximum rows to save from each CMS dataset before moving to the next selected dataset.

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

Rows requested per CMS API page. Keep the default unless you need smaller API calls.

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

Optional two-letter state filter applied to common state fields in each CMS row.

## `city` (type: `string`):

Optional city/town text filter. Matching is case-insensitive and uses common city fields.

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

Optional provider/facility name text filter. Matching is case-insensitive and uses common name fields.

## `includeRawFields` (type: `boolean`):

Preserve source-specific CMS columns under raw so analysts can use every field from the selected dataset.

## `includeDatasetMetadata` (type: `boolean`):

Attach compact CMS dataset metadata to each row, including title, description, keywords, and modified date.

## Actor input object example

```json
{
  "datasetSearch": "hospital quality provider facility",
  "datasetIds": [
    "23ew-n7w9"
  ],
  "maxRows": 20,
  "rowsPerDataset": 20,
  "pageSize": 100,
  "state": "AL",
  "includeRawFields": true,
  "includeDatasetMetadata": 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 = {
    "datasetSearch": "hospital quality provider facility",
    "datasetIds": [
        "23ew-n7w9"
    ],
    "maxRows": 20,
    "rowsPerDataset": 20,
    "pageSize": 100,
    "state": "AL",
    "includeRawFields": true,
    "includeDatasetMetadata": true
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/cms-medicare-provider-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 = {
    "datasetSearch": "hospital quality provider facility",
    "datasetIds": ["23ew-n7w9"],
    "maxRows": 20,
    "rowsPerDataset": 20,
    "pageSize": 100,
    "state": "AL",
    "includeRawFields": True,
    "includeDatasetMetadata": True,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/cms-medicare-provider-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 '{
  "datasetSearch": "hospital quality provider facility",
  "datasetIds": [
    "23ew-n7w9"
  ],
  "maxRows": 20,
  "rowsPerDataset": 20,
  "pageSize": 100,
  "state": "AL",
  "includeRawFields": true,
  "includeDatasetMetadata": true
}' |
apify call automation-lab/cms-medicare-provider-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "CMS Medicare Provider Scraper",
        "description": "Extract CMS Medicare provider and facility datasets with identifiers, addresses, ratings, metadata, raw fields, and source API URLs.",
        "version": "0.1",
        "x-build-id": "Bu7GyZrKcWYoHFLab"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~cms-medicare-provider-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-cms-medicare-provider-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-medicare-provider-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-cms-medicare-provider-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-medicare-provider-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-cms-medicare-provider-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": {
                    "datasetSearch": {
                        "title": "Dataset search terms",
                        "type": "string",
                        "description": "Terms matched against CMS Provider Data dataset titles, descriptions, keywords, and identifiers. Ignored when datasetIds are provided."
                    },
                    "datasetIds": {
                        "title": "CMS dataset IDs",
                        "type": "array",
                        "description": "Optional exact CMS Provider Data dataset identifiers, for example 23ew-n7w9 for Dialysis Facility - Listing by Facility. Leave empty to use dataset search.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxRows": {
                        "title": "Maximum rows",
                        "minimum": 1,
                        "maximum": 100000,
                        "type": "integer",
                        "description": "Maximum total provider/facility rows to save across all selected datasets.",
                        "default": 20
                    },
                    "rowsPerDataset": {
                        "title": "Rows per dataset",
                        "minimum": 1,
                        "maximum": 100000,
                        "type": "integer",
                        "description": "Maximum rows to save from each CMS dataset before moving to the next selected dataset.",
                        "default": 20
                    },
                    "pageSize": {
                        "title": "CMS API page size",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Rows requested per CMS API page. Keep the default unless you need smaller API calls.",
                        "default": 100
                    },
                    "state": {
                        "title": "State",
                        "type": "string",
                        "description": "Optional two-letter state filter applied to common state fields in each CMS row."
                    },
                    "city": {
                        "title": "City contains",
                        "type": "string",
                        "description": "Optional city/town text filter. Matching is case-insensitive and uses common city fields."
                    },
                    "nameContains": {
                        "title": "Provider or facility name contains",
                        "type": "string",
                        "description": "Optional provider/facility name text filter. Matching is case-insensitive and uses common name fields."
                    },
                    "includeRawFields": {
                        "title": "Include raw CMS fields",
                        "type": "boolean",
                        "description": "Preserve source-specific CMS columns under raw so analysts can use every field from the selected dataset.",
                        "default": true
                    },
                    "includeDatasetMetadata": {
                        "title": "Include dataset metadata",
                        "type": "boolean",
                        "description": "Attach compact CMS dataset metadata to each row, including title, description, keywords, and modified date.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
