# FDA Drug Shortages Scraper (`automation-lab/fda-drug-shortages-scraper`) Actor

Export official FDA drug shortage records with status, company, availability, NDCs, dates, and product metadata for monitoring workflows.

- **URL**: https://apify.com/automation-lab/fda-drug-shortages-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.01 / 1,000 fda shortage records

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## FDA Drug Shortages Scraper

Export official FDA/openFDA drug shortage records into a clean Apify dataset for pharmacy procurement, hospital supply-chain monitoring, pharma intelligence, and healthcare risk dashboards.

This actor calls the public openFDA Drug Shortages API, normalizes the records, and gives you searchable fields such as shortage status, generic name, company, availability, dosage form, NDC identifiers, posting dates, update dates, therapeutic category, and source metadata.

### What does FDA Drug Shortages Scraper do?

FDA Drug Shortages Scraper turns the FDA drug shortage feed into analysis-ready rows.

- ✅ Monitor current drug shortages.
- ✅ Export resolved or discontinued shortages for historical review.
- ✅ Search by generic ingredient, company, therapeutic category, brand, or NDC.
- ✅ Capture FDA update dates for alerting workflows.
- ✅ Normalize nested openFDA fields into spreadsheet-friendly arrays.

### Who is it for?

This scraper is designed for teams that need repeatable shortage data instead of manual FDA page checks.

- 🏥 Hospital supply-chain analysts tracking medication risk.
- 💊 Pharmacy procurement teams watching current availability.
- 📊 Healthcare data teams feeding BI dashboards.
- 🧪 Pharma and regulatory analysts monitoring product disruptions.
- 🔔 Risk and operations teams creating recurring shortage alerts.

### Why use this FDA drug shortages extractor?

The FDA feed is public, but production workflows need consistent filters, exports, metadata, and repeatable runs.

This actor adds:

- Structured output fields.
- Apify datasets, exports, API access, and scheduling.
- Provenance fields for auditability.
- PPE billing with a small start fee and per-record pricing.
- Low-cost HTTP execution with no browser or proxy requirement.

### Data source

The actor uses the official openFDA Drug Shortages endpoint:

`https://api.fda.gov/drug/shortages.json`

openFDA data may contain sparse or changing fields depending on the record. The actor keeps source values when present and leaves unavailable fields empty.

### What data can you extract?

| Field | Description |
| --- | --- |
| `status` | FDA shortage status, such as Current or Resolved |
| `genericName` | Generic drug or active ingredient name from the shortage record |
| `companyName` | Company listed by FDA |
| `availability` | FDA availability text |
| `dosageForm` | Dosage form, when supplied |
| `presentation` | Package/presentation text |
| `therapeuticCategories` | FDA therapeutic categories |
| `packageNdc` | Package NDC from the shortage record |
| `productNdcs` | Product NDC values from openFDA metadata |
| `brandNames` | Brand names from openFDA metadata |
| `manufacturers` | Manufacturer names from openFDA metadata |
| `applicationNumbers` | FDA application numbers |
| `rxcuis` | RxNorm concept identifiers |
| `initialPostingDateIso` | ISO-normalized initial posting date |
| `updateDateIso` | ISO-normalized update date |
| `sourceUrl` | API URL used for the source page |
| `scrapedAt` | Actor run timestamp |

### How much does it cost to scrape FDA drug shortages?

The actor uses pay-per-event pricing.

- A small `start` event is charged once per run.
- An `item` event is charged for each shortage record saved.
- The default input is intentionally small so first runs stay cheap.
- Larger scheduled monitoring runs scale with the number of records exported.

Exact live pricing is shown on the Apify actor page.

### Input options

Use these inputs to focus the feed:

- `maxItems` — maximum shortage records to save.
- `status` — Current, Resolved, To Be Discontinued, Discontinued, or All.
- `search` — free-text phrase for openFDA search.
- `genericName` — filter by generic or active ingredient.
- `companyName` — filter by company or manufacturer.
- `therapeuticCategory` — filter by category when present.
- `updatedSince` — keep records updated on or after a date.
- `postedSince` — keep records initially posted on or after a date.

### Example input: current shortages

