# CMS Dialysis Facility Compare Scraper (`automation-lab/cms-dialysis-facility-compare-scraper`) Actor

Extract CMS dialysis facility listings, ICH CAHPS survey ratings, and ESRD QIP metrics for healthcare benchmarking and network analysis.

- **URL**: https://apify.com/automation-lab/cms-dialysis-facility-compare-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/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 Dialysis Facility Compare Scraper

Extract dialysis facility listings, quality ratings, patient survey scores, and ESRD QIP metrics from the public CMS Provider Data API.

### What does CMS Dialysis Facility Compare Scraper do?

CMS Dialysis Facility Compare Scraper turns public CMS dialysis datasets into clean Apify dataset rows.

It supports three CMS Provider Data API sources:

- 🏥 Dialysis Facility - Listing by Facility
- ⭐ Patient survey (ICH CAHPS) - Facility
- 📊 ESRD QIP - Complete QIP Data

Use it to collect dialysis facility names, CCNs, addresses, ownership flags, chain organizations, service capabilities, quality categories, survey ratings, and QIP performance fields.

### Who is it for?

This actor is built for teams that monitor ESRD and dialysis facility data.

- 🧑‍⚕️ Healthcare analysts benchmarking quality and access
- 💼 Payers evaluating dialysis provider networks
- 📈 Consultants preparing market maps and facility scorecards
- 🏢 B2B healthcare vendors finding sales/account triggers
- ✅ Compliance teams tracking CMS quality-program data
- 🧪 Data teams enriching internal provider master files

### Why use it?

CMS publishes dialysis data, but analysts often need a repeatable workflow.

This actor gives you:

- A simple input form for common dialysis filters
- Repeatable runs for state, city, ZIP, CCN, chain, and ownership monitoring
- JSON, CSV, Excel, and API exports through Apify datasets
- Optional raw CMS records when you need every source column
- A normalized output table for common business workflows

### Data sources

The actor uses public CMS Provider Data API endpoints on `data.cms.gov`.

| Input option | CMS dataset | Best for |
| --- | --- | --- |
| `facility` | `23ew-n7w9` | Facility listing, addresses, ownership, services, ratings |
| `patientSurvey` | `59mq-zhts` | ICH CAHPS patient survey ratings |
| `qipComplete` | `complete_qip_data` | ESRD QIP scores and payment metrics |

### What data can you extract?

Typical output fields include:

| Field | Description |
| --- | --- |
| `ccn` | CMS Certification Number |
| `facilityName` | Dialysis facility name |
| `address` | Street address |
| `city`, `state`, `zipCode`, `county` | Location fields |
| `phone` | Facility phone number |
| `profitStatus` | Profit or non-profit flag |
| `chainOwned` | CMS chain-owned flag |
| `chainOrganization` | Chain organization name |
| `dialysisStations` | Number of dialysis stations |
| `fiveStarRating` | CMS five-star rating when available |
| `patientSurvivalCategory` | Survival performance category |
| `hospitalizationCategory` | Hospitalization performance category |
| `readmissionCategory` | Readmission performance category |
| `surveyOverallFacilityRating` | ICH CAHPS facility rating |
| `qipTotalPerformanceScore` | ESRD QIP total performance score |
| `sourceUrl` | CMS source dataset page |

### How much does it cost to scrape CMS dialysis facility compare data?

This actor uses pay-per-event pricing.

- A small start fee is charged once per run.
- A per-record event is charged for each CMS dialysis record saved.
- You control cost with `maxItems` and filters.

Because the actor uses a public API and does not require a browser or proxies, runs are designed to be inexpensive and predictable.

### Quick start

1. Open the actor on Apify.
2. Choose a CMS dialysis dataset.
3. Set `maxItems`.
4. Add filters such as state, city, ZIP, facility name, or CCN.
5. Run the actor.
6. Export results from the dataset as JSON, CSV, Excel, or through the Apify API.

### Input options

#### Dataset

Use `datasetType` to choose the CMS source:

- `facility` for core facility listing and quality categories
- `patientSurvey` for patient experience ratings
- `qipComplete` for ESRD QIP metrics

#### Filters

You can filter by:

- State abbreviation
- City name
- ZIP code or ZIP prefix
- County/parish
- Facility name
- CMS Certification Number
- Chain-owned flag
- Profit/non-profit status
- Minimum or maximum dialysis stations

#### Raw record option

Set `includeRawRecord` to `true` when you need the full raw CMS API row in addition to normalized fields.

### Example input: California dialysis facilities

