# FDA PMA Medical Device Approvals Scraper (`automation-lab/fda-pma-medical-device-approvals-scraper`) Actor

Export FDA PMA approvals and supplement records from openFDA for regulatory monitoring, medtech intelligence, and device research.

- **URL**: https://apify.com/automation-lab/fda-pma-medical-device-approvals-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Developer tools
- **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

## FDA PMA Medical Device Approvals Scraper

### What does FDA PMA Medical Device Approvals Scraper do?

FDA PMA Medical Device Approvals Scraper exports public FDA Premarket Approval (PMA) and PMA supplement records from the openFDA device PMA API. It turns FDA approval data into a clean Apify dataset with PMA numbers, applicants, device names, product codes, decision dates, supplement details, and openFDA registration identifiers.

Use it to monitor medical device approvals, enrich regulatory datasets, and build repeatable compliance research workflows.

- ✅ Public openFDA PMA API source
- ✅ Structured Apify dataset output
- ✅ Built for recurring compliance and market intelligence workflows

### Who is it for?

This actor is built for regulatory affairs teams, medtech strategy teams, healthcare investors, compliance analysts, data engineers, and product-intelligence teams that need FDA PMA approval data in a repeatable dataset instead of one-off manual searches.

- Regulatory affairs teams can monitor PMA and supplement activity.
- Competitive intelligence teams can track device makers and product lines.
- Investors can follow approval momentum across medtech categories.
- Data teams can load openFDA PMA records into warehouses and dashboards.

### Who is this FDA PMA scraper for?

Regulatory affairs teams can monitor approval activity. Medtech strategy teams can track competitors and product lines. Investors and analysts can follow device approval momentum. Data teams can normalize openFDA PMA records into warehouses, dashboards, and CRM enrichment pipelines.

- ✅ Public openFDA PMA API source
- ✅ Structured Apify dataset output
- ✅ Built for recurring compliance and market intelligence workflows

### Why use this actor?

The actor wraps the public openFDA PMA endpoint with Apify-friendly inputs, pagination, retries, dataset output, and pay-per-result charging.

You do not need to write API pagination code, remember openFDA query syntax, or manually convert PMA records into CSV or JSON exports.

- ✅ Handles paged openFDA requests
- ✅ Retries transient API failures
- ✅ Saves normalized rows to the default dataset

### What FDA PMA data can you extract?

Each record can include PMA number, supplement number, applicant, address, trade name, generic name, product code, advisory committee, supplement type, supplement reason, expedited review flag, received date, decision date, decision code, docket number, FDA registration numbers, source API URL, and scrape timestamp.

- ✅ Device names
- ✅ FDA identifiers
- ✅ Applicant details
- ✅ Decision and received dates

### How much does it cost to scrape FDA PMA approvals?

This actor uses pay-per-event pricing. You pay a small run start fee and a per-record fee for each FDA PMA approval or supplement record saved. Keep `maxItems` low for quick monitoring jobs, then increase it for full exports or historical backfills.

Pricing is visible on the Apify actor page and may vary by Apify subscription tier.

### How to scrape FDA PMA approval records

1. Open the actor on Apify.
2. Set `maxItems` to the number of PMA records you need.
3. Optionally add structured filters such as applicant, product code, decision date, or PMA number.
4. Run the actor.
5. Download the dataset as JSON, CSV, Excel, XML, or HTML.

### Input options

Use `search` for raw openFDA expressions such as `trade_name:"CARDIO" AND decision_code:APPR`.

Use structured fields for simpler filtering:

- `applicant`
- `productCode`
- `pmaNumber`
- `supplementType`
- `decisionCode`
- `decisionDateFrom`
- `decisionDateTo`
- `receivedDateFrom`
- `receivedDateTo`
- `sortBy`
- `includeOpenFda`

### Output example

A typical item contains:

```json
{
  "pmaNumber": "P220016",
  "supplementNumber": null,
  "applicant": "Hepquant, LLC",
  "tradeName": "HepQuant SHUNT® Liver Diagnostic Test",
  "genericName": "Liver function test",
  "productCode": "SIO",
  "decisionDate": "2026-06-18",
  "decisionCode": "APPR",
  "apiUrl": "https://api.fda.gov/device/pma.json?...",
  "scrapedAt": "2026-07-06T06:04:56.000Z"
}
````

### Dataset fields table

| Field | Description |
|---|---|
| `pmaNumber` | FDA PMA identifier. |
| `supplementNumber` | Supplement identifier when the record is a PMA supplement. |
| `applicant` | Applicant or manufacturer name. |
| `tradeName` | Device trade name. |
| `genericName` | FDA generic device name. |
| `productCode` | FDA product code. |
| `advisoryCommitteeDescription` | FDA advisory committee description. |
| `supplementType` | PMA supplement type. |
| `supplementReason` | Reason for the supplement. |
| `dateReceived` | FDA received date. |
| `decisionDate` | FDA decision date. |
| `decisionCode` | FDA decision code. |
| `docketNumber` | Docket number when present. |
| `registrationNumbers` | openFDA registration numbers. |
| `apiUrl` | Exact openFDA request URL for traceability. |
| `scrapedAt` | Actor scrape timestamp. |

### Tips for better FDA PMA searches

Use `decisionDateFrom` for monitoring recent approvals. Combine `productCode` with `decisionCode: APPR` for focused regulatory analysis. Use applicant names carefully because FDA applicant spelling can vary.

For full historical exports, run by date range chunks instead of requesting everything at once.

### Monitoring workflows

Create a saved task with `decisionDateFrom` set to the beginning of your monitoring period and `maxItems` tuned to expected volume. Run it on a schedule and compare new PMA numbers with previous dataset exports.

Apify webhooks can notify a Slack channel, trigger a warehouse load, or start a downstream enrichment workflow when the actor finishes.

### Integrations

Send FDA PMA records to Google Sheets for lightweight monitoring, to a warehouse for analytics, to Slack for approval alerts, or to CRM/company intelligence tools for medtech account enrichment.

Common workflow patterns:

- FDA PMA approval monitor → Slack alert
- PMA applicant export → CRM enrichment
- Product-code export → market map dashboard
- Monthly approval feed → warehouse table

### API Usage

You can run this actor programmatically with the Apify API, Apify client libraries, or Apify MCP.

#### Node.js API example

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/fda-pma-medical-device-approvals-scraper').call({
  decisionCode: 'APPR',
  decisionDateFrom: '2024-01-01',
  maxItems: 100,
});

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

#### Python API example

```python
from apify_client import ApifyClient
import os

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/fda-pma-medical-device-approvals-scraper').call(run_input={
    'decisionCode': 'APPR',
    'decisionDateFrom': '2024-01-01',
    'maxItems': 100,
})

items = client.dataset(run['defaultDatasetId']).list_items().items
print(items[:3])
```

#### cURL API example

```bash
curl -X POST 'https://api.apify.com/v2/acts/automation-lab~fda-pma-medical-device-approvals-scraper/runs?token=YOUR_APIFY_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"decisionCode":"APPR","decisionDateFrom":"2024-01-01","maxItems":100}'
```

### MCP section

Use the Apify MCP server with Claude Code or Claude Desktop and enable this actor as a tool.

Claude Code setup:

```bash
claude mcp add apify https://mcp.apify.com/?tools=automation-lab/fda-pma-medical-device-approvals-scraper
```

Claude Desktop JSON configuration:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com/?tools=automation-lab/fda-pma-medical-device-approvals-scraper"
    }
  }
}
```

Example prompts:

- "Find approved FDA PMA records for cardiac devices since 2024 and summarize applicants."
- "Export recent FDA PMA supplements for Medtronic and identify product codes."
- "Build a dataset of PMA approvals since 2020 for a medtech market map."

### Data quality notes

openFDA data is public and useful for research, but openFDA warns that results should be treated as unvalidated. Always verify critical regulatory decisions against official FDA sources and source documents.

### Legality and responsible use

The actor uses a public U.S. government API and does not bypass login, paywalls, or anti-bot systems. Respect openFDA terms, use reasonable limits, and avoid high-frequency runs that could stress public infrastructure.

### Troubleshooting

If you get zero results, remove exact applicant or product-code filters and test a broader decision date range.

If an openFDA search expression fails, try structured fields first, then add raw search syntax gradually.

If you need every historical record, split runs by date range to keep each run predictable.

### FAQ

#### Can I export all FDA PMA records?

Yes, but chunk large historical jobs by date ranges and respect `maxItems`.

#### Does this actor need proxies?

No. The data source is the public openFDA API.

#### Does this include every FDA device database?

No. This actor focuses on PMA and supplement records from `device/pma.json`.

#### Can I filter by company?

Yes. Use the `applicant` field, but remember FDA applicant naming can vary across records.

### Related scrapers

For adjacent regulatory and healthcare workflows, check other automation-lab actors on Apify for company enrichment, healthcare provider data, product intelligence, and public-record extraction.

Use this PMA actor as the approval-record component in a broader medtech intelligence stack.

### Additional workflow note

- Use focused date ranges, exact PMA identifiers, or product codes to keep exports fast and affordable.
- Save common filters as Apify tasks for recurring monitoring.
- Connect finished runs to webhooks for notifications and ETL.
- Keep official FDA validation in your review process for regulated decisions.

# Actor input Schema

## `search` (type: `string`):

Optional openFDA search query. Example: trade\_name:"CARDIO" AND decision\_code:APPR. Leave empty to use structured filters only.

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

Maximum number of PMA approval or supplement records to save to the dataset.

## `applicant` (type: `string`):

Exact FDA applicant name filter, such as Medtronic or Abbott. Leave blank for all applicants.

## `productCode` (type: `string`):

Exact FDA product code, for example DZE or MAF.

## `pmaNumber` (type: `string`):

Exact PMA number, such as P150003 or N14226.