```json
{
  "status": "Current",
  "maxItems": 100
}
````

### Example input: company monitoring

```json
{
  "companyName": "Takeda",
  "status": "All",
  "maxItems": 100
}
```

### Example input: active ingredient search

```json
{
  "genericName": "lisdexamfetamine",
  "status": "All",
  "maxItems": 100
}
```

### Output example

```json
{
  "status": "Current",
  "genericName": "Lisdexamfetamine Dimesylate Tablet, Chewable",
  "companyName": "Takeda Pharmaceuticals America, Inc.",
  "availability": "Available",
  "packageNdc": "59417-116-01",
  "updateDateIso": "2026-06-23",
  "sourceUrl": "https://api.fda.gov/drug/shortages.json?...",
  "scrapedAt": "2026-07-01T00:00:00.000Z"
}
```

### How to run it

1. Open the actor on Apify.
2. Choose a shortage status.
3. Add optional filters such as company, generic name, or updated date.
4. Set `maxItems`.
5. Run the actor.
6. Export the dataset as JSON, CSV, Excel, or through the Apify API.

### Scheduling and monitoring

You can schedule this scraper in Apify to run daily, weekly, or hourly depending on your monitoring needs.

Common patterns:

- Daily current-shortage export.
- Weekly resolved-shortage archive.
- Company-specific monitoring for a vendor list.
- Ingredient-specific monitoring for a pharmacy formulary.

### Integrations

Connect the output to:

- Google Sheets for pharmacy procurement tracking.
- BigQuery or Snowflake for healthcare analytics.
- Slack or email alerts through Apify integrations.
- BI dashboards for shortage trend reporting.
- Internal inventory and risk systems.

### API usage with Node.js

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/fda-drug-shortages-scraper').call({
  status: 'Current',
  maxItems: 100,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

### API usage with Python

```python
from apify_client import ApifyClient

client = ApifyClient("<APIFY_TOKEN>")
run = client.actor("automation-lab/fda-drug-shortages-scraper").call(run_input={
    "status": "Current",
    "maxItems": 100,
})
items = client.dataset(run["defaultDatasetId"]).list_items().items
print(items)
```

### API usage with cURL

```bash
curl -X POST "https://api.apify.com/v2/acts/automation-lab~fda-drug-shortages-scraper/runs?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"status":"Current","maxItems":100}'
```

### MCP integration

Use this actor from Claude Desktop or Claude Code through Apify MCP:

`https://mcp.apify.com/?tools=automation-lab/fda-drug-shortages-scraper`

Add it in Claude Code:

```bash
claude mcp add apify-fda-shortages https://mcp.apify.com/?tools=automation-lab/fda-drug-shortages-scraper
```

Claude Desktop JSON configuration:

```json
{
  "mcpServers": {
    "apify-fda-shortages": {
      "url": "https://mcp.apify.com/?tools=automation-lab/fda-drug-shortages-scraper"
    }
  }
}
```

Example prompts:

- "Run the FDA Drug Shortages Scraper for current shortages and summarize high-risk categories."
- "Export FDA shortage records updated this month and group them by company."
- "Check whether a specific generic ingredient appears in current FDA shortages."

### Tips for best results

- Use `status: Current` for routine monitoring.
- Use `status: All` for historical analysis.
- Keep `maxItems` modest for alerting workflows.
- Use `updatedSince` to focus on recent FDA changes.
- Combine company and generic filters for targeted vendor risk monitoring.

### Troubleshooting

If you get zero results, broaden your filters first.

Examples:

- Change `status` to `All`.
- Remove the company filter.
- Remove date filters.
- Try a shorter generic name.

### Why are some fields empty?

FDA/openFDA records are not perfectly uniform. Some older or sparse records do not include brand names, RxCUIs, route, or manufacturer metadata. The actor preserves available source fields and leaves unavailable fields empty.

### Legality

#### Is it legal to scrape FDA drug shortages?

The actor uses a public U.S. government/openFDA JSON endpoint. You are responsible for using the data according to your local rules, organizational policies, and openFDA terms.

### Related scrapers

Other automation-lab healthcare and FDA actors may complement this workflow:

- https://apify.com/automation-lab/openfda-drug-enforcement-reports
- https://apify.com/automation-lab/openfda-adverse-events-scraper
- https://apify.com/automation-lab/health-canada-drug-product-scraper

### FAQ

#### Can I monitor only one manufacturer?

Yes. Use `companyName` with the manufacturer or company name and set `status` to `Current` or `All`.

#### Can I search by NDC?

Yes. Put an NDC value in the `search` field. Results depend on how openFDA indexes the value.

