# openFDA Drug & Device Data Crawler (`jungle_synthesizer/openfda-drug-crawler`) Actor

Crawl FDA drug adverse events, recalls, labels, NDC codes, device events, and 510(k) clearances from the openFDA API. Filter by drug name, manufacturer, date range, and severity. 20M+ adverse event reports available.

- **URL**: https://apify.com/jungle\_synthesizer/openfda-drug-crawler.md
- **Developed by:** [BowTiedRaccoon](https://apify.com/jungle_synthesizer) (community)
- **Categories:** Business, Lead generation, Other
- **Stats:** 2 total users, 2 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

## openFDA Drug & Device Data Crawler

Query the FDA's public API for drug adverse events, recalls, drug labels, NDC codes, device events, and 510(k) clearances. Eight datasets, one actor, no authentication required.

### Features

- **Queries all eight openFDA endpoints** — drug adverse events (FAERS), drug recalls, drug labels (SPL), drug approvals (Drugs@FDA), NDC directory, device adverse events (MAUDE), 510(k) clearances, and device recalls
- **Filters by drug name, manufacturer, and date range** — field mapping is handled per-endpoint automatically
- **Limits adverse event results to serious reports** — death, hospitalization, life-threatening outcomes, and permanent disability
- **Filters recalls by severity class** — Class I (risk of death), Class II (moderate), or Class III (least severe)
- **Paginates past the 25,000-record API cap** — uses date-range windowing for large result sets
- **Decodes numeric codes into readable values** — drug characterization, sex, reaction outcome, and reporter qualification are translated from FDA codes to plain text
- **Returns a unified schema across all endpoints** — adverse event fields and recall fields coexist in each record; unused fields are empty rather than absent

### Use Cases

#### Who is pulling this data and why?

- **Pharmacovigilance analysts** monitoring adverse event signals for a specific drug or drug class
- **Compliance teams** tracking open recalls by class and distribution region before a product launch
- **Healthcare data engineers** building pipelines that enrich internal drug databases with FAERS data
- **Medical device researchers** screening 510(k) clearance history for a competitor's device portfolio
- **Insurance underwriters** assessing liability exposure tied to Class I recall history for a manufacturer
- **Academic researchers** studying patient demographics and reaction outcomes across a drug category

### How It Works

1. Select an FDA dataset endpoint and apply filters (drug name, manufacturer, date range, severity).
2. The actor constructs the openFDA `search=` query, paginates through results in batches of 100, and respects the 240 req/min rate limit with a 250ms delay between requests.
3. Raw API records are decoded — numeric sex/outcome/characterization codes become human-readable strings, dates are normalized to `YYYY-MM-DD`.
4. Each record is written to the Apify dataset in the unified schema. Adverse event fields are populated for `drug/event` and `device/event` runs; recall fields are populated for enforcement and recall runs.

### Input

```json
{
  "endpoint": "drug/event",
  "drugName": "metformin",
  "manufacturer": "",
  "dateFrom": "2023-01-01",
  "dateTo": "2023-12-31",
  "seriousOnly": true,
  "recallClass": "",
  "maxItems": 500
}
````

| Field | Type | Default | Description |
|---|---|---|---|
| `endpoint` | string | `drug/event` | FDA dataset to query. See endpoint table below. |
| `drugName` | string | — | Drug brand or generic name. Partial match supported. |
| `manufacturer` | string | — | Manufacturer or recalling firm name. Partial match supported. |
| `dateFrom` | string | — | Start date (`YYYY-MM-DD`). For adverse events, filters by FDA receive date. |
| `dateTo` | string | — | End date (`YYYY-MM-DD`). Defaults to today when `dateFrom` is set. |
| `seriousOnly` | boolean | `false` | Return only serious reports (adverse event endpoints only). |
| `recallClass` | string | — | `Class I`, `Class II`, or `Class III`. Recall endpoints only. |
| `maxItems` | integer | `100` | Maximum records to return. |

#### Available Endpoints

| Value | Dataset | Records Available |
|---|---|---|
| `drug/event` | Drug Adverse Events (FAERS) | 20M+ |
| `drug/enforcement` | Drug Recalls | 18K+ |
| `drug/label` | Drug Labels (SPL) | 257K+ |
| `drug/drugsfda` | Drug Approvals (Drugs@FDA) | 29K+ |
| `drug/ndc` | NDC Directory | 134K+ |
| `device/event` | Device Adverse Events (MAUDE) | 24M+ |
| `device/510k` | Device 510(k) Clearances | 174K+ |
| `device/recall` | Device Recalls | — |

### Output Fields

```json
{
  "report_id": "12345678",
  "endpoint": "drug/event",
  "drug_name": "METFORMIN HYDROCHLORIDE",
  "drug_active_ingredients": ["METFORMIN HYDROCHLORIDE"],
  "drug_manufacturer": "Amneal Pharmaceuticals",
  "drug_characterization": "Suspect",
  "drug_indication": "TYPE 2 DIABETES MELLITUS",
  "drug_route": "Oral",
  "reactions": ["Nausea", "Vomiting", "Lactic acidosis"],
  "reaction_outcomes": ["Recovered", "Recovered", "Hospitalized"],
  "serious": true,
  "seriousness_death": false,
  "seriousness_hospitalization": true,
  "patient_age": "67",
  "patient_sex": "Female",
  "report_country": "US",
  "report_source": "Physician",
  "receive_date": "2023-04-18",
  "recall_number": "",
  "recall_class": "",
  "recall_status": "",
  "recall_reason": "",
  "recall_product": "",
  "recall_firm": "",
  "recall_state": "",
  "recall_distribution": ""
}
```

| Field | Description |
|---|---|
| `report_id` | Unique report or record identifier (FAERS safety report ID, recall number, NDC code, etc.) |
| `endpoint` | FDA dataset this record came from |
| `drug_name` | Drug brand name or generic name |
| `drug_active_ingredients` | Active ingredient(s) in the drug |
| `drug_manufacturer` | Drug manufacturer or reporting company |
| `drug_characterization` | Role of drug in the report: Suspect, Concomitant, or Interacting |
| `drug_indication` | Condition the drug was prescribed for |
| `drug_route` | Route of administration (Oral, Intravenous, Topical, etc.) |
| `reactions` | Adverse reaction terms (MedDRA preferred terms) |
| `reaction_outcomes` | Outcome per reaction: Recovered, Recovering, Not Recovered, Recovered with Sequelae, Fatal, Unknown |
| `serious` | Whether the report is classified as serious |
| `seriousness_death` | Whether the event resulted in death |
| `seriousness_hospitalization` | Whether the event resulted in hospitalization |
| `patient_age` | Patient age at time of event |
| `patient_sex` | Patient sex (Male, Female, Unknown) |
| `report_country` | Country where the report originated |
| `report_source` | Reporter type (Physician, Pharmacist, Consumer, etc.) |
| `receive_date` | Date the FDA received the report or recall initiation date (`YYYY-MM-DD`) |
| `recall_number` | FDA recall number (recall and enforcement records) |
| `recall_class` | Class I, II, or III |
| `recall_status` | Ongoing, Completed, or Terminated |
| `recall_reason` | Reason for the recall |
| `recall_product` | Description of the recalled product |
| `recall_firm` | Firm initiating or subject to the recall |
| `recall_state` | State of the recalling firm |
| `recall_distribution` | Distribution pattern of the recalled product |

### FAQ

**How much data is available for drug adverse events?**
The openFDA Drug Adverse Events (FAERS) dataset contains over 20 million reports accumulated since the 1960s. The Device Adverse Events (MAUDE) dataset has over 24 million. This actor paginates through results up to the `maxItems` limit you set.

**Does this actor require an API key?**
No. The openFDA API is a free government service that requires no authentication. Without a key, the rate limit is 240 requests per minute. This actor stays within that limit and does not currently support API key injection.

**What happens when results exceed 25,000 records?**
The openFDA API has a hard cap of 25,000 on the skip offset (skip + limit must not exceed 25,000). This actor detects that boundary and stops pagination at the cap. For datasets larger than 25,000, use a narrow date range to retrieve specific windows of data across multiple runs.

**Can I get only deaths or hospitalizations?**
Set `seriousOnly: true` to restrict `drug/event` and `device/event` results to serious reports. Within those results, `seriousness_death` and `seriousness_hospitalization` are boolean fields you can filter on in your downstream pipeline. The actor does not currently support single-outcome filtering as a direct input parameter.

**Are all fields present in every record?**
The actor uses a unified schema across all eight endpoints. Fields that do not apply to a given endpoint (e.g., recall fields on an adverse event record) are returned as empty strings or empty arrays rather than omitted. This keeps downstream schema handling consistent.

### Need More Features?

Open an issue or contact us at [apify.com/jungle\_synthesizer/openfda-drug-crawler](https://apify.com/jungle_synthesizer/openfda-drug-crawler) to request additional endpoints, new filter parameters, or a custom build.

### Why Use This Actor

- **No scraping, no rate-limit workarounds** — the openFDA API returns clean JSON; this actor handles pagination, decoding, and schema normalization so you do not have to
- **Eight datasets in one interface** — adverse events, recalls, labels, approvals, NDC codes, and device data are all accessible through the same input format
- **Numeric codes are decoded** — FDA uses integer codes for sex, reaction outcome, drug characterization, and reporter type; this actor converts them to readable strings before writing to your dataset

# 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.

## `endpoint` (type: `string`):

Select which FDA dataset to query. Drug Adverse Events (FAERS) is the largest and most popular dataset.

## `drugName` (type: `string`):

Search by drug brand or generic name. Leave empty for all drugs.

## `manufacturer` (type: `string`):

Filter by manufacturer or reporting company name. Supports partial match.

## `dateFrom` (type: `string`):

Start date for date range filter (YYYY-MM-DD). For adverse events this filters by receive date.

## `dateTo` (type: `string`):

End date for date range filter (YYYY-MM-DD). Defaults to today if dateFrom is set.

## `seriousOnly` (type: `boolean`):

For Drug Adverse Events: only return serious reports (death, hospitalization, life-threatening, disability). Ignored for other datasets.

## `recallClass` (type: `string`):

For Drug/Device Recalls: filter by recall severity class. Class I is the most severe (risk of death). Ignored for non-recall datasets.

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

Maximum number of records to return.

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

Select proxies. The openFDA 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...",
  "endpoint": "drug/event",
  "seriousOnly": false,
  "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...",
    "endpoint": "drug/event",
    "drugName": "",
    "manufacturer": "",
    "dateFrom": "",
    "dateTo": "",
    "recallClass": "",
    "maxItems": 100,
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("jungle_synthesizer/openfda-drug-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...",
    "endpoint": "drug/event",
    "drugName": "",
    "manufacturer": "",
    "dateFrom": "",
    "dateTo": "",
    "recallClass": "",
    "maxItems": 100,
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("jungle_synthesizer/openfda-drug-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...",
  "endpoint": "drug/event",
  "drugName": "",
  "manufacturer": "",
  "dateFrom": "",
  "dateTo": "",
  "recallClass": "",
  "maxItems": 100,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call jungle_synthesizer/openfda-drug-crawler --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "openFDA Drug & Device Data Crawler",
        "description": "Crawl FDA drug adverse events, recalls, labels, NDC codes, device events, and 510(k) clearances from the openFDA API. Filter by drug name, manufacturer, date range, and severity. 20M+ adverse event reports available.",
        "version": "1.0",
        "x-build-id": "QETEPjijB48EgQiYb"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/jungle_synthesizer~openfda-drug-crawler/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-jungle_synthesizer-openfda-drug-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~openfda-drug-crawler/runs": {
            "post": {
                "operationId": "runs-sync-jungle_synthesizer-openfda-drug-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~openfda-drug-crawler/run-sync": {
            "post": {
                "operationId": "run-sync-jungle_synthesizer-openfda-drug-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."
                    },
                    "endpoint": {
                        "title": "FDA Dataset",
                        "enum": [
                            "drug/event",
                            "drug/enforcement",
                            "drug/label",
                            "drug/drugsfda",
                            "drug/ndc",
                            "device/event",
                            "device/510k",
                            "device/recall"
                        ],
                        "type": "string",
                        "description": "Select which FDA dataset to query. Drug Adverse Events (FAERS) is the largest and most popular dataset."
                    },
                    "drugName": {
                        "title": "Drug Name",
                        "type": "string",
                        "description": "Search by drug brand or generic name. Leave empty for all drugs."
                    },
                    "manufacturer": {
                        "title": "Manufacturer / Company",
                        "type": "string",
                        "description": "Filter by manufacturer or reporting company name. Supports partial match."
                    },
                    "dateFrom": {
                        "title": "Date From",
                        "type": "string",
                        "description": "Start date for date range filter (YYYY-MM-DD). For adverse events this filters by receive date."
                    },
                    "dateTo": {
                        "title": "Date To",
                        "type": "string",
                        "description": "End date for date range filter (YYYY-MM-DD). Defaults to today if dateFrom is set."
                    },
                    "seriousOnly": {
                        "title": "Serious Events Only",
                        "type": "boolean",
                        "description": "For Drug Adverse Events: only return serious reports (death, hospitalization, life-threatening, disability). Ignored for other datasets.",
                        "default": false
                    },
                    "recallClass": {
                        "title": "Recall Classification",
                        "enum": [
                            "",
                            "Class I",
                            "Class II",
                            "Class III"
                        ],
                        "type": "string",
                        "description": "For Drug/Device Recalls: filter by recall severity class. Class I is the most severe (risk of death). Ignored for non-recall datasets."
                    },
                    "maxItems": {
                        "title": "Max Items",
                        "type": "integer",
                        "description": "Maximum number of records to return.",
                        "default": 100
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Select proxies. The openFDA 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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
