# FDA Approval Feed (`zinin/fda-approval-feed`) Actor

Watch drugs or companies for new FDA approvals and recalls. Official openFDA data, free, no API key or login. Get application status, sponsor, latest submission and recall details for every match.

- **URL**: https://apify.com/zinin/fda-approval-feed.md
- **Developed by:** [Tim Zinin](https://apify.com/zinin) (community)
- **Categories:** News, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $5.00 / 1,000 approval founds

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

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

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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 Approval Feed — New Drug Approvals & Recalls by Drug or Company

Point this Actor at a list of drug or company names and get back a live feed of confirmed new FDA drug approvals and product recalls — sponsor, approval date, recall classification and a direct Drugs@FDA link. Every field comes from official openFDA data: no scraping, no API key, no login.

### What you get

- **A verdict, not a guess.** An "approval" here means the drug's *original* application got FDA approval within the last 180 days — not any dated entry that happens to say "approved" somewhere in its history. See "Why 'approval' is stricter than it looks" below.
- **Recalls too.** Every matching enforcement action — firm, product, reason, classification (Class I/II/III) and current status.
- **Two datasets, one call.** Checks openFDA's Drugs@FDA (`drugsfda`) for approvals and its Enforcement database for recalls — pick one or both per run.
- Up to 25 names per run, concurrency up to 8.
- Runs on Apify: schedule it, monitor it, call it from the API or the MCP server, export to JSON, CSV or Excel, or push results straight into your own pipeline.

### Why it matters

Tracking new drug approvals and recalls for a watchlist of drugs or competitors today means manually polling drugs.fda.gov and accessdata.fda.gov by hand, or paying for a regulatory-intelligence SaaS seat. Most of that data is already free and public via openFDA — it just isn't shaped as a feed.

### Why "approval" is stricter than it looks

A drug or company name can rack up dozens of FDA submissions over the years — new dosage forms, label changes, manufacturing-site updates — and most of them are marked "approved" in openFDA's own records. None of that is news to someone watching for **new drugs reaching the market**. So this Actor only calls something an approval when the underlying submission is:

- the drug's **original** application (`submission_type: ORIG` — not `SUPPL`, a supplement to an already-marketed drug), *and*
- **fully approved** (`submission_status: AP` — not `TA`, tentative approval, which means the FDA signed off on the science but the drug still isn't on the market, usually pending patent litigation), *and*
- **recent** — approved within the last 180 days.

An application that matched your query but fails any of those three tests comes back as its own row with `found: false` and a plain-English reason, e.g. *"no original approval in the last 180 days; most recent submission on file is SUPPL/AP on 2026-04-06."* That row is not a bug — it means the drug you searched for has history on file, just nothing this feed calls a new approval, and it is **not charged for**. Search `Pfizer` and you will see mostly `found: false` rows for exactly this reason: a large company's catalog is almost entirely old, already-approved drugs getting routine supplements, not new approvals. Earlier versions of this Actor counted those as approvals — that was wrong, and it no longer does.

### How to run it

1. Click **Try for free** — no card needed on the free plan.
2. Paste drug or company names into **Queries**, one per line.
3. Choose **Dataset** — approvals only, recalls only, or both (default).
4. Press **Start**. Results appear in the dataset — read them in the UI, pull them from the API, or have a webhook push them onward.

### Pricing

Pay-per-event: **$0.005 per run start + $0.005 per result found**. No monthly seat, no minimum. 100 results cost about **$0.51**; 1,000 about **$5.01**.

Nothing is charged for a row you can't use: `found: false` rows — no match, a lookup error, or an application that doesn't clear the approval bar above — are returned for transparency but never billed.

### Input

| Field | Required | What it does |
|---|---|---|
| `queries` | yes | Drug or company names to watch, e.g. `pembrolizumab`, `Pfizer`, `semaglutide`. Up to 25 per run. |
| `dataset` | no | `approvals`, `recalls`, or `both` (default). |
| `limit` | no | Max results per query, per source (1–50, default 10). |
| `maxConcurrency` | no | Parallelism (1–8, default 3). openFDA's unauthenticated rate limit is 40 req/min. |

```json
{
    "queries": ["pembrolizumab", "semaglutide", "Pfizer"]
}
````

### Output

One row per matched application or recall event, per query. This is a real row from a real run:

```json
{
    "sourceQuery": "pembrolizumab",
    "found": true,
    "type": "recall",
    "product": "PEMBROLIZUMAB 200 MG / 100 ML NS IVPB, Rx Only, Infusion Options, Inc. 5924 13the Ave, Brooklyn, NY 11219-4934, 718-283-7233",
    "reason": "Lack of Assurance of Sterility",
    "classification": "Class II",
    "firm": "Infusion Options, Inc.",
    "reportDate": "2019-08-21",
    "status": "Terminated",
    "summary": "Infusion Options, Inc. recall (Class II) — PEMBROLIZUMAB 200 MG / 100 ML NS IVPB, Rx Only, Infusion Options, Inc. 5924 13the Ave, Brooklyn, NY 11219-4934, 718-283-7233 — Lack of Assurance of Sterility.",
    "checkedAt": "2026-07-26T13:58:04.917Z"
}
```

An approval row and a recall row share the same envelope but different fields:

| Field | What it means |
|---|---|
| `type` | `approval` or `recall` |
| `found` | `false` = no qualifying event: no match, a lookup error, or (approvals only) nothing clears the ORIG / AP / 180-day bar |
| `latestSubmission` *(approval rows)* | `{type: "ORIG", status: "AP", date}` — always the qualifying submission, never a supplement or a tentative approval |
| `classification` *(recall rows)* | FDA recall class: I (most serious) to III |
| `summary` | Human-readable one-liner |

`found: false` approval rows still say what is on file, e.g. *"KEYTRUDA (BLA125514) — no original approval in the last 180 days; most recent submission on file is SUPPL/AP on 2026-04-06."* — so a `Pfizer` search returning mostly `found: false` rows means exactly what it says: old drugs, routine supplements, nothing new to report.

#### Need the rest of the picture?

These run on the same account, take the same shape of input and bill the same way, so they slot into an existing pipeline without new plumbing.

| Actor | What it does |
|---|---|
| [Clinical Trials Monitor](https://apify.com/zinin/clinical-trials-monitor) | Watch conditions, drugs or sponsors for new and updated clinical trials |
| [AI Crawler Access Checker](https://apify.com/zinin/ai-crawler-access-checker) | Check which AI crawlers (GPTBot, ClaudeBot, PerplexityBot, Google-Extended & more) can access your website |
| [B2B Lead Enricher](https://apify.com/zinin/b2b-lead-enricher) | Turn a list of company websites into sales-qualified lead cards: detected tech stack, a rough revenue… |
| [Company Hiring Radar](https://apify.com/zinin/company-hiring-radar) | Pull every open role a company is hiring for from its public job board (Greenhouse, Lever, Ashby) and turn… |
| [Company Profile Lookup](https://apify.com/zinin/company-lookup) | Turn a domain or company name into one unified company card: website tech stack (CMS, ecommerce, key tech)… |

### FAQ

**Does it need an API key or login?** No — openFDA's public endpoints are keyless; this Actor uses no credentials.

**How fresh is the data?** As fresh as openFDA itself — updated on the FDA's own publishing schedule, typically within days of an approval or recall being posted.

**Why did my company search come back mostly `found: false`?** Because most of what a large pharma company has on file is old drugs getting routine label or manufacturing updates, not new approvals — see "Why 'approval' is stricter than it looks" above. That's the filter working, not a broken query.

**Why do I get more than one row per query?** A name can match several applications (different dosage forms) or several recall events. Each match is its own row so nothing gets silently merged.

**Can I call it from an AI agent?** Yes — it's a standard Apify Actor, callable via the Apify API or the Apify MCP server.

**What this is NOT.** It does not report tentative approvals, supplements to already-marketed drugs, or old applications as "new" — see above. It does not evaluate drug safety or efficacy, and it does not replace a subscription regulatory-intelligence service for legal or clinical decisions.

This Actor surfaces public FDA data (openFDA) for monitoring and research. **It is not medical advice.** openFDA's own terms are explicit that its data must not be used to make medical decisions — consult a healthcare professional and the FDA's own record for any decision about a specific drug.

Found a wrong result, or need a check we don't run? Open an issue on this Actor's page.

***

Built by [zinin](https://apify.com/zinin). Questions? Telegram [@timzinin](https://t.me/timzinin).

# Actor input Schema

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

Drug or company names to watch (e.g. `pembrolizumab`, `Pfizer`, `semaglutide`). One row per query.

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

Which openFDA feed to check.

## `limit` (type: `integer`):

Max results to pull per query, per source (approvals/recalls).

## `maxConcurrency` (type: `integer`):

How many queries to process in parallel.

## Actor input object example

```json
{
  "queries": [
    "pembrolizumab",
    "semaglutide",
    "Pfizer"
  ],
  "dataset": "both",
  "limit": 10,
  "maxConcurrency": 3
}
```

# 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": [
        "pembrolizumab",
        "semaglutide",
        "Pfizer"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("zinin/fda-approval-feed").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": [
        "pembrolizumab",
        "semaglutide",
        "Pfizer",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("zinin/fda-approval-feed").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 '{
  "queries": [
    "pembrolizumab",
    "semaglutide",
    "Pfizer"
  ]
}' |
apify call zinin/fda-approval-feed --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=zinin/fda-approval-feed",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "FDA Approval Feed",
        "description": "Watch drugs or companies for new FDA approvals and recalls. Official openFDA data, free, no API key or login. Get application status, sponsor, latest submission and recall details for every match.",
        "version": "0.1",
        "x-build-id": "cZnHi23kr8U1c1lT3"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/zinin~fda-approval-feed/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-zinin-fda-approval-feed",
                "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/zinin~fda-approval-feed/runs": {
            "post": {
                "operationId": "runs-sync-zinin-fda-approval-feed",
                "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/zinin~fda-approval-feed/run-sync": {
            "post": {
                "operationId": "run-sync-zinin-fda-approval-feed",
                "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",
                "required": [
                    "queries"
                ],
                "properties": {
                    "queries": {
                        "title": "Queries",
                        "maxItems": 25,
                        "type": "array",
                        "description": "Drug or company names to watch (e.g. `pembrolizumab`, `Pfizer`, `semaglutide`). One row per query.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "dataset": {
                        "title": "Dataset",
                        "enum": [
                            "approvals",
                            "recalls",
                            "both"
                        ],
                        "type": "string",
                        "description": "Which openFDA feed to check.",
                        "default": "both"
                    },
                    "limit": {
                        "title": "Limit per source",
                        "minimum": 1,
                        "maximum": 50,
                        "type": "integer",
                        "description": "Max results to pull per query, per source (approvals/recalls).",
                        "default": 10
                    },
                    "maxConcurrency": {
                        "title": "Max concurrency",
                        "minimum": 1,
                        "maximum": 8,
                        "type": "integer",
                        "description": "How many queries to process in parallel.",
                        "default": 3
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
