# FDA Drug Shortages Scraper - openFDA Supply Tracker (`compute-edge/fda-drug-shortages-scraper`) Actor

Extract FDA drug shortage records from the openFDA API. Filter by status, generic name, and posting date. Includes manufacturer, dosage form, NDC, and shortage reason fields.

- **URL**: https://apify.com/compute-edge/fda-drug-shortages-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 Drug Shortages Scraper — openFDA Supply Disruption Tracker

Extract structured drug shortage records from the **openFDA Drug Shortages API**, the official U.S. Food & Drug Administration feed used by hospitals, pharmacies, group purchasing organizations (GPOs), and pharmaceutical wholesalers to monitor U.S. drug supply continuity. The actor pulls the entire shortage catalog and enriches each record with the openFDA metadata block (NDC codes, application numbers, substance names, route, brand names) so the output is immediately usable in procurement, clinical decision support, and supply-chain analytics pipelines.

The FDA Drug Shortage list is the authoritative source for **CGMP supply disruption tracking** in the United States. Currently in Shortage status, Resolved status, To Be Discontinued, and full Discontinuation notices are all surfaced through a single endpoint. Pharmacy benefit managers, hospital pharmacists, 340B program administrators, and pharmaceutical analysts rely on this data to anticipate stock-outs and plan therapeutic substitutions.

### Key Features

- **Complete openFDA Drug Shortages coverage** — pulls the full ~1,700 record catalog with API pagination
- **Status filtering** — Currently in Shortage / Resolved / Discontinuation / To Be Discontinued
- **Generic name filter** — for monitoring a specific molecule across all manufacturers
- **Date-range filtering** on the initial posting date (YYYY-MM-DD)
- **Enriched fields** — joins openFDA's product metadata (application number, NDC, route, brand)
- **No authentication required** — the openFDA endpoint is public
- **Clean JSON output** — ready for RAG pipelines, BI dashboards, or PostgreSQL ingestion

### Output Data Fields

| Field | Type | Description |
|-------|------|-------------|
| `genericName` | string | Generic / nonproprietary drug name |
| `proprietaryName` | string | Brand or proprietary name |
| `status` | string | "Currently in Shortage", "Resolved", etc. |
| `availability` | string | Free-text availability/supply notes |
| `dosageForm` | string | e.g., "Tablet", "Solution" |
| `strength` | string | Concentration / strength |
| `packageNdc` | string | National Drug Code (package level) |
| `productNdc` | string | National Drug Code (product level) |
| `applicationNumber` | string | FDA ANDA/NDA application number |
| `company` | string | Manufacturer |
| `shortageReason` | string | FDA-reported reason (e.g., "Demand increase for the drug") |
| `therapeuticCategory` | string | Therapeutic class |
| `route` | string | Route of administration |
| `substanceName` | string | Active ingredient |
| `contactInfo` | string | Manufacturer contact for the shortage |
| `relatedInfo` | string | Additional notes |
| `updateType` | string | Add / Update / Reverified |
| `initialPostingDate` | string | First date posted (MM/DD/YYYY from openFDA) |
| `updateDate` | string | Last update timestamp |
| `brandName` | string | openFDA brand name (when available) |

### How to Scrape FDA Drug Shortages

1. Open the **FDA Drug Shortages Scraper** Actor page on Apify Store.
2. Click **Start** to open the input form.
3. (Optional) Set **Status Filter** to `Currently in Shortage` to only retrieve open shortages.
4. (Optional) Set **Generic Name Filter** to focus on a single molecule, e.g., `Amoxicillin`.
5. (Optional) Use **Initially Posted After** / **Before** to narrow the window (YYYY-MM-DD).
6. Set **Max Results** to cap the output. Leave at 0 for everything.
7. Click **Start**.
8. Download as JSON / CSV / Excel from the Dataset tab, or hit the API endpoint for automation.

### Input Example

