# FDA Drug Approvals Scraper (`automation-lab/fda-drugs-approval-records-search`) Actor

Search official Drugs@FDA approval records and export applications, products, sponsors, ingredients, approval actions, and label links.

- **URL**: https://apify.com/automation-lab/fda-drugs-approval-records-search.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 $8.29 / 1,000 item extracteds

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?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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 Approvals Scraper

Search official Drugs@FDA records and export application, product, sponsor, ingredient, strength, dosage-form, route, approval-action, and FDA document data.

FDA Drug Approvals Scraper turns the structured openFDA Drugs@FDA dataset into analysis-ready records. Look up a drug or exact NDA, ANDA, or BLA application; filter approval actions by date; and send repeatable results to a spreadsheet, database, webhook, or compliance workflow.

The Actor uses the official anonymous FDA API. It does not need a login, browser, or proxy.

### What can you do with FDA drug approvals data?

- Research approved products for a brand, generic name, or active ingredient.
- Look up one or many FDA application numbers.
- Compare products, sponsors, strengths, dosage forms, and routes.
- Review approved original and supplemental submissions.
- Collect FDA approval letters, labels, and review-document links.
- Schedule a date-window query and compare datasets between runs.
- Feed regulatory intelligence, portfolio research, or market analysis pipelines.

Each dataset item represents one product under one application. If an application has no product object, the Actor emits an application-level record instead.

### Who is this Actor for?

**Regulatory affairs teams** can build repeatable application and labeling reviews.

**Pharmaceutical market researchers** can compare sponsor portfolios and approved product presentations.

**Life-sciences data teams** can normalize official records before loading them into a warehouse or BI tool.

**Due-diligence analysts** can retrieve the approval history and source documents behind a product.

**Developers** can use a stable input and output contract instead of implementing openFDA pagination, retries, product expansion, and normalization themselves.

### Why use this FDA drug approvals scraper?

- **Official source:** records come from the FDA-hosted openFDA Drugs@FDA endpoint.
- **Product-level output:** applications are expanded into separate, useful product rows.
- **Approval history included:** approved actions and linked documents are normalized inside each row.
- **Multiple lookup modes:** broad text, field-specific search, exact application numbers, and action-date windows.
- **Deduplicated export:** repeated matches across queries are saved only once per application and product.
- **Automation ready:** runs work through Apify Console, API, schedules, webhooks, and MCP.
- **Low overhead:** direct JSON requests use 256 MB memory and no paid proxy traffic.