#### Can I export to CSV?

Yes. Apify datasets support CSV, JSON, Excel, XML, RSS, and API export formats.

#### Does this actor require proxies?

No. It uses the official openFDA API over HTTP and does not need browser automation or proxies.

#### Can I schedule shortage alerts?

Yes. Schedule the actor on Apify and connect the dataset or webhook output to your alerting workflow.

### Changelog

- Initial version: official openFDA drug shortage extraction with status, company, ingredient, availability, NDC, date, and source metadata fields.

# Actor input Schema

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

Maximum number of FDA shortage records to save to the dataset.

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

Filter by FDA shortage status. Use All to include current, resolved, and discontinued records.

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

Optional openFDA search phrase such as a brand name, NDC, ingredient, or manufacturer.

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

Optional generic drug or active ingredient filter, for example amoxicillin or lisdexamfetamine.

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

Optional FDA company name filter, for example Pfizer, Takeda, or Baxter.

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

Optional category filter such as Psychiatry, Anti-Infective, or Oncology when present in FDA data.

## `updatedSince` (type: `string`):

Only keep records with an FDA update date on or after this date. Format: YYYY-MM-DD.

## `postedSince` (type: `string`):

Only keep records initially posted by FDA on or after this date. Format: YYYY-MM-DD.

## Actor input object example

```json
{
  "maxItems": 20,
  "status": "Current"
}
```

# Actor output Schema

## `overview` (type: `string`):

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

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

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "maxItems": 20,
    "status": "Current",
    "search": "",
    "genericName": "",
    "companyName": "",
    "therapeuticCategory": "",
    "updatedSince": "",
    "postedSince": ""
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/fda-drug-shortages-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 = {
    "maxItems": 20,
    "status": "Current",
    "search": "",
    "genericName": "",
    "companyName": "",
    "therapeuticCategory": "",
    "updatedSince": "",
    "postedSince": "",
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/fda-drug-shortages-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 '{
  "maxItems": 20,
  "status": "Current",
  "search": "",
  "genericName": "",
  "companyName": "",
  "therapeuticCategory": "",
  "updatedSince": "",
  "postedSince": ""
}' |
apify call automation-lab/fda-drug-shortages-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "FDA Drug Shortages Scraper",
        "description": "Export official FDA drug shortage records with status, company, availability, NDCs, dates, and product metadata for monitoring workflows.",
        "version": "0.1",
        "x-build-id": "LRSO22nCachtm5LdW"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~fda-drug-shortages-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-fda-drug-shortages-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/automation-lab~fda-drug-shortages-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-fda-drug-shortages-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/automation-lab~fda-drug-shortages-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-fda-drug-shortages-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": {
                    "maxItems": {
                        "title": "Maximum shortage records",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of FDA shortage records to save to the dataset.",
                        "default": 20
                    },
                    "status": {
                        "title": "Shortage status",
                        "enum": [
                            "Current",
                            "Resolved",
                            "To Be Discontinued",
                            "Discontinued",
                            "All"
                        ],
                        "type": "string",
                        "description": "Filter by FDA shortage status. Use All to include current, resolved, and discontinued records.",
                        "default": "Current"
                    },
                    "search": {
                        "title": "Free-text search",
                        "type": "string",
                        "description": "Optional openFDA search phrase such as a brand name, NDC, ingredient, or manufacturer."
                    },
                    "genericName": {
                        "title": "Generic / active ingredient",
                        "type": "string",
                        "description": "Optional generic drug or active ingredient filter, for example amoxicillin or lisdexamfetamine."
                    },
                    "companyName": {
                        "title": "Company / manufacturer",
                        "type": "string",
                        "description": "Optional FDA company name filter, for example Pfizer, Takeda, or Baxter."
                    },
                    "therapeuticCategory": {
                        "title": "Therapeutic category",
                        "type": "string",
                        "description": "Optional category filter such as Psychiatry, Anti-Infective, or Oncology when present in FDA data."
                    },
                    "updatedSince": {
                        "title": "Updated since",
                        "type": "string",
                        "description": "Only keep records with an FDA update date on or after this date. Format: YYYY-MM-DD."
                    },
                    "postedSince": {
                        "title": "Initially posted since",
                        "type": "string",
                        "description": "Only keep records initially posted by FDA on or after this date. Format: YYYY-MM-DD."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