```json
{
  "datasetType": "facility",
  "state": "CA",
  "maxItems": 100
}
````

### Example input: Los Angeles patient survey ratings

```json
{
  "datasetType": "patientSurvey",
  "state": "CA",
  "city": "Los Angeles",
  "maxItems": 50
}
```

### Example input: ESRD QIP records for a facility name

```json
{
  "datasetType": "qipComplete",
  "facilityName": "dialysis",
  "state": "TX",
  "maxItems": 100,
  "includeRawRecord": true
}
```

### Example output

```json
{
  "datasetType": "facility",
  "datasetId": "23ew-n7w9",
  "datasetTitle": "Dialysis Facility - Listing by Facility",
  "ccn": "052345",
  "facilityName": "EXAMPLE DIALYSIS CENTER",
  "network": "18",
  "address": "123 MAIN ST",
  "city": "LOS ANGELES",
  "state": "CA",
  "zipCode": "90001",
  "county": "Los Angeles",
  "phone": "(555) 555-0100",
  "profitStatus": "Profit",
  "chainOwned": "Yes",
  "chainOrganization": "Example Chain",
  "dialysisStations": 24,
  "fiveStarRating": 4,
  "sourceUrl": "https://data.cms.gov/provider-data/dataset/23ew-n7w9",
  "scrapedAt": "2026-07-04T00:00:00.000Z"
}
```

### Tips for better results

- Use `state` when you need a practical state-level export.
- Add `city` or `zipCode` to target a market area.
- Use `ccn` for exact facility checks.
- Use `includeRawRecord` only when you need all CMS columns because it makes output wider.
- For broad monitoring, schedule one run per state or region.

### Common workflows

#### Network analysis

Collect dialysis facilities in a state or metro area, then compare ownership, chains, services, and quality categories.

#### Sales/account monitoring

Run scheduled searches for target markets and identify facilities by chain, ownership, size, or QIP/survey signals.

#### Compliance research

Export QIP or survey datasets and preserve the raw CMS record for audit trails.

#### Provider master enrichment

Match internal provider records by CCN, facility name, ZIP, and state, then enrich with CMS public fields.

### Integrations

Use results with:

- Apify datasets
- Google Sheets exports
- BI tools such as Tableau, Power BI, or Looker
- CRM enrichment workflows
- Data warehouses
- Apify webhooks and schedules
- Zapier or Make scenarios

### 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-dialysis-facility-compare-scraper').call({
  datasetType: 'facility',
  state: 'CA',
  maxItems: 100,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

### API usage with Python

```python
from apify_client import ApifyClient
import os

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/cms-dialysis-facility-compare-scraper').call(run_input={
    'datasetType': 'facility',
    'state': 'CA',
    'maxItems': 100,
})
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

### API usage with cURL

```bash
curl -X POST "https://api.apify.com/v2/acts/automation-lab~cms-dialysis-facility-compare-scraper/runs?token=$APIFY_TOKEN" \
  -H 'Content-Type: application/json' \
  -d '{"datasetType":"facility","state":"CA","maxItems":100}'
```

### MCP integration

Use this actor from Claude Desktop, Claude Code, or other MCP-compatible clients through Apify MCP.

MCP tool URL:

```text
https://mcp.apify.com/?tools=automation-lab/cms-dialysis-facility-compare-scraper
```

Add it in Claude Code:

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

Claude Desktop JSON configuration:

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

Example prompts:

- "Extract CMS dialysis facilities in California and summarize the largest chains."
- "Find ICH CAHPS dialysis survey records for Los Angeles."
- "Get ESRD QIP records for Texas dialysis facilities and show low scoring facilities."

### Scheduling

You can schedule the actor to run monthly or quarterly as CMS updates dialysis datasets.

Suggested schedules:

- Monthly state-level exports
- Quarterly QIP monitoring
- Weekly sales territory refreshes
- Ad hoc CCN checks during diligence or compliance reviews

### Limitations

- The actor returns public CMS data as available from `data.cms.gov`.
- CMS fields vary by dataset; some output fields are `null` when the selected dataset does not contain that measure.
- Very broad filtered searches may scan multiple API pages before finding enough matches.
- This actor does not infer clinical conclusions; it exports source data for your analysis.

### Legality and compliance

The actor uses public CMS Provider Data API endpoints. Always use the data according to CMS terms, Apify terms, and your organization's compliance requirements.

Public healthcare data can still be sensitive in context. Review downstream usage, retention, and sharing policies before combining it with other datasets.

### FAQ

#### Does this scrape a website or use a browser?

No. It uses the public CMS Provider Data API directly.

#### Can I search by CMS Certification Number?

Yes. Use the `ccn` input with a full or partial CCN.

#### Why are some fields null?

CMS datasets contain different fields. For example, QIP records include payment and performance fields, while the facility listing includes service flags and stations.

#### Can I get every CMS source column?

Yes. Set `includeRawRecord` to `true` to include the full raw CMS API row.

#### What if my run returns zero records?

Try fewer filters first. For example, use only `state` and `maxItems`, then add city, ZIP, CCN, or name filters.

### Related scrapers

Explore related Automation Lab healthcare data actors:

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

### Support

If you need a field from a CMS dialysis dataset that is not normalized yet, enable `includeRawRecord` first. If you still need help, open an Apify issue with the run URL and desired field.

### Changelog