## `supplementType` (type: `string`):

Exact supplement type when available, such as 180-Day, Real-Time, Panel Track, or Special.

## `decisionCode` (type: `string`):

FDA decision code. APPR is common for approved records.

## `decisionDateFrom` (type: `string`):

Earliest FDA decision date in YYYY-MM-DD format.

## `decisionDateTo` (type: `string`):

Latest FDA decision date in YYYY-MM-DD format. Leave blank for current records.

## `receivedDateFrom` (type: `string`):

Earliest FDA received date in YYYY-MM-DD format.

## `receivedDateTo` (type: `string`):

Latest FDA received date in YYYY-MM-DD format.

## `sortBy` (type: `string`):

Sort order sent to the openFDA API.

## `includeOpenFda` (type: `boolean`):

Include nested openFDA identifier arrays such as registration numbers when available.

## Actor input object example

```json
{
  "search": "decision_code:APPR",
  "maxItems": 20,
  "decisionCode": "APPR",
  "decisionDateFrom": "2024-01-01",
  "sortBy": "decision_date_desc",
  "includeOpenFda": 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 = {
    "search": "decision_code:APPR",
    "maxItems": 20,
    "decisionCode": "APPR",
    "decisionDateFrom": "2024-01-01",
    "sortBy": "decision_date_desc",
    "includeOpenFda": true
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/fda-pma-medical-device-approvals-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 = {
    "search": "decision_code:APPR",
    "maxItems": 20,
    "decisionCode": "APPR",
    "decisionDateFrom": "2024-01-01",
    "sortBy": "decision_date_desc",
    "includeOpenFda": True,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/fda-pma-medical-device-approvals-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 '{
  "search": "decision_code:APPR",
  "maxItems": 20,
  "decisionCode": "APPR",
  "decisionDateFrom": "2024-01-01",
  "sortBy": "decision_date_desc",
  "includeOpenFda": true
}' |
apify call automation-lab/fda-pma-medical-device-approvals-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "FDA PMA Medical Device Approvals Scraper",
        "description": "Export FDA PMA approvals and supplement records from openFDA for regulatory monitoring, medtech intelligence, and device research.",
        "version": "0.1",
        "x-build-id": "VKb7slVrIPl1e04n5"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~fda-pma-medical-device-approvals-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-fda-pma-medical-device-approvals-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~fda-pma-medical-device-approvals-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-fda-pma-medical-device-approvals-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~fda-pma-medical-device-approvals-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-fda-pma-medical-device-approvals-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": {
                    "search": {
                        "title": "openFDA search expression",
                        "type": "string",
                        "description": "Optional openFDA search query. Example: trade_name:\"CARDIO\" AND decision_code:APPR. Leave empty to use structured filters only."
                    },
                    "maxItems": {
                        "title": "Maximum PMA records",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of PMA approval or supplement records to save to the dataset.",
                        "default": 20
                    },
                    "applicant": {
                        "title": "Applicant / company",
                        "type": "string",
                        "description": "Exact FDA applicant name filter, such as Medtronic or Abbott. Leave blank for all applicants."
                    },
                    "productCode": {
                        "title": "Product code",
                        "type": "string",
                        "description": "Exact FDA product code, for example DZE or MAF."
                    },
                    "pmaNumber": {
                        "title": "PMA number",
                        "type": "string",
                        "description": "Exact PMA number, such as P150003 or N14226."
                    },
                    "supplementType": {
                        "title": "Supplement type",
                        "type": "string",
                        "description": "Exact supplement type when available, such as 180-Day, Real-Time, Panel Track, or Special."
                    },
                    "decisionCode": {
                        "title": "Decision code",
                        "type": "string",
                        "description": "FDA decision code. APPR is common for approved records.",
                        "default": "APPR"
                    },
                    "decisionDateFrom": {
                        "title": "Decision date from",
                        "type": "string",
                        "description": "Earliest FDA decision date in YYYY-MM-DD format."
                    },
                    "decisionDateTo": {
                        "title": "Decision date to",
                        "type": "string",
                        "description": "Latest FDA decision date in YYYY-MM-DD format. Leave blank for current records."
                    },
                    "receivedDateFrom": {
                        "title": "Received date from",
                        "type": "string",
                        "description": "Earliest FDA received date in YYYY-MM-DD format."
                    },
                    "receivedDateTo": {
                        "title": "Received date to",
                        "type": "string",
                        "description": "Latest FDA received date in YYYY-MM-DD format."
                    },
                    "sortBy": {
                        "title": "Sort records by",
                        "enum": [
                            "decision_date_desc",
                            "decision_date_asc",
                            "date_received_desc",
                            "date_received_asc"
                        ],
                        "type": "string",
                        "description": "Sort order sent to the openFDA API.",
                        "default": "decision_date_desc"
                    },
                    "includeOpenFda": {
                        "title": "Include openFDA identifiers",
                        "type": "boolean",
                        "description": "Include nested openFDA identifier arrays such as registration numbers when available.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
