# Drugs@FDA Approved Drug Applications Scraper (`compute-edge/fda-drug-approvals-scraper`) Actor

Extract FDA-approved drug applications from the openFDA Drugs@FDA database. Get sponsor names, brand and generic names, dosage forms, routes, active ingredients, NDC codes, marketing status, and original approval dates. Filter by sponsor, brand, or application number.

- **URL**: https://apify.com/compute-edge/fda-drug-approvals-scraper.md
- **Developed by:** [Compute Edge](https://apify.com/compute-edge) (community)
- **Categories:** Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 results

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 Drugs@FDA Approved Drug Applications Scraper

Extract structured data from **FDA Drugs@FDA**, the authoritative database of FDA-approved drug applications maintained by the U.S. Food and Drug Administration. This Actor fetches comprehensive drug approval records from the openFDA API, providing powerful filtering, computed approval date fields, and clean JSON output ready for pharmaceutical research, regulatory compliance, and supply-chain intelligence pipelines.

Drugs@FDA contains all FDA-approved human drug applications approved since 1982 for all dosage forms and routes of administration. Pharmaceutical companies, researchers, regulatory professionals, and healthcare supply-chain managers rely on this data for market analysis, competitive intelligence, and pharmacovigilance workflows.

### Key Features

- **Complete Drugs@FDA database access** — All FDA-approved drug applications searchable without authentication
- **Sponsor/manufacturer filtering** — Find drugs by the company that sponsors the application
- **Brand name and generic name extraction** — Clean separation of brand names, generic names, and active ingredients
- **Marketing status filtering** — Isolate Prescription, Over-the-Counter, Discontinued, or Withdrawn drugs
- **Product-level detail** — Dosage forms, routes of administration, NDC codes, manufacturer information
- **Original approval dates** — Computed from submission records (earliest ORIG/AP submission date)
- **Active ingredients structured** — Each ingredient listed with strength/dose information
- **Pharmacological classifications** — Extract therapeutic and chemical classes (pharm_class_epc)
- **Batch-optimized output** — One record per product (applications may have multiple product variations)
- **No authentication required** — Public openFDA API, no API keys or credentials needed
- **Pagination support** — Handle up to 25,000 results with configurable batch sizes

### Output Data Fields

| Field | Type | Description |
|-------|------|-------------|
| `applicationNumber` | string | FDA application number (e.g., NDA021833, ANDA076232, BLA125023) |
| `applicationType` | string | Application type derived from application number (e.g., NDA, ANDA, BLA) |
| `sponsorName` | string | Company name that sponsored the application |
| `brandName` | string | Brand/trade name of the drug product |
| `genericName` | string | Generic/nonproprietary name (INN) |
| `activeIngredients` | string | Semicolon-separated list of active ingredients with strengths |
| `dosageForm` | string | Pharmaceutical form (e.g., Tablet, Capsule, Solution, Injectable) |
| `route` | string | Route of administration (e.g., Oral, Intravenous, Topical, Intramuscular) |
| `marketingStatus` | string | Market status (e.g., Prescription, Over-the-Counter, Discontinued) |
| `manufacturerName` | string | Manufacturing company names (comma-separated if multiple) |
| `pharmClass` | string | Pharmacological class/therapeutic category |
| `substanceName` | string | Active substance names from the openFDA database |
| `productNdc` | string | FDA NDC (National Drug Code) values |
| `originalApprovalDate` | string | Date of original FDA approval (YYYY-MM-DD format, or empty if not found) |

### How to Scrape FDA Approved Drugs

1. Navigate to the **FDA Drugs@FDA Scraper** Actor page on Apify Store.
2. Click **Start** to open the input configuration form.
3. (Optional) Enter a **Sponsor Name** to filter results by pharmaceutical company (e.g., "Pfizer", "Merck").
4. (Optional) Enter a **Brand Name** to search for a specific drug by brand (e.g., "Lipitor", "Advil").
5. (Optional) Enter a **Marketing Status** to filter by status (e.g., "Prescription", "Over-the-Counter", "Discontinued").
6. (Optional) Enter an **Application Number** to retrieve a specific FDA application.
7. Set **Max Results** to control the output size (default: 1000, max: 25000).
8. Click **Start** to run the Actor.
9. Download results as JSON, CSV, or Excel from the **Dataset** tab after execution.

### Input Example

```json
{
    "sponsorName": "Pfizer",
    "brandName": "",
    "marketingStatus": "Prescription",
    "applicationNumber": "",
    "maxResults": 100
}
````

### Output Example

```json
{
    "applicationNumber": "NDA021833",
    "applicationType": "NDA",
    "sponsorName": "Pfizer Inc",
    "brandName": "Lipitor",
    "genericName": "atorvastatin",
    "activeIngredients": "atorvastatin calcium 10 mg; atorvastatin calcium 20 mg",
    "dosageForm": "Tablet",
    "route": "Oral",
    "marketingStatus": "Prescription",
    "manufacturerName": "Pfizer Inc",
    "pharmClass": "HMG-CoA Reductase Inhibitors",
    "substanceName": "atorvastatin",
    "productNdc": "0071-0151-23; 0071-0152-23",
    "originalApprovalDate": "1997-12-17",
    "applicationType": "NDA"
}
```

### Pricing

This Actor fetches data from the free public openFDA API using simple HTTP requests with no browser automation required.

- **Cost per run**: ~$0.0001 (minimal API overhead, fast queries)
- **Actor start event**: Default platform rate
- **Per-result pricing**: $0.003/result (each product record emitted)

Typical run times:

- Empty filters (all drugs): 30-60 seconds for 1000 results
- Filtered queries (by sponsor/brand): 5-15 seconds
- Specific application number: <2 seconds

### Use Cases

- **Pharmaceutical market research** — Analyze competitive drug portfolios by sponsor, therapeutic class, and approval timeline
- **Regulatory compliance tracking** — Monitor FDA approvals, track withdrawal/discontinuation status, validate product marketing claims
- **Supply-chain intelligence** — Identify active manufacturers, track NDC codes, verify product formulations
- **Clinical data enrichment** — Supplement patient records with structured drug approval and formulation data
- **Patent and IP analysis** — Correlate FDA approvals with patent databases to track product life-cycle
- **Pharmacovigilance workflows** — Feed approval records into adverse-event tracking systems
- **Healthcare provider onboarding** — Validate formularies against Drugs@FDA data for accuracy
- **RAG pipeline ingestion** — Clean structured output ready for LLM-based drug information queries
- **Competitive intelligence** — Track competitor product approvals, dosage forms, and market entries
- **Historical trend analysis** — Analyze approval trends by therapeutic class, manufacturer, or application type

### FAQ

#### Is it legal to scrape FDA Drugs@FDA data?

Yes. This Actor accesses publicly available data from the openFDA API, which is published by the U.S. Food and Drug Administration as open government data. No authentication is required and no terms of service are violated. The data is freely available for any use, including commercial use.

#### How often is Drugs@FDA data updated?

The openFDA database is updated quarterly with new FDA approvals. New drug applications may appear in Drugs@FDA within a few days of FDA approval. You can schedule this Actor to run weekly or monthly to stay current with new approvals.

#### What does "Marketing Status" mean?

**Marketing Status** indicates whether a drug is actively available for sale:

- **Prescription** — Requires a prescription; typically OTC equivalents do not have this status
- **Over-the-Counter (OTC)** — Available for purchase without a prescription
- **Discontinued** — No longer manufactured/marketed but was previously approved
- **Withdrawn** — Approval was voluntarily withdrawn or revoked by FDA

#### Can I export FDA Drugs@FDA data to Excel or CSV?

Yes. Apify supports exporting results in JSON, CSV, Excel, XML, and other formats directly from the Dataset tab after a run completes. You can also download raw data for bulk import into databases or analytics tools.

#### Why do some applications have multiple product records?

Each FDA application can contain multiple drug products (different dosage forms, strengths, or routes). For example, a single application for "Aspirin" may include tablets in 100mg, 325mg, and 500mg strengths. This Actor emits **one record per product variation** to enable detailed analysis. If you need application-level records only, you can deduplicate by `applicationNumber` downstream.

#### What is an Application Number (NDA, ANDA, BLA)?

- **NDA** (New Drug Application) — Standard approval pathway for a new chemical entity
- **ANDA** (Abbreviated New Drug Application) — Approval for generic equivalent of an existing drug
- **BLA** (Biologics License Application) — Approval for biological products (vaccines, monoclonal antibodies, etc.)

#### What is an NDC code?

**NDC** (National Drug Code) is a unique identifier assigned to each drug product strength/dosage combination and packaging size. It has 10 digits in 5-4-2 format: `LLLLL-LLLL-LL`. NDCs are used in pharmacy records, insurance claims, and supply-chain tracking.

#### How do I filter by therapeutic class?

Use the **Brand Name** or **Sponsor Name** filter to narrow results, then filter by **pharmacClass** in your downstream analysis. Alternatively, you can schedule multiple runs targeting specific therapeutic classes (e.g., "statin", "antibiotic", "immunosuppressant") using the generic name or pharm\_class fields.

#### Can I get approval dates for generic/ANDA drugs?

Yes. This Actor computes **originalApprovalDate** from submission records. For ANDA (generic) drugs, this is typically the date the generic formulation was approved, not the date the original brand drug was approved.

### Other Scrapers by SeatSignal

- [CISA Known Exploited Vulnerabilities (KEV) Scraper](https://apify.com/seatsignal/cisa-kev-scraper) — Extract CVE threat intelligence and remediation due dates
- [NIST NVD Scraper](https://apify.com/seatsignal/nist-nvd-scraper) — Extract CVE vulnerability data from the NIST National Vulnerability Database
- [CPSC Product Recalls Scraper](https://apify.com/seatsignal/cpsc-product-recalls-scraper) — Extract consumer product recall data and safety information
- [NHTSA Vehicle Safety Scraper](https://apify.com/seatsignal/nhtsa-vehicle-safety-scraper) — Extract vehicle recalls and safety investigations
- [OSHA Inspections Scraper](https://apify.com/seatsignal/osha-inspections-scraper) — Extract OSHA workplace safety inspection data and violations

### Legal Disclaimer

This Actor extracts publicly available data from the openFDA Drugs@FDA database, which is published as open government data by the U.S. Food and Drug Administration. No authentication bypass, credential usage, or terms-of-service violation is involved. Users are responsible for ensuring their use of extracted data complies with applicable laws and regulations, including HIPAA (for health information), FDA regulations, and state pharmacy/medical practice laws.

For regulatory questions about Drugs@FDA data, consult the [official FDA Drugs@FDA Documentation](https://open.fda.gov/apis/drug/drugsfda/). For Actor support, contact the developer through the Apify Store.

# Actor input Schema

## `sponsorName` (type: `string`):

Filter by drug sponsor/manufacturer name. Examples: 'Pfizer', 'Merck', 'Roche'. Leave empty to include all sponsors.

## `brandName` (type: `string`):

Filter by drug brand name. Examples: 'Aspirin', 'Lipitor', 'Advil'. Leave empty to include all brand names.

## `marketingStatus` (type: `string`):

Filter by marketing status. Examples: 'Prescription', 'Over-the-Counter', 'Discontinued'. Leave empty to include all statuses.

## `applicationNumber` (type: `string`):

Filter by specific FDA application number. Examples: 'NDA021833', 'ANDA076232'. Leave empty to include all applications.

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

Maximum number of drug applications to return. Each application may have multiple products (each becomes one result row).

## Actor input object example

```json
{
  "sponsorName": "",
  "brandName": "",
  "marketingStatus": "",
  "applicationNumber": "",
  "maxResults": 1000
}
```

# Actor output Schema

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

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

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Drugs@FDA Approved Drug Applications Scraper",
        "description": "Extract FDA-approved drug applications from the openFDA Drugs@FDA database. Get sponsor names, brand and generic names, dosage forms, routes, active ingredients, NDC codes, marketing status, and original approval dates. Filter by sponsor, brand, or application number.",
        "version": "0.1",
        "x-build-id": "ZKEd8XXs2yRkDrJaE"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/compute-edge~fda-drug-approvals-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-compute-edge-fda-drug-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/compute-edge~fda-drug-approvals-scraper/runs": {
            "post": {
                "operationId": "runs-sync-compute-edge-fda-drug-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/compute-edge~fda-drug-approvals-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-compute-edge-fda-drug-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": {
                    "sponsorName": {
                        "title": "Sponsor Name",
                        "type": "string",
                        "description": "Filter by drug sponsor/manufacturer name. Examples: 'Pfizer', 'Merck', 'Roche'. Leave empty to include all sponsors.",
                        "default": ""
                    },
                    "brandName": {
                        "title": "Brand Name",
                        "type": "string",
                        "description": "Filter by drug brand name. Examples: 'Aspirin', 'Lipitor', 'Advil'. Leave empty to include all brand names.",
                        "default": ""
                    },
                    "marketingStatus": {
                        "title": "Marketing Status",
                        "type": "string",
                        "description": "Filter by marketing status. Examples: 'Prescription', 'Over-the-Counter', 'Discontinued'. Leave empty to include all statuses.",
                        "default": ""
                    },
                    "applicationNumber": {
                        "title": "Application Number",
                        "type": "string",
                        "description": "Filter by specific FDA application number. Examples: 'NDA021833', 'ANDA076232'. Leave empty to include all applications.",
                        "default": ""
                    },
                    "maxResults": {
                        "title": "Max Results",
                        "minimum": 1,
                        "maximum": 25000,
                        "type": "integer",
                        "description": "Maximum number of drug applications to return. Each application may have multiple products (each becomes one result row).",
                        "default": 1000
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```