# 💊 FDA Drug Shortages Monitor — Current & Resolved (`nexgendata/fda-drug-shortages-monitor`) Actor

Monitor current & resolved FDA (CDER) drug shortages with drug, manufacturer, status, availability, category and dates. For hospital pharmacy, GPOs, 503B compounders, and pharma supply chain.

- **URL**: https://apify.com/nexgendata/fda-drug-shortages-monitor.md
- **Developed by:** [NexGenData](https://apify.com/nexgendata) (community)
- **Categories:** Business
- **Stats:** 3 total users, 1 monthly users, 0.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.

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 Drug Shortages Monitor — Current & Resolved

**Track every drug on the FDA's official shortage list — current and resolved — with manufacturer, status, availability, therapeutic category, dosage form, and update dates. Pay-per-result JSON, $0.10 per record. No IQVIA contract, no Cortellis seat, no enterprise data subscription.**

Drug shortages are an operational emergency for anyone who dispenses, compounds, sources, or insures medications. When a sterile injectable goes short, hospital pharmacies scramble for substitutes, 503B compounders spin up production, GPOs renegotiate allocations, and supply-chain teams race to qualify a second source — and every hour of delay has clinical consequences. The FDA's CDER Drug Shortages database is the authoritative public record of which products are short, why, and whether they've recovered, but it lives behind a search-one-drug-at-a-time web UI that is impossible to monitor at scale. This actor turns that database into a clean, filterable, structured feed you can poll on a schedule, diff against yesterday, and pipe straight into your formulary, ERP, or alerting stack.

### Why use this

The commercial drug-shortage intelligence market is dominated by a handful of expensive enterprise platforms — IQVIA, Clarivate Cortellis, and specialty supply-chain vendors — that bundle shortage data into six-figure annual contracts and lock it behind per-seat logins you cannot pipe into your own pharmacy system. The underlying source they all reference is the same public FDA CDER list this actor reads. The problem is never access to the FDA data; it is turning a one-drug-at-a-time web search into a monitored, diff-able feed.

This actor does exactly that. It pulls the full current-and-resolved shortage record set, lets you filter by generic name, manufacturer, therapeutic category, dosage form, and status, and returns each shortage as a structured row with the fields that actually drive a decision — what's short, who makes it, whether it's available, and when the record last changed. Run it daily and dedupe on `genericName` + `companyName` and you have a live shortage-monitoring system for cents per run instead of a six-figure platform.

### What you get

Every record is structured JSON with the fields below, populated wherever the FDA CDER source provides them:

- `genericName` — the drug's generic (non-proprietary) name, e.g. "Amoxicillin"
- `companyName` — the manufacturer / labeler reporting the shortage
- `status` — the FDA-reported shortage status text (e.g. "Currently in Shortage", "Resolved")
- `availability` — the FDA's availability note describing what supply exists and any allocation detail
- `therapeuticCategory` — the drug's therapeutic class (e.g. "Oncology", "Anesthesia")
- `dosageForm` — the formulation affected (e.g. "Injection", "Tablet")
- `updateDate` — the date the FDA last updated this shortage record

The schema is stable across runs, so you can append straight to Snowflake, BigQuery, Postgres, or your pharmacy data warehouse without re-mapping each refresh.

### Use cases

- **Hospital pharmacy formulary monitoring** — Run daily with `onlyCurrentShortages` on, diff against yesterday's pull, and auto-alert your P&T committee the moment a formulary drug enters or exits shortage so substitution protocols and conservation measures kick in immediately.
- **503B outsourcing-facility demand signal** — Filter by `dosageForm=Injection` and `therapeuticCategory` to spot newly-short sterile injectables that represent a compounding-demand opportunity, and watch `status` flip to "Resolved" to know when to wind a batch down.
- **GPO and procurement allocation** — Track shortages across your contracted manufacturers (`companyName` filter) to anticipate allocation, pre-position alternate-vendor orders, and brief member hospitals before the shortage bites.
- **Pharma supply-chain and competitive intelligence** — Monitor competitors' products entering shortage to time your own launch, marketing, or capacity decisions; a competitor's anesthesia injectable going short is a market-share opening.
- **Payer and PBM coverage management** — Feed current shortages into utilization-management logic so prior-auth and step-therapy rules account for which preferred agents are actually obtainable.
- **Clinical decision-support enrichment** — Surface real-time shortage status inside EHR ordering so prescribers see availability at the point of care.
- **Health-policy and academic research** — Pull the full current-and-resolved history (set a high `maxResults`, leave `onlyCurrentShortages` off) for longitudinal analysis of shortage frequency, duration, and therapeutic-class concentration.

### Sample output

```json
{
  "genericName": "Amoxicillin Oral Suspension",
  "companyName": "Aurobindo Pharma USA, Inc.",
  "status": "Currently in Shortage",
  "availability": "Some presentations available; others on back order. Estimated recovery dates vary by presentation.",
  "therapeuticCategory": "Anti-Infective",
  "dosageForm": "Oral Suspension",
  "updateDate": "2026-06-18"
}
````

### Input parameters

| Parameter | Label | Description |
| --- | --- | --- |
| `genericName` | Generic name | Filter by drug generic name (e.g. `amoxicillin`). |
| `companyName` | Company | Filter by manufacturer / company name. |
| `therapeuticCategory` | Therapeutic category | Filter by therapeutic class (e.g. `Oncology`, `Anesthesia`). |
| `dosageForm` | Dosage form | Filter by formulation (e.g. `Injection`, `Tablet`). |
| `status` | Status contains | Filter by status text (e.g. `Current`, `Resolved`). |
| `onlyCurrentShortages` | Only current shortages | Exclude resolved / discontinued records. |
| `maxResults` | Max results | Maximum number of records to return. |

### How to use

#### Python (apify-client)

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_TOKEN")

run = client.actor("nexgendata/fda-drug-shortages-monitor").call(run_input={
    "onlyCurrentShortages": True,
    "dosageForm": "Injection",
    "maxResults": 500,
})

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["genericName"], item["companyName"], item["status"], item["updateDate"])
```

#### cURL

```bash
curl -X POST "https://api.apify.com/v2/acts/nexgendata~fda-drug-shortages-monitor/run-sync-get-dataset-items?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "onlyCurrentShortages": true,
    "dosageForm": "Injection",
    "maxResults": 500
  }'
```

Schedule it daily via Apify's built-in scheduler and dedupe on `genericName` + `companyName` into your warehouse. Diff consecutive runs to detect new shortages and resolutions, and wire a webhook to push a Slack or n8n alert whenever a watched drug changes status.

### Pricing

This actor runs on Apify's **pay-per-event (PPE)** model — you pay only for results, not run-time:

- **$0.10 per shortage record** pushed to your dataset
- A negligible per-actor-start charge

No subscriptions, no seat licences, no per-CPU-second billing.

#### Worked cost example

A daily monitoring run pulling the full current-shortage list — typically around 100-150 active records:

- 130 records × $0.10 = **$13.00**
- plus one negligible actor-start charge

So roughly **$13 per full daily current-shortage pull**, all-in. If you only watch a focused slice — say injectable oncology drugs, returning 20 records — that run costs about **$2.00**. Compare that to IQVIA / Cortellis enterprise shortage modules that start in the high five to six figures per year.

#### Why pay-per-event beats time-based pricing

- **Predictable** — cost equals record count, known before the run.
- **Failure-safe** — if the FDA page changes and a run returns 0 rows, you pay 0.
- **Easy to attribute** — 1 shortage record = 1 unit of cost, so per-facility or per-service-line accounting is trivial.

### How this compares to IQVIA / Cortellis

| Capability | IQVIA / Clarivate Cortellis | FDA Drug Shortages Monitor (this actor) |
| --- | --- | --- |
| Shortage data source | FDA + proprietary enrichment | Official FDA CDER shortage database |
| Coverage | Global, enrichment-heavy | US FDA CDER current & resolved shortages |
| Annual cost | High five to six figures / enterprise contract | Pay-per-record, no subscription |
| Programmatic access | Enterprise API, seat-locked | Apify REST API + webhooks, no seat lock |
| Pipe into your pharmacy / ERP system | Restricted by contract | Native JSON / JSONL / CSV export |

If you need global commercial-availability forecasting, NDC-level supply analytics, and proprietary manufacturing-disruption intelligence, the enterprise platforms still offer more. But if your workflow is monitoring the authoritative FDA shortage list and pushing status changes into your formulary, compounding, or procurement process, this actor delivers the same source data at a fraction of the cost with full programmatic access.

### FAQ

**Q: How current is the data?**

A: As current as the FDA CDER Drug Shortages database, which the FDA updates as manufacturers report changes. The `updateDate` field on every record tells you exactly when the FDA last touched that shortage entry.

**Q: What's the difference between this and the FDA drug-recall list?**

A: Shortages are supply-availability problems (a drug is hard to get); recalls are safety/quality removals of specific lots. They're separate FDA programs — pair this actor with a recall monitor for full supply-and-safety coverage.

**Q: Can I get only the drugs currently in shortage?**

A: Yes — set `onlyCurrentShortages` to true to exclude resolved and discontinued records and return only the active shortage list.

**Q: Does this cover biologics and vaccines?**

A: This actor reads the CDER (drugs) shortage database. Biologics regulated by CBER follow a separate FDA process and are not included here.

**Q: How do I detect newly-added or newly-resolved shortages?**

A: Run on a daily schedule and diff consecutive datasets on `genericName` + `companyName`; a record appearing or its `status` changing flags a new shortage or a resolution.

**Q: What output formats are supported?**

A: JSON, JSONL, CSV, and Excel via Apify's dataset export, plus webhook delivery.

### Schema stability & versioning

This actor follows NexGenData's **additive-only schema** contract:

- New fields may be **added** at any time — they appear as new JSON keys and default to `null` for older runs.
- Existing fields are **never renamed or removed** without a major-version bump and an advance changelog notice.
- Field semantics (date formats, the meaning of `status` and `availability`) are **never silently changed** — if a change is needed, we add a new field and keep the old one for at least 90 days.

You can build production formulary and supply-chain pipelines on this actor without an unannounced change breaking your ETL.

### Compliance & legal

- The actor reads the **public, unauthenticated FDA CDER Drug Shortages database** — the same pages any browser can open, with no login.
- NexGenData is **not affiliated with, endorsed by, or sponsored by** the U.S. Food and Drug Administration. "FDA" and "CDER" are designations of the U.S. government.
- Shortage status, availability notes, and recovery estimates are the FDA's published values; for any clinical or sourcing decision, **verify against the primary FDA record** referenced by each entry.
- This data supports operational and research use; it is not medical advice and must not be the sole basis for patient-level treatment decisions.
- You are responsible for ensuring downstream use complies with applicable healthcare data and procurement regulations.

### Related NexGenData actors

Part of NexGenData's **Pharma / Health** intelligence suite — pair this actor with:

- [FDA Orange Book Drug Patents](https://apify.com/nexgendata/fda-orange-book-drug-patents?fpr=2ayu9b) — small-molecule patent & exclusivity data
- [FDA Purple Book Biologics & Biosimilars](https://apify.com/nexgendata/fda-purple-book-biologics-biosimilars?fpr=2ayu9b) — licensed biologics and biosimilar reference products
- [FDA Recall Monitor](https://apify.com/nexgendata/fda-recall-monitor?fpr=2ayu9b) — drug, device, and food recall events
- [FDA Drug Approvals](https://apify.com/nexgendata/fda-drug-approvals?fpr=2ayu9b) — new and supplemental drug approvals
- [Clinical Trials Tracker](https://apify.com/nexgendata/clinical-trials-tracker?fpr=2ayu9b) — registered clinical trials and status
- [CMS Hospital Compare](https://apify.com/nexgendata/cms-hospital-compare?fpr=2ayu9b) — hospital quality and performance metrics

Browse the full catalog of 200+ buyer-intent actors at **https://apify.com/nexgendata?fpr=2ayu9b**.

# Actor input Schema

## `genericName` (type: `string`):

Filter by drug generic name (e.g. 'amoxicillin').

## `companyName` (type: `string`):

Filter by manufacturer/company name.

## `therapeuticCategory` (type: `string`):

e.g. 'Oncology', 'Anesthesia'.

## `dosageForm` (type: `string`):

e.g. 'Injection', 'Tablet'.

## `status` (type: `string`):

Filter by status text (e.g. 'Current', 'Resolved').

## `onlyCurrentShortages` (type: `boolean`):

Exclude resolved/discontinued records.

## `maxResults` (type: `integer`):

Max records to return.

## Actor input object example

```json
{
  "onlyCurrentShortages": false,
  "maxResults": 2000
}
```

# 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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("nexgendata/fda-drug-shortages-monitor").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 = {}

# Run the Actor and wait for it to finish
run = client.actor("nexgendata/fda-drug-shortages-monitor").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 '{}' |
apify call nexgendata/fda-drug-shortages-monitor --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=nexgendata/fda-drug-shortages-monitor",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "💊 FDA Drug Shortages Monitor — Current & Resolved",
        "description": "Monitor current & resolved FDA (CDER) drug shortages with drug, manufacturer, status, availability, category and dates. For hospital pharmacy, GPOs, 503B compounders, and pharma supply chain.",
        "version": "0.0",
        "x-build-id": "sdnsE5sv2E2jH5ly6"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/nexgendata~fda-drug-shortages-monitor/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-nexgendata-fda-drug-shortages-monitor",
                "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/nexgendata~fda-drug-shortages-monitor/runs": {
            "post": {
                "operationId": "runs-sync-nexgendata-fda-drug-shortages-monitor",
                "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/nexgendata~fda-drug-shortages-monitor/run-sync": {
            "post": {
                "operationId": "run-sync-nexgendata-fda-drug-shortages-monitor",
                "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": {
                    "genericName": {
                        "title": "Generic name",
                        "type": "string",
                        "description": "Filter by drug generic name (e.g. 'amoxicillin')."
                    },
                    "companyName": {
                        "title": "Company",
                        "type": "string",
                        "description": "Filter by manufacturer/company name."
                    },
                    "therapeuticCategory": {
                        "title": "Therapeutic category",
                        "type": "string",
                        "description": "e.g. 'Oncology', 'Anesthesia'."
                    },
                    "dosageForm": {
                        "title": "Dosage form",
                        "type": "string",
                        "description": "e.g. 'Injection', 'Tablet'."
                    },
                    "status": {
                        "title": "Status contains",
                        "type": "string",
                        "description": "Filter by status text (e.g. 'Current', 'Resolved')."
                    },
                    "onlyCurrentShortages": {
                        "title": "Only current shortages",
                        "type": "boolean",
                        "description": "Exclude resolved/discontinued records.",
                        "default": false
                    },
                    "maxResults": {
                        "title": "Max results",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Max records to return.",
                        "default": 2000
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