- Initial version: CMS dialysis facility listing, ICH CAHPS survey, and ESRD QIP Complete Data support.

# Actor input Schema

## `datasetType` (type: `string`):

CMS dialysis dataset to extract. Facility listing is best for addresses, services, ownership, ratings, and quality categories.

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

Maximum matching CMS dialysis records to save.

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

Two-letter state abbreviation, for example CA, TX, NY, or FL.

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

Case-insensitive city/town filter.

## `zipCode` (type: `string`):

ZIP or ZIP prefix filter, for example 900 or 10001.

## `county` (type: `string`):

Case-insensitive county/parish filter.

## `facilityName` (type: `string`):

Case-insensitive dialysis facility name search.

## `ccn` (type: `string`):

Filter by full or partial CMS Certification Number.

## `chainOwned` (type: `string`):

Filter facilities by CMS chain-owned flag.

## `profitStatus` (type: `string`):

Filter by CMS profit/non-profit flag.

## `minStations` (type: `integer`):

Only include facilities with at least this many dialysis stations when the dataset provides station counts.

## `maxStations` (type: `integer`):

Only include facilities with no more than this many dialysis stations when the dataset provides station counts.

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

Add the full raw CMS API row to each output item for analysts who need every CMS field.

## Actor input object example

```json
{
  "datasetType": "facility",
  "maxItems": 20,
  "state": "CA",
  "city": "Los Angeles",
  "includeRawRecord": false
}
```

# 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 = {
    "datasetType": "facility",
    "maxItems": 20,
    "state": "CA",
    "city": "Los Angeles",
    "includeRawRecord": false
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/cms-dialysis-facility-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 = {
    "datasetType": "facility",
    "maxItems": 20,
    "state": "CA",
    "city": "Los Angeles",
    "includeRawRecord": False,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/cms-dialysis-facility-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 '{
  "datasetType": "facility",
  "maxItems": 20,
  "state": "CA",
  "city": "Los Angeles",
  "includeRawRecord": false
}' |
apify call automation-lab/cms-dialysis-facility-compare-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "CMS Dialysis Facility Compare Scraper",
        "description": "Extract CMS dialysis facility listings, ICH CAHPS survey ratings, and ESRD QIP metrics for healthcare benchmarking and network analysis.",
        "version": "0.1",
        "x-build-id": "Gj80U2v4g7Rs5MejQ"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~cms-dialysis-facility-compare-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-cms-dialysis-facility-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-dialysis-facility-compare-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-cms-dialysis-facility-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-dialysis-facility-compare-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-cms-dialysis-facility-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": {
                    "datasetType": {
                        "title": "Dataset",
                        "enum": [
                            "facility",
                            "patientSurvey",
                            "qipComplete"
                        ],
                        "type": "string",
                        "description": "CMS dialysis dataset to extract. Facility listing is best for addresses, services, ownership, ratings, and quality categories.",
                        "default": "facility"
                    },
                    "maxItems": {
                        "title": "Maximum records",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum matching CMS dialysis records to save.",
                        "default": 100
                    },
                    "state": {
                        "title": "State",
                        "minLength": 2,
                        "maxLength": 2,
                        "type": "string",
                        "description": "Two-letter state abbreviation, for example CA, TX, NY, or FL."
                    },
                    "city": {
                        "title": "City contains",
                        "type": "string",
                        "description": "Case-insensitive city/town filter."
                    },
                    "zipCode": {
                        "title": "ZIP code starts with",
                        "type": "string",
                        "description": "ZIP or ZIP prefix filter, for example 900 or 10001."
                    },
                    "county": {
                        "title": "County contains",
                        "type": "string",
                        "description": "Case-insensitive county/parish filter."
                    },
                    "facilityName": {
                        "title": "Facility name contains",
                        "type": "string",
                        "description": "Case-insensitive dialysis facility name search."
                    },
                    "ccn": {
                        "title": "CMS Certification Number (CCN) contains",
                        "type": "string",
                        "description": "Filter by full or partial CMS Certification Number."
                    },
                    "chainOwned": {
                        "title": "Chain owned",
                        "enum": [
                            "Yes",
                            "No"
                        ],
                        "type": "string",
                        "description": "Filter facilities by CMS chain-owned flag."
                    },
                    "profitStatus": {
                        "title": "Profit status",
                        "enum": [
                            "Profit",
                            "Non-profit"
                        ],
                        "type": "string",
                        "description": "Filter by CMS profit/non-profit flag."
                    },
                    "minStations": {
                        "title": "Minimum dialysis stations",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only include facilities with at least this many dialysis stations when the dataset provides station counts."
                    },
                    "maxStations": {
                        "title": "Maximum dialysis stations",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only include facilities with no more than this many dialysis stations when the dataset provides station counts."
                    },
                    "includeRawRecord": {
                        "title": "Include raw CMS record",
                        "type": "boolean",
                        "description": "Add the full raw CMS API row to each output item for analysts who need every CMS field.",
                        "default": false
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