This Actor focuses on approval applications and products. For current availability problems, use [FDA Drug Shortages Scraper](https://apify.com/automation-lab/fda-drug-shortages-scraper), which returns shortage status rather than approval history.

### What data does the Actor extract?

| Field | Meaning |
| --- | --- |
| `recordType` | `product` or fallback `application` record |
| `applicationNumber` | Official NDA, ANDA, or BLA application identifier |
| `sponsorName` | Sponsor reported in Drugs@FDA |
| `productNumber` | Product number within the application |
| `brandName` | Product brand name, when available |
| `genericNames` | Generic names reported by openFDA |
| `activeIngredients` | Ingredient names and strengths |
| `dosageForm` | FDA dosage form |
| `route` | Administration route |
| `strength` | Combined display value for ingredient strengths |
| `marketingStatus` | Marketing status reported for the product |
| `referenceDrug` | Whether FDA marks the product as a reference drug |
| `referenceStandard` | Whether FDA marks it as a reference standard |
| `approvalDate` | Earliest included approved action date |
| `latestActionDate` | Latest included approved action date |
| `submissions` | Normalized original/supplemental approval actions |
| `labelDocuments` | FDA documents classified as labels |
| `applicationDocuments` | All linked FDA letters, labels, reviews, and other documents |
| `productNdcs` | Product NDC values mapped by openFDA |
| `sourceUrl` | Drugs@FDA application overview page |
| `apiUrl` | Exact official API request used |
| `searchQuery` | Query or date window that found the row |
| `retrievedAt` | UTC retrieval timestamp |

FDA fields can legitimately be missing. Nullable output values remain `null`, while list fields are empty arrays.

### Input parameters

#### `queries`

A list of drug names, ingredients, sponsors, application numbers, or NDC values. The Actor searches each value independently and deduplicates output.

#### `applicationNumbers`

Exact application identifiers such as `NDA020267` or `ANDA083022`. These always use application-number lookup, regardless of `searchField`.

#### `searchField`

Choose how values in `queries` are interpreted:

- `any` — openFDA full-text search;
- `brandName` — brand names;
- `genericName` — generic names;
- `activeIngredient` — product active ingredients;
- `applicationNumber` — application identifiers;
- `sponsorName` — sponsors;
- `productNdc` — product NDCs.

#### `approvalDateFrom` and `approvalDateTo`

Optional inclusive approval-action dates in `YYYY-MM-DD` format. You can submit a date window without a text query to monitor all matching actions.

#### `approvedOnly`

Defaults to `true`. When enabled, only submissions with official FDA status `AP` are included.

#### `includeSubmissions`

Defaults to `true`. Disable it for smaller records if you only need product identity and document arrays.

#### `maxItems`

Maximum product/application records saved across all queries. The range is 1–10,000 and the default is 100.

### Getting started

1. Open the Actor input in Apify Console.
2. Enter one or more search queries, exact application numbers, or an approval date window.
3. Select a field when you need precise matching.
4. Keep `approvedOnly` enabled for approval-focused research.
5. Choose a useful `maxItems` limit.
6. Click **Start**.
7. Open the **Dataset** tab to preview, download, or integrate the results.

A quick first run:

```json
{
  "queries": ["ibuprofen"],
  "searchField": "activeIngredient",
  "approvedOnly": true,
  "includeSubmissions": true,
  "maxItems": 20
}
```

### Example: exact FDA application lookup

```json
{
  "applicationNumbers": ["NDA020267"],
  "approvedOnly": true,
  "includeSubmissions": true,
  "maxItems": 10
}
```

This returns the Drugs@FDA product under NDA020267, including sponsor, ibuprofen strength, dosage form, route, approved actions, and available FDA document links.

### Example: recurring regulatory monitoring

Use a bounded date window in an Apify Schedule:

```json
{
  "approvalDateFrom": "2024-01-01",
  "approvalDateTo": "2024-12-31",
  "approvedOnly": true,
  "includeSubmissions": true,
  "maxItems": 500
}
```

Store each run's dataset or connect a webhook to your comparison workflow. The Actor exports source snapshots; it does not itself send change alerts or compare prior runs.

### Example output

The shortened record below reflects the Actor's current product-level output:

```json
{
  "recordType": "product",
  "applicationNumber": "NDA020267",
  "sponsorName": "HALEON US HOLDINGS",
  "productNumber": "002",
  "brandName": "JUNIOR STRENGTH ADVIL",
  "genericNames": ["IBUPROFEN"],
  "activeIngredients": [{ "name": "IBUPROFEN", "strength": "100MG" }],
  "dosageForm": "TABLET",
  "route": "ORAL",
  "strength": "100MG",
  "marketingStatus": "Over-the-counter",
  "approvalDate": "1996-12-13",
  "latestActionDate": "2017-03-29",
  "labelDocuments": [
    {
      "id": "47861",
      "type": "Label",
      "date": "2017-04-05",
      "url": "https://www.accessdata.fda.gov/drugsatfda_docs/label/2017/020267Orig1s015lbl.pdf"
    }
  ],
  "sourceUrl": "https://www.accessdata.fda.gov/scripts/cder/daf/index.cfm?event=overview.process&ApplNo=020267"
}
```

The complete row also includes `submissions`, all application documents, NDCs, request provenance, and retrieval time.

### How much does it cost to search FDA drug approval records?

Pay per event pricing has two parts:

- **Start:** $0.005 once per run.
- **Item:** $0.013824 per saved record on the Bronze plan, with lower per-record rates on higher plans.

At the Bronze rate, 10 records cost about **$0.14324**, 100 records about **$1.38740**, and 1,000 records about **$13.82900**, including the start event. Apify compute is included in these event prices. Failed, duplicate, or rejected source rows are not charged as items.

The Actor emits one item event per saved application-product record. Approval actions and document links nested in that record have no separate charge.

### Pagination, limits, and reliability

The Actor requests up to 100 applications per official API page and stops when it reaches `maxItems` or source exhaustion. Because an application can contain multiple products, a page can produce more than one candidate row; the Actor stops exactly at the requested output limit.

openFDA allows pagination up to a 25,000-record skip boundary. Very broad date-only exports can therefore represent a bounded portion of a larger result set. Split large historical jobs into smaller date windows for more complete coverage.

Transient network errors, HTTP 429 responses, and temporary server errors are retried up to three times with exponential backoff. Invalid input and deterministic API errors fail the run instead of silently returning an empty successful dataset.

A genuine no-match query returns an empty dataset and a successful run.

### Search tips

- Use `activeIngredient` for precise ingredient portfolios.
- Use `brandName` when a common word creates noisy full-text matches.
- Submit exact application IDs through `applicationNumbers`.
- Split large sponsor or date searches into smaller tasks.
- Keep approval history enabled when label and approval-letter evidence matters.
- Use dataset field selection when exporting only a compact product table.

Search behavior follows openFDA's indexed Drugs@FDA fields. Product spelling and sponsor naming reflect the source; the Actor does not perform fuzzy entity resolution.

### Export and integration workflows

From the Dataset tab, export JSON, JSONL, CSV, Excel, XML, or RSS. Common workflows include:

1. Load application-product rows into a regulatory data warehouse.
2. Join `applicationNumber` to internal product or trial data.
3. Review newly observed `latestActionDate` values in a scheduled pipeline.
4. Download `labelDocuments` through a separate document-processing workflow.
5. Send completed-run webhooks to Make, Zapier, Slack, or your own API.

Document URLs are exported as links; this Actor does not download or parse PDF contents.

### Run with the Apify API

Replace `YOUR_TOKEN` with your Apify API token.

#### cURL

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~fda-drugs-approval-records-search/runs?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"queries":["ibuprofen"],"searchField":"activeIngredient","maxItems":20}'
```

#### JavaScript

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/fda-drugs-approval-records-search').call({
  applicationNumbers: ['NDA020267'],
  approvedOnly: true,
  maxItems: 10,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_TOKEN")
run = client.actor("automation-lab/fda-drugs-approval-records-search").call(run_input={
    "approvalDateFrom": "2024-01-01",
    "approvalDateTo": "2024-12-31",
    "maxItems": 25,
})
items = client.dataset(run["defaultDatasetId"]).list_items().items
print(items)
```