```json
{
    "statusFilter": "Currently in Shortage",
    "maxResults": 200
}
````

### Output Example

```json
{
    "genericName": "Clonazepam Tablet",
    "proprietaryName": "Clonazepam",
    "status": "Resolved",
    "availability": "Available",
    "dosageForm": "Tablet",
    "company": "Advagen Pharma Ltd.",
    "shortageReason": "Demand increase for the drug",
    "applicationNumber": "ANDA075468",
    "packageNdc": "72888-154-05",
    "initialPostingDate": "03/10/2023"
}
```

### Pricing

This Actor calls a free public API. Compute cost is minimal — a complete catalog pull finishes well under a minute.

- **Per-result pricing**: $0.003/result
- **Typical run**: complete catalog (~1,700 records) for a few cents

### Other Actors

- CISA Known Exploited Vulnerabilities Scraper
- openFDA Drug Adverse Events Scraper
- ClinicalTrials.gov Scraper
- CMS Hospital General Information Scraper

### FAQ

**Does this Actor require an FDA / openFDA API key?**
No. The openFDA Drug Shortages endpoint is public and requires no authentication.

**How fresh is the data?**
openFDA pushes updates daily. The `updateDate` field reflects when the FDA last touched the record.

**Can I get only shortages that are currently active?**
Yes — set `statusFilter` to `Currently in Shortage`.

### Legal

This Actor extracts publicly available data from the openFDA API operated by the U.S. Food & Drug Administration. No personal data is collected. Users are responsible for complying with the openFDA Terms of Service (https://open.fda.gov/terms/) when redistributing data.

# Actor input Schema

## `statusFilter` (type: `string`):

Filter by shortage status. Examples: 'Currently in Shortage', 'Resolved', 'To Be Discontinued', 'Discontinuation'. Leave blank for all statuses.

## `genericNameFilter` (type: `string`):

Filter by generic drug name (exact match per openFDA, case-insensitive). Examples: 'Clonazepam', 'Amoxicillin', 'Lisinopril'.

## `postedAfter` (type: `string`):

Only include records first posted on or after this date (YYYY-MM-DD).

## `postedBefore` (type: `string`):

Only include records first posted on or before this date (YYYY-MM-DD).

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

Maximum number of records to return. 0 = unlimited.

## Actor input object example

```json
{
  "statusFilter": "",
  "genericNameFilter": "",
  "postedAfter": "",
  "postedBefore": "",
  "maxResults": 500
}
```

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

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "FDA Drug Shortages Scraper - openFDA Supply Tracker",
        "description": "Extract FDA drug shortage records from the openFDA API. Filter by status, generic name, and posting date. Includes manufacturer, dosage form, NDC, and shortage reason fields.",
        "version": "0.1",
        "x-build-id": "lQjGyPLEgvu8sJIYq"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/compute-edge~fda-drug-shortages-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-compute-edge-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/compute-edge~fda-drug-shortages-scraper/runs": {
            "post": {
                "operationId": "runs-sync-compute-edge-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/compute-edge~fda-drug-shortages-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-compute-edge-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": {
                    "statusFilter": {
                        "title": "Status Filter",
                        "type": "string",
                        "description": "Filter by shortage status. Examples: 'Currently in Shortage', 'Resolved', 'To Be Discontinued', 'Discontinuation'. Leave blank for all statuses.",
                        "default": ""
                    },
                    "genericNameFilter": {
                        "title": "Generic Name Filter",
                        "type": "string",
                        "description": "Filter by generic drug name (exact match per openFDA, case-insensitive). Examples: 'Clonazepam', 'Amoxicillin', 'Lisinopril'.",
                        "default": ""
                    },
                    "postedAfter": {
                        "title": "Initially Posted After",
                        "type": "string",
                        "description": "Only include records first posted on or after this date (YYYY-MM-DD).",
                        "default": ""
                    },
                    "postedBefore": {
                        "title": "Initially Posted Before",
                        "type": "string",
                        "description": "Only include records first posted on or before this date (YYYY-MM-DD).",
                        "default": ""
                    },
                    "maxResults": {
                        "title": "Max Results",
                        "minimum": 0,
                        "maximum": 50000,
                        "type": "integer",
                        "description": "Maximum number of records to return. 0 = unlimited.",
                        "default": 500
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
