# CMS Open Payments Crawler - Physician Pharma Payment Data (`jungle_synthesizer/openpayments-cms-crawler`) Actor

Crawl physician payment records from the CMS Open Payments database (Sunshine Act). Extract payments from pharma and device companies to physicians. Filter by state, specialty, payer, payment type, year, and minimum amount.

- **URL**: https://apify.com/jungle\_synthesizer/openpayments-cms-crawler.md
- **Developed by:** [BowTiedRaccoon](https://apify.com/jungle_synthesizer) (community)
- **Categories:** Business, Lead generation, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN 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.

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 Open Payments Crawler - Physician Pharma Payment Data

Extract physician payment records from the [CMS Open Payments database](https://openpaymentsdata.cms.gov/) (Sunshine Act). Collect payments from pharmaceutical and medical device companies to physicians — including dollar amounts, payment types, payer companies, associated products, and physician details across all 50 U.S. states.

### CMS Open Payments Crawler Features

- Query three datasets: **General Payments** (consulting, food, travel, speaking fees), **Research Payments** (research funding), and **Physician Ownership** (ownership/investment interests)
- Filter by state, physician specialty, payer company name, payment type, and minimum dollar amount
- Covers program years 2018 through 2024 — over 15 million General Payment records per year
- Reads the official CMS DKAN API directly — structured JSON, no HTML parsing, no proxy required
- Normalizes field names across all three dataset types into a unified output schema
- Pay-per-event pricing at roughly **$0.001 per record**

### Who Uses CMS Open Payments Data?

- **Healthcare compliance teams** — monitor pharma payments to physicians for conflict-of-interest audits and Sunshine Act reporting
- **Pharmaceutical market researchers** — analyze payment patterns by specialty, state, or company to understand industry spending trends
- **Journalists and watchdog organizations** — investigate financial relationships between drug makers and prescribing physicians
- **Medical device sales teams** — identify which physicians receive consulting fees, speaking engagements, or research funding from competitors
- **Academic researchers** — study the correlation between industry payments and prescribing behavior at scale
- **Legal professionals** — gather payment evidence for litigation involving pharmaceutical marketing practices

### How CMS Open Payments Crawler Works

1. You select a dataset type (General, Research, or Ownership) and a program year.
2. The crawler queries the CMS DKAN API with your filters — state, specialty, payer name, payment type — using server-side conditions where possible.
3. Results are paginated at 500 records per request, transformed into a clean unified schema, and filtered client-side for minimum payment amount.
4. Each record includes the physician name, NPI, specialty, payer company, dollar amount, payment type, associated product, and a unique CMS record ID.

### Input

#### Basic: Get general payments for a state

```json
{
  "datasetType": "general",
  "programYear": "2024",
  "states": ["CA"],
  "maxItems": 100
}
````

#### Filter by payer company

```json
{
  "datasetType": "general",
  "programYear": "2023",
  "payerName": "Pfizer",
  "states": ["NY"],
  "maxItems": 50
}
```

#### Research payments by specialty

```json
{
  "datasetType": "research",
  "programYear": "2023",
  "physicianSpecialty": "Allopathic & Osteopathic Physicians|Internal Medicine",
  "maxItems": 200
}
```

#### High-value consulting fees

```json
{
  "datasetType": "general",
  "programYear": "2024",
  "paymentType": "Consulting Fee",
  "minPaymentAmount": 1000,
  "maxItems": 50
}
```

#### Input Parameters

| Field | Type | Default | Description |
|-------|------|---------|-------------|
| `programYear` | string | `"2024"` | Program year: 2018 through 2024 |
| `datasetType` | string | `"general"` | Dataset: `general` (payments), `research` (funding), or `ownership` (investment interests) |
| `states` | string\[] | `[]` | Filter by recipient state (two-letter codes). Leave empty for all states. |
| `paymentType` | string | `""` | Filter by payment type: Consulting Fee, Food and Beverage, Travel and Lodging, Education, Gift, Honoraria, Grant, and others |
| `payerName` | string | `""` | Search by pharmaceutical or device company name. Supports partial match. |
| `physicianName` | string | `""` | Search by physician last name. Supports partial match. |
| `physicianSpecialty` | string | `""` | Filter by specialty: Internal Medicine, Orthopedic Surgery, Dermatology, Family Medicine, and 11 others |
| `minPaymentAmount` | number | `0` | Return only payments at or above this dollar amount |
| `maxItems` | integer | `100` | Maximum number of records to return |
| `proxyConfiguration` | object | `{}` | Proxy settings. Not required — this is a government API with no geo-restrictions. |

### CMS Open Payments Crawler Output Fields

#### Example Output

```json
{
  "physician_name": "JOHN A SMITH MD",
  "physician_npi": "1234567890",
  "physician_specialty": "Allopathic & Osteopathic Physicians|Internal Medicine",
  "recipient_city": "LOS ANGELES",
  "recipient_state": "CA",
  "payer_name": "Pfizer Inc.",
  "payment_amount": 2450.00,
  "payment_type": "Consulting Fee",
  "payment_date": "06/15/2024",
  "product_name": "ELIQUIS",
  "product_type": "Drug",
  "teaching_hospital_name": "",
  "program_year": 2024,
  "payment_count": 1,
  "record_id": "1058723"
}
```

#### Field Reference

| Field | Type | Description |
|-------|------|-------------|
| `physician_name` | string | Full name of the physician or covered recipient |
| `physician_npi` | string | National Provider Identifier (10-digit unique physician ID) |
| `physician_specialty` | string | Medical specialty (e.g., Internal Medicine, Orthopedic Surgery) |
| `recipient_city` | string | City of the covered recipient |
| `recipient_state` | string | State abbreviation of the covered recipient |
| `payer_name` | string | Pharmaceutical or medical device company making the payment |
| `payment_amount` | number | Dollar amount of the payment or transfer of value |
| `payment_type` | string | Nature of payment: consulting, food/beverage, travel, research, royalty, ownership, etc. |
| `payment_date` | string | Date the payment was made (MM/DD/YYYY) |
| `product_name` | string | Associated drug, device, or biological product name |
| `product_type` | string | Product category: Drug, Device, Biological, or Medical Supply |
| `teaching_hospital_name` | string | Teaching hospital name, if the payment was made to one |
| `program_year` | number | Reporting year of the payment disclosure |
| `payment_count` | number | Number of individual payments aggregated in this record |
| `record_id` | string | Unique record identifier from CMS |

### CMS Open Payments Data Coverage

| Dataset | 2024 Records | 2023 Records | Description |
|---------|-------------|-------------|-------------|
| General Payments | 15.4M | 14.7M | Food, travel, consulting, speaking, gifts, royalties |
| Research Payments | 757K | ~750K | Research funding from pharma/device companies |
| Physician Ownership | 4.6K | ~4K | Ownership and investment interests |

Data is published annually by CMS for the previous reporting period. The crawler covers 2018 through 2024.

### FAQ

**What is the CMS Open Payments database?**
The CMS Open Payments database tracks payments from pharmaceutical and medical device companies to physicians and teaching hospitals, as mandated by the Physician Payments Sunshine Act (part of the Affordable Care Act). CMS publishes this data annually at [openpaymentsdata.cms.gov](https://openpaymentsdata.cms.gov/).

**How much does CMS Open Payments Crawler cost to run?**
Roughly $0.001 per record on pay-per-event pricing. Extracting 10,000 records costs about $10. The actor runs on 256 MB of memory by default and processes approximately 10,000 records per minute.

**Do I need proxies?**
No. The CMS Open Payments API is a public government service with no authentication, no CAPTCHA, and no geo-restrictions. Proxy support is disabled by default.

**What is the difference between the three dataset types?**
General Payments cover direct transfers of value — consulting fees, food, travel, speaking engagements, gifts, and royalties. Research Payments cover funding for clinical research. Physician Ownership covers ownership stakes and investment interests that physicians hold in pharmaceutical or device companies.

**Can I search by company name?**
Yes. The `payerName` field supports partial match, so searching "Pfizer" returns payments from any entity with "Pfizer" in the name. Combine with state and specialty filters to narrow results.

**How current is the data?**
CMS publishes Open Payments data annually, typically in January for the previous reporting year. Program year 2024 is the most recent available dataset.

**Can I get data for a specific physician?**
Use the `physicianName` field to search by last name (partial match). Combine with `states` or `physicianSpecialty` to narrow results when the name is common.

### Need More Features?

Need custom fields, filters, or a different healthcare data source? [File an issue](https://console.apify.com/actors/issues) or get in touch.

# Actor input Schema

## `sp_intended_usage` (type: `string`):

Please describe how you plan to use the data extracted by this crawler.

## `sp_improvement_suggestions` (type: `string`):

Provide any feedback or suggestions for improvements.

## `sp_contact` (type: `string`):

Provide your email address so we can get in touch with you.

## `programYear` (type: `string`):

Filter by program year. Defaults to the most recent available year (2024).

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

Select which Open Payments dataset to query. General Payments covers food, travel, consulting, speaking fees. Research Payments covers research funding. Physician Ownership covers ownership/investment interests.

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

Filter by recipient state. Leave empty for all states.

## `paymentType` (type: `string`):

Filter by nature of payment or transfer of value.

## `payerName` (type: `string`):

Search by pharmaceutical or medical device company name. Supports partial match.

## `physicianName` (type: `string`):

Search by physician last name. Supports partial match.

## `physicianSpecialty` (type: `string`):

Filter by physician specialty.

## `minPaymentAmount` (type: `number`):

Filter for payments at or above this dollar amount. Applied client-side after fetching records.

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

Maximum number of payment records to return.

## `proxyConfiguration` (type: `object`):

Select proxies. The CMS Open Payments API is a government service and typically does not require proxies.

## Actor input object example

```json
{
  "sp_intended_usage": "Describe your intended use...",
  "sp_improvement_suggestions": "Share your suggestions here...",
  "sp_contact": "Share your email here...",
  "programYear": "2024",
  "datasetType": "general",
  "states": [],
  "minPaymentAmount": 0,
  "maxItems": 100,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `results` (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 = {
    "sp_intended_usage": "Describe your intended use...",
    "sp_improvement_suggestions": "Share your suggestions here...",
    "sp_contact": "Share your email here...",
    "programYear": "2024",
    "datasetType": "general",
    "states": [],
    "paymentType": "",
    "payerName": "",
    "physicianName": "",
    "physicianSpecialty": "",
    "minPaymentAmount": 0,
    "maxItems": 100,
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("jungle_synthesizer/openpayments-cms-crawler").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 = {
    "sp_intended_usage": "Describe your intended use...",
    "sp_improvement_suggestions": "Share your suggestions here...",
    "sp_contact": "Share your email here...",
    "programYear": "2024",
    "datasetType": "general",
    "states": [],
    "paymentType": "",
    "payerName": "",
    "physicianName": "",
    "physicianSpecialty": "",
    "minPaymentAmount": 0,
    "maxItems": 100,
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("jungle_synthesizer/openpayments-cms-crawler").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 '{
  "sp_intended_usage": "Describe your intended use...",
  "sp_improvement_suggestions": "Share your suggestions here...",
  "sp_contact": "Share your email here...",
  "programYear": "2024",
  "datasetType": "general",
  "states": [],
  "paymentType": "",
  "payerName": "",
  "physicianName": "",
  "physicianSpecialty": "",
  "minPaymentAmount": 0,
  "maxItems": 100,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call jungle_synthesizer/openpayments-cms-crawler --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=jungle_synthesizer/openpayments-cms-crawler",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "CMS Open Payments Crawler - Physician Pharma Payment Data",
        "description": "Crawl physician payment records from the CMS Open Payments database (Sunshine Act). Extract payments from pharma and device companies to physicians. Filter by state, specialty, payer, payment type, year, and minimum amount.",
        "version": "1.0",
        "x-build-id": "Z7tVI2a0GNqTrjh7P"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/jungle_synthesizer~openpayments-cms-crawler/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-jungle_synthesizer-openpayments-cms-crawler",
                "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/jungle_synthesizer~openpayments-cms-crawler/runs": {
            "post": {
                "operationId": "runs-sync-jungle_synthesizer-openpayments-cms-crawler",
                "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/jungle_synthesizer~openpayments-cms-crawler/run-sync": {
            "post": {
                "operationId": "run-sync-jungle_synthesizer-openpayments-cms-crawler",
                "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",
                "required": [
                    "sp_intended_usage",
                    "sp_improvement_suggestions"
                ],
                "properties": {
                    "sp_intended_usage": {
                        "title": "What is the intended usage of this data?",
                        "minLength": 1,
                        "type": "string",
                        "description": "Please describe how you plan to use the data extracted by this crawler."
                    },
                    "sp_improvement_suggestions": {
                        "title": "How can we improve this crawler for you?",
                        "minLength": 1,
                        "type": "string",
                        "description": "Provide any feedback or suggestions for improvements."
                    },
                    "sp_contact": {
                        "title": "Contact Email",
                        "minLength": 1,
                        "type": "string",
                        "description": "Provide your email address so we can get in touch with you."
                    },
                    "programYear": {
                        "title": "Program Year",
                        "enum": [
                            "2024",
                            "2023",
                            "2022",
                            "2021",
                            "2020",
                            "2019",
                            "2018"
                        ],
                        "type": "string",
                        "description": "Filter by program year. Defaults to the most recent available year (2024).",
                        "default": "2024"
                    },
                    "datasetType": {
                        "title": "Dataset Type",
                        "enum": [
                            "general",
                            "research",
                            "ownership"
                        ],
                        "type": "string",
                        "description": "Select which Open Payments dataset to query. General Payments covers food, travel, consulting, speaking fees. Research Payments covers research funding. Physician Ownership covers ownership/investment interests.",
                        "default": "general"
                    },
                    "states": {
                        "title": "Recipient State",
                        "type": "array",
                        "description": "Filter by recipient state. Leave empty for all states.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "AL",
                                "AK",
                                "AZ",
                                "AR",
                                "CA",
                                "CO",
                                "CT",
                                "DE",
                                "DC",
                                "FL",
                                "GA",
                                "HI",
                                "ID",
                                "IL",
                                "IN",
                                "IA",
                                "KS",
                                "KY",
                                "LA",
                                "ME",
                                "MD",
                                "MA",
                                "MI",
                                "MN",
                                "MS",
                                "MO",
                                "MT",
                                "NE",
                                "NV",
                                "NH",
                                "NJ",
                                "NM",
                                "NY",
                                "NC",
                                "ND",
                                "OH",
                                "OK",
                                "OR",
                                "PA",
                                "RI",
                                "SC",
                                "SD",
                                "TN",
                                "TX",
                                "UT",
                                "VT",
                                "VA",
                                "WA",
                                "WV",
                                "WI",
                                "WY"
                            ],
                            "enumTitles": [
                                "Alabama",
                                "Alaska",
                                "Arizona",
                                "Arkansas",
                                "California",
                                "Colorado",
                                "Connecticut",
                                "Delaware",
                                "District of Columbia",
                                "Florida",
                                "Georgia",
                                "Hawaii",
                                "Idaho",
                                "Illinois",
                                "Indiana",
                                "Iowa",
                                "Kansas",
                                "Kentucky",
                                "Louisiana",
                                "Maine",
                                "Maryland",
                                "Massachusetts",
                                "Michigan",
                                "Minnesota",
                                "Mississippi",
                                "Missouri",
                                "Montana",
                                "Nebraska",
                                "Nevada",
                                "New Hampshire",
                                "New Jersey",
                                "New Mexico",
                                "New York",
                                "North Carolina",
                                "North Dakota",
                                "Ohio",
                                "Oklahoma",
                                "Oregon",
                                "Pennsylvania",
                                "Rhode Island",
                                "South Carolina",
                                "South Dakota",
                                "Tennessee",
                                "Texas",
                                "Utah",
                                "Vermont",
                                "Virginia",
                                "Washington",
                                "West Virginia",
                                "Wisconsin",
                                "Wyoming"
                            ]
                        }
                    },
                    "paymentType": {
                        "title": "Payment Type",
                        "enum": [
                            "",
                            "Consulting Fee",
                            "Compensation for services other than consulting, including serving as faculty or as a speaker at a venue other than a continuing education program",
                            "Food and Beverage",
                            "Travel and Lodging",
                            "Education",
                            "Entertainment",
                            "Gift",
                            "Honoraria",
                            "Charitable Contribution",
                            "Royalty or License",
                            "Current or prospective ownership or investment interest",
                            "Space rental or facility fees (payments by a third party)",
                            "Grant"
                        ],
                        "type": "string",
                        "description": "Filter by nature of payment or transfer of value."
                    },
                    "payerName": {
                        "title": "Payer (Company) Name",
                        "type": "string",
                        "description": "Search by pharmaceutical or medical device company name. Supports partial match."
                    },
                    "physicianName": {
                        "title": "Physician Name",
                        "type": "string",
                        "description": "Search by physician last name. Supports partial match."
                    },
                    "physicianSpecialty": {
                        "title": "Physician Specialty",
                        "enum": [
                            "",
                            "Allopathic & Osteopathic Physicians|Internal Medicine",
                            "Allopathic & Osteopathic Physicians|Family Medicine",
                            "Allopathic & Osteopathic Physicians|Psychiatry & Neurology",
                            "Allopathic & Osteopathic Physicians|Orthopedic Surgery",
                            "Allopathic & Osteopathic Physicians|Anesthesiology",
                            "Allopathic & Osteopathic Physicians|Surgery",
                            "Allopathic & Osteopathic Physicians|Radiology",
                            "Allopathic & Osteopathic Physicians|Emergency Medicine",
                            "Allopathic & Osteopathic Physicians|Obstetrics & Gynecology",
                            "Allopathic & Osteopathic Physicians|Ophthalmology",
                            "Allopathic & Osteopathic Physicians|Dermatology",
                            "Allopathic & Osteopathic Physicians|Urology",
                            "Allopathic & Osteopathic Physicians|Pathology",
                            "Dental Providers|Dentist",
                            "Physician Assistants & Advanced Practice Nursing Providers|Nurse Practitioner"
                        ],
                        "type": "string",
                        "description": "Filter by physician specialty."
                    },
                    "minPaymentAmount": {
                        "title": "Minimum Payment Amount ($)",
                        "type": "number",
                        "description": "Filter for payments at or above this dollar amount. Applied client-side after fetching records.",
                        "default": 0
                    },
                    "maxItems": {
                        "title": "Max Items",
                        "type": "integer",
                        "description": "Maximum number of payment records to return.",
                        "default": 100
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Select proxies. The CMS Open Payments API is a government service and typically does not require proxies."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