### Use with MCP and AI agents

Add the Actor to Claude Code through Apify MCP:

```bash
claude mcp add --transport http apify \
  "https://mcp.apify.com?tools=automation-lab/fda-drugs-approval-records-search"
```

#### Claude Desktop

Use this HTTP MCP configuration in Claude Desktop:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=automation-lab/fda-drugs-approval-records-search"
    }
  }
}
```

#### Cursor

Add the same `mcpServers.apify.url` value to Cursor's MCP settings.

#### VS Code

Add the same HTTP server URL through the VS Code MCP server configuration or command palette.

#### Example prompts

- "Look up Drugs@FDA application NDA020267 and summarize its products and latest approved action."
- "Find up to 50 ibuprofen products and group them by sponsor and dosage form."
- "Export FDA approval actions from a specified month and return the linked label documents."

Always review source records before using AI-generated regulatory conclusions.

### Responsible use and legal notes

The Actor retrieves public United States government data from openFDA and Drugs@FDA. FDA datasets can contain omissions, delays, corrections, and source-specific terminology. Follow FDA attribution and data-use guidance, and retain `sourceUrl`/`apiUrl` when provenance matters.

This tool is for research and automation. It does not provide medical, legal, or regulatory advice and should not be used as the sole basis for treatment, prescribing, investment, or compliance decisions. Verify material conclusions against current FDA source documents.

Do not use the service to overload the source. The Actor uses bounded sequential pagination and retries.

### Limitations

- The output reflects the openFDA Drugs@FDA update cycle, not real-time FDA decisions.
- Broad free-text search can match multiple indexed fields.
- Date filters apply to included submission actions, while each output row still represents the associated application product.
- Very broad queries are bounded by openFDA pagination and the requested `maxItems`.
- Some historical applications have incomplete product, NDC, action, or document fields.
- A label link may be absent even when an approved submission exists.
- FDA document links are normalized to HTTPS but availability remains controlled by FDA.
- The Actor does not parse label PDFs, compare runs, send alerts, or make regulatory judgments.

### Troubleshooting

**The run returned no records.** Check spelling, use `any`, remove a narrow date window, or try an exact application number. A valid no-match lookup intentionally produces an empty dataset.

**The API rejected my search.** Remove openFDA/Lucene operators from the query. The Actor escapes reserved query characters and is designed for ordinary names and identifiers.

**I reached fewer items than expected.** Filters can remove actions or duplicate products across queries. Inspect logs and the exact `apiUrl`, then split very broad date searches into smaller windows.

**The run failed after retries.** openFDA may be temporarily rate-limited or unavailable. Retry later; a failed run does not emit item charges for unsaved records.

**I only need product identity fields.** Set `includeSubmissions` to `false`; document arrays remain available while the larger submission-history array is omitted.

### Related Automation Lab Actors

- [FDA Drug Shortages Scraper](https://apify.com/automation-lab/fda-drug-shortages-scraper) — current and resolved shortage records, causes, and availability status.
- [openFDA Drug NDC Directory Scraper](https://apify.com/automation-lab/openfda-drug-ndc-directory-scraper) — NDC product and package directory records rather than approval actions.
- [PubMed Article Search Scraper](https://apify.com/automation-lab/pubmed-article-search-scraper) — literature metadata and abstracts for related scientific research.

These products solve different jobs. Choose this Actor when the central entity is a Drugs@FDA application/product and its regulatory actions.

### FAQ

#### Is this the same as an FDA drug shortage tracker?

No. Approval records describe applications, products, and regulatory actions. Shortage records describe availability problems. Use the related shortage Actor for supply monitoring.

#### Does the Actor require an openFDA API key?

No. It uses the official anonymous endpoint with bounded requests.

#### Can I search several drugs in one run?

Yes. Add up to 50 values to `queries`; results are deduplicated across them.

#### Can I look up NDA, ANDA, and BLA numbers?

Yes. Put exact identifiers in `applicationNumbers` or select `applicationNumber` as the search field.

#### Are approval letters and labels downloaded?

No. The dataset contains official links and document metadata. Use a document downloader or PDF extraction workflow when you need file contents.

#### Can I monitor changes?

Schedule recurring date-window runs and compare datasets in your own storage or automation. The Actor provides repeatable snapshots but does not maintain cross-run state or send alerts itself.

#### Is the data suitable for medical decisions?

No. Treat it as research data and verify current facts with FDA source pages and qualified professionals.

# Actor input Schema

## `queries` (type: `array`):

Drug names, active ingredients, sponsors, application numbers, or NDCs to find. Each query is searched independently and results are deduplicated.

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

Exact NDA, ANDA, or BLA application numbers, for example NDA020267.

## `searchField` (type: `string`):

Limit search queries to one Drugs@FDA field, or use Any field for broad full-text lookup.

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

Keep applications with an approval action on or after this date (YYYY-MM-DD).

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

Keep applications with an approval action on or before this date (YYYY-MM-DD).

## `approvedOnly` (type: `boolean`):

Include only submissions whose official status is approved (AP).

## `includeSubmissions` (type: `boolean`):

Include normalized submission actions and their FDA document links in each record.

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

Maximum deduplicated application-product records saved across all queries.

## Actor input object example

```json
{
  "queries": [
    "ibuprofen"
  ],
  "searchField": "any",
  "approvedOnly": true,
  "includeSubmissions": true,
  "maxItems": 20
}
```

# Actor output Schema

## `dataset` (type: `string`):

Default dataset containing all application-product records.

# 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 = {
    "queries": [
        "ibuprofen"
    ],
    "maxItems": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/fda-drugs-approval-records-search").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 = {
    "queries": ["ibuprofen"],
    "maxItems": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/fda-drugs-approval-records-search").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 '{
  "queries": [
    "ibuprofen"
  ],
  "maxItems": 20
}' |
apify call automation-lab/fda-drugs-approval-records-search --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,automation-lab/fda-drugs-approval-records-search"
        }
    }
}

```

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/S4XqOIO0Fwn6Jalbe/builds/8B1Aq8eSnfEclVu37/openapi.json