# FDA Drug Approvals Scraper (`muhammadafzal/fda-drug-approvals-scraper`) Actor

Extract FDA drug approval actions, products, ingredients, sponsors, dates, review priorities, and public documents from Drugs@FDA.

- **URL**: https://apify.com/muhammadafzal/fda-drug-approvals-scraper.md
- **Developed by:** [Muhammad Afzal](https://apify.com/muhammadafzal) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.60 / 1,000 fda approval actions

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/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

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

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## FDA Drug Approvals Scraper

> **Free-plan limit:** Apify free-plan runs can return at most **5 dataset records per run** from this Actor, even if you request more.

Extract structured FDA drug approval actions from the official Drugs@FDA dataset. The Actor is designed for pharmaceutical research, regulatory intelligence, competitive monitoring, and data pipelines that need application-level approval history without parsing FDA pages manually.

The Actor uses the public openFDA Drugs@FDA endpoint, which is sourced from Drugs@FDA and updated on FDA business days. One dataset item represents one approved original or supplement submission—not one product package. This distinction keeps dates, review priority, submission class, and public approval documents attached to the regulatory action they describe.

### What it extracts

| Field | Description |
| --- | --- |
| `applicationNumber`, `applicationType` | NDA, ANDA, or BLA identifier and type |
| `approvalDate`, `approvalStatus` | FDA submission status date and AP/TA status |
| `submissionType`, `submissionNumber` | Original or supplement action and its number |
| `reviewPriority` | Standard or priority review when FDA supplies it |
| `submissionClassCode` | FDA submission classification and description |
| `sponsorName` | Application sponsor |
| `products` | Brand, ingredient/strength, dosage form, route, marketing status, RLD/RS flags, and TE code |
| `brandNames`, `genericNames`, `substanceNames` | Harmonized openFDA names |
| `manufacturerNames`, `productNdcs`, `rxcuis` | Harmonized identifiers |
| `applicationDocuments` | Public labels, letters, reviews, and other submission documents when available |
| `applicationUrl`, `apiUrl` | Official FDA and openFDA source links |
| `sourceLastUpdated`, `fetchedAt` | Source freshness and extraction timestamp |

### When to use it

Use this Actor to monitor approvals by date, build a sponsor or drug approval history, retrieve exact applications, analyze original versus supplement actions, or feed FDA regulatory data into a spreadsheet, database, or AI agent.

Do not use it for medical advice, adverse-event analysis, recalls, drug labels as full text, patents/exclusivity, or a complete list of CBER-regulated vaccines, blood products, and cell or gene therapies. Drugs@FDA coverage and harmonized fields vary by product and year.

### Input

| Input | Default | Purpose |
| --- | --- | --- |
| `query` | `Ozempic` | Search brand names, ingredients, sponsors, and application numbers |
| `applicationNumbers` | `[]` | Retrieve exact NDA, ANDA, or BLA applications |
| `brandName` | empty | Match an FDA product brand name |
| `activeIngredient` | empty | Match an FDA active ingredient |
| `sponsorName` | empty | Match an application sponsor |
| `applicationType` | `all` | Limit to NDA, ANDA, or BLA |
| `approvalType` | `original` | Return originals, supplements, or both |
| `approvalDateFrom`, `approvalDateTo` | empty | Bound approval status dates in `YYYY-MM-DD` |
| `includeTentativeApprovals` | `false` | Include TA records alongside AP approvals |
| `sortBy` | `newest` | Sort approval actions by date |
| `maxResults` | `25` | Cap records and result-event charges (1–5,000) |
| `maxRequestRetries` | `2` | Retry bounded 429, 5xx, timeout, and network errors |
| `apiKey` | empty | Optional openFDA key for higher official API limits |

At least one search criterion is required. Clear the default `query` when you want only exact filters to apply.

#### Recent original approvals

```json
{
  "query": "",
  "approvalDateFrom": "2026-01-01",
  "approvalDateTo": "2026-12-31",
  "approvalType": "original",
  "sortBy": "newest",
  "maxResults": 100
}
```

#### Exact applications with supplement history

```json
{
  "query": "",
  "applicationNumbers": ["NDA209637", "NDA213051"],
  "approvalType": "all",
  "maxResults": 250
}
```

#### API call

```bash
curl -X POST "https://api.apify.com/v2/acts/USERNAME~fda-drug-approvals-scraper/runs?token=APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"query":"semaglutide","approvalType":"original","maxResults":10}'
```

With Apify's MCP server, call the Actor with the same JSON input, wait for completion, then read `results` from the default dataset or `summary` from the output links.

### Output example

```json
{
  "approvalId": "NDA209637:ORIG:1:2017-12-05",
  "applicationNumber": "NDA209637",
  "applicationType": "NDA",
  "sponsorName": "NOVO",
  "submissionType": "ORIG",
  "submissionNumber": "1",
  "approvalStatus": "AP",
  "approvalStatusLabel": "Approved",
  "approvalDate": "2017-12-05",
  "reviewPriority": "STANDARD",
  "submissionClassCode": "TYPE 1",
  "submissionClassDescription": "Type 1 - New Molecular Entity",
  "brandNames": ["OZEMPIC"],
  "genericNames": [],
  "applicationUrl": "https://www.accessdata.fda.gov/scripts/cder/daf/index.cfm?event=overview.process&ApplNo=209637",
  "sourceLastUpdated": "2026-08-28",
  "fetchedAt": "2026-08-31T12:00:00.000Z"
}
```

The full record also contains `products`, ingredients and strengths, harmonized identifiers, routes, manufacturers, and public documents. Optional FDA fields are represented as `null` or empty arrays rather than invented values.

### Pricing

This Actor uses **pay-per-event** pricing. These are the current Apify Store event prices:

| Event | Price (USD) | When it is charged |
|---|---:|---|
| `apify-actor-start` | $0.0005 | Actor Start — Charged when the Actor starts running. Number of events charged depends on Actor memory (one event per GB, minimum one event). — Charged once per run. |
| `fda-approval-action` | $0.001 | FDA approval action — One schema-valid FDA drug approval action written to the default dataset. |

Apify platform usage for this Actor run is included alongside the event prices above; no separate per-run platform-usage fee is passed to users.

This covers Apify platform usage for this Actor run. Other Apify products or usage outside this Actor run may still follow your account plan.

### Reliability and limits

- The source is the official public openFDA Drugs@FDA endpoint; no third-party provider is used.
- Requests use bounded timeouts, retry 429 and transient 5xx/network failures, and honor `Retry-After` when supplied.
- openFDA accepts at most 99 application records per request and restricts deep paging. The Actor paginates automatically and reports a warning if the source's 25,000-record deep-page boundary is reached. Narrow filters for larger studies.
- openFDA returns whole application records when a nested submission matches. The Actor re-filters every nested submission locally so unrelated dates or action types are not emitted.
- Drug-name text filters must use printable ASCII because openFDA rejects some Unicode search syntax; exact FDA application numbers remain available as a language-neutral lookup.
- A valid search with no approval actions returns an empty dataset plus a truthful `SUMMARY`. Invalid input is rejected before billable result work.
- Public API limits are stricter without an openFDA API key. Supply your own optional key for frequent or large runs.

### Data responsibility

The data is public U.S. government regulatory information. Respect the openFDA terms and license, use reasonable request volumes, and retain source links when redistributing records. FDA and openFDA warn that the data should not be used alone for medical-care decisions. Verify material regulatory conclusions against the linked FDA documents and application page.

For support, open an issue from the Actor's Apify Console page and include the run ID, redacted input, expected outcome, and the `SUMMARY` record. Never include API keys or tokens.

# Actor input Schema

## `query` (type: `string`):

Use this to search brand names, active ingredients, sponsors, and application numbers, for example `Ozempic`. Defaults to `Ozempic`; clear it when using exact filters.

## `applicationNumbers` (type: `array`):

Use this for exact FDA application numbers, for example `NDA213051` or `ANDA079162`. These are not NDC product codes.

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

Use this to match an FDA product brand name, for example `Keytruda`. Leave empty to include all brand names.

## `activeIngredient` (type: `string`):

Use this to match an active ingredient, for example `semaglutide`. This is not a pharmacologic class search.

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

Use this to match the FDA application sponsor, for example `Novo Nordisk`. Leave empty for all sponsors.

## `applicationType` (type: `string`):

Use `all` for every Drugs@FDA application, `NDA` for new drugs, `ANDA` for abbreviated new drugs, or `BLA` for biologic license applications represented in this dataset.

## `approvalType` (type: `string`):

Use `original` for initial approvals, `supplement` for approved supplements, or `all` for both. Default is original approvals.

## `approvalDateFrom` (type: `string`):

Use this lower approval-date bound in YYYY-MM-DD format, for example `2025-01-01`. This filters submission approval actions, not product marketing dates.

## `approvalDateTo` (type: `string`):

Use this upper approval-date bound in YYYY-MM-DD format, for example `2025-12-31`. It must not precede the lower bound.

## `includeTentativeApprovals` (type: `boolean`):

Use this to include FDA submission status `TA` as well as fully approved status `AP`. Default is false; tentative approvals are clearly labeled in output.

## `sortBy` (type: `string`):

Use `newest` or `oldest` to order delivered approval actions by FDA submission status date.

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

Use this to cap delivered dataset records and PPE result events. Default is 25; accepted range is 1–5,000.

## `maxRequestRetries` (type: `integer`):

Use this to retry openFDA 429, 5xx, timeout, or network failures. Default is 2; accepted range is 0–5. Invalid searches are not retried.

## `apiKey` (type: `string`):

Use this optional openFDA API key for higher official API limits. The default run works without one. This is not an Apify API token.

## Actor input object example

```json
{
  "query": "Ozempic",
  "applicationNumbers": [],
  "applicationType": "all",
  "approvalType": "original",
  "includeTentativeApprovals": false,
  "sortBy": "newest",
  "maxResults": 25,
  "maxRequestRetries": 2
}
```

# Actor output Schema

## `results` (type: `string`):

Schema-validated approval-action records from the default dataset.

## `summary` (type: `string`):

Outcome, counts, warnings, source update date, and cost estimate.

# 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 = {
    "query": "Ozempic"
};

// Run the Actor and wait for it to finish
const run = await client.actor("muhammadafzal/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 = { "query": "Ozempic" }

# Run the Actor and wait for it to finish
run = client.actor("muhammadafzal/fda-drug-approvals-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "query": "Ozempic"
}' |
apify call muhammadafzal/fda-drug-approvals-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,muhammadafzal/fda-drug-approvals-scraper"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/chHPaqth0E593WKGj/builds/FbZpHKcDboh7CsuKB/openapi.json