# FDA Recalls Scraper - Drug, Device & Food (`maydit/us-fda-recalls-scraper`) Actor

Scrape & monitor FDA drug, medical device, and food recalls from the openFDA enforcement API in one run. Filter by type, class, state, and date. Export CSV/JSON.

- **URL**: https://apify.com/maydit/us-fda-recalls-scraper.md
- **Developed by:** [Brandt May](https://apify.com/maydit) (community)
- **Categories:** Business, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $5.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 Recalls Scraper - Drug, Device & Food Recall Data from openFDA

> Monitor and export US FDA recalls for drugs, medical devices, and food in a single run - straight from the official openFDA enforcement API.

### What it does

This **FDA recalls scraper** pulls US FDA recall enforcement data for drugs, medical devices, and food by querying the public **openFDA enforcement API** (no API key required) and returning one clean, normalized record per recall. It unifies all three FDA product categories in one place, so you no longer have to run a separate **FDA drug recall API** query, an **FDA medical device recall** search, and an **FDA food recall API** call to assemble a complete picture. Each record captures the recall's severity (Class I/II/III), status, product and reason for recall, the recalling firm and its location, distribution pattern, brand and generic names, key dates, and the FDA recall number. Filter by product type, keyword, classification, status, firm state, and date range, then schedule it for continuous **FDA recall monitoring** and alerting.

### Who it's for

- **Pharma, medical-device, and food-safety compliance / regulatory affairs** teams tracking recalls in their category
- **Quality assurance** teams monitoring their own products and lot/batch codes
- **Supply-chain and supplier-risk** managers surveilling vendors and contract manufacturers
- **Insurers and underwriters** assessing product-liability and recall exposure
- **Legal / class-action researchers** building recall and incident timelines
- **Journalists and data teams** covering public-health and consumer-safety stories
- **Developers** who want structured openFDA enforcement data without writing and maintaining API plumbing

### What you get / Output

One row per recall, with the following fields:

| Field | Description |
|---|---|
| `productType` | FDA category: `drug`, `device`, or `food` |
| `recallNumber` | FDA-assigned recall identifier |
| `classification` | Severity: `Class I` (most serious), `Class II`, or `Class III` |
| `status` | Recall status (e.g. Ongoing, Completed, Terminated) |
| `productDescription` | Description of the recalled product |
| `reasonForRecall` | Why the product was recalled |
| `recallingFirm` | Company that issued the recall |
| `city` | City of the recalling firm |
| `state` | US state of the recalling firm |
| `country` | Country of the recalling firm |
| `distributionPattern` | Where the recalled product was distributed |
| `brandNames` | Brand name(s), when available |
| `genericNames` | Generic name(s), when available |
| `reportDate` | Date the recall was reported/published by FDA |
| `recallInitiationDate` | Date the firm initiated the recall |
| `terminationDate` | Date the recall was terminated, when applicable |

Export the dataset to **CSV, Excel, JSON, or XML** from the run's Storage tab, or pull it programmatically via the Apify API.

### Input / How to query

All filters are optional - run with defaults to pull recent recalls across all three categories, or narrow the query:

- **Product types** - any combination of `drug`, `device`, and `food` (defaults to all three)
- **Keyword** - match against product description, reason for recall, or recalling firm (e.g. `listeria`, `salmonella`, a drug name, or a company name)
- **Classification** - `Class I`, `Class II`, or `Class III`
- **Status** - e.g. Ongoing, Completed, Terminated
- **Recalling firm state** - two-letter US state code (e.g. `CA`, `NJ`)
- **Reported since / Reported until** - date window (`YYYY-MM-DD`) on the FDA report date
- **Max results** - upper bound on recalls returned per run

### Example use cases

- **Track a supplier or manufacturer:** set a keyword to a firm name and schedule weekly runs to catch every new recall tied to that company.
- **Class I early warning:** filter to `Class I` across all product types to surface only the most serious, potential-harm recalls for immediate triage.
- **Food-safety pathogen watch:** filter product type to `food` with keyword `listeria` or `salmonella` and a rolling date window.
- **Device-recall register:** pull all `device` recalls for a given state and date range to feed a compliance dashboard.
- **Recall dataset for analysis:** export a full historical slice to CSV for BI, risk scoring, or research.

### Recurring use / scheduling

Add the actor to an Apify **Schedule** (for example, every Monday) with a `Reported since` date set to roughly the last week to poll for **new FDA recalls** on an ongoing basis. Because the actor returns a stable `recallNumber` per recall, you can dedupe incrementally on that field to keep only genuinely new records and wire the fresh rows into email, Slack, or webhook **recall alerts**. Note that FDA publishes enforcement data on a roughly weekly cycle, so the newest recalls can lag one to two weeks.

### FAQ

### How do I get FDA recall data via API?

This actor queries the official **openFDA enforcement API** for you and returns normalized, ready-to-use records - no openFDA API key or query-building required. Run it in the Apify Console or trigger it via the Apify API, then read results from the dataset.

### How can I monitor FDA drug, device, and food recalls in one place?

That is exactly what this actor is built for. One run covers drugs, medical devices, and food together, so you get a unified recall feed instead of stitching together three separate single-category tools.

### How do I export FDA recall data to CSV or Excel?

After a run, open the dataset in the run's Storage tab and export to CSV, Excel, JSON, or XML with one click, or fetch it programmatically through the Apify dataset API.

### How do I search FDA recalls by company or recalling firm?

Set the **keyword** filter to the company name - it matches against the recalling firm (and product description and reason), and each result includes the `recallingFirm`, `city`, and `state` fields.

### How often is openFDA recall (enforcement) data updated?

The FDA publishes enforcement (recall) data on a roughly weekly cycle, so the freshest recalls can appear one to two weeks after initiation. Scheduling a weekly run keeps your dataset current.

### How do I filter FDA recalls by classification (Class I, II, III)?

Use the **classification** filter to restrict results to `Class I`, `Class II`, or `Class III`. Class I is the most serious (risk of death or serious harm); Class III is least serious.

### How can I set up automated alerts for new FDA recalls?

Schedule the actor with a rolling `Reported since` date, dedupe on `recallNumber`, and connect the new rows to an integration (email, Slack, or webhook) so each run pushes only newly published recalls.

### What is the openFDA enforcement endpoint and how do I use it?

The openFDA enforcement endpoints expose the FDA's public drug, device, and food recall records. This actor calls those endpoints on your behalf and normalizes the fields into a consistent schema, so you do not have to learn the endpoint syntax yourself.

### How do I track recalls for a specific manufacturer or supplier?

Set the **keyword** to the manufacturer or supplier name and add it to a recurring schedule. Every run returns any new recalls mentioning that firm, giving you continuous supplier surveillance.

### Can I get FDA recalls filtered by state or date range?

Yes. Use the **recalling firm state** filter (two-letter code) and the **Reported since / Reported until** date window to scope results by geography and time.

### Data source & notes

- **Source:** the official US FDA **openFDA** enforcement (recall) API for drugs, devices, and food. This is public, government-published data and does not require an API key.
- **Coverage:** US FDA-regulated recalls only. This actor does not cover other agencies (such as CPSC or NHTSA) or non-US regulators - it stays focused on FDA drug, device, and food recalls.
- **Freshness:** FDA publishes enforcement data on a roughly weekly cadence, so newly initiated recalls may take one to two weeks to appear.
- **Fields:** availability of optional fields (such as brand/generic names or termination date) depends on what the FDA published for a given recall.

# Actor input Schema

## `productTypes` (type: `array`):

Which FDA-regulated product categories to pull recalls for.
## `keyword` (type: `string`):

Filter recalls whose product description, recall reason, or recalling firm matches this term — e.g. 'listeria', 'salmonella', a drug name, or a company name. Leave empty for all.
## `classification` (type: `string`):

Class I = most serious (risk of death/serious harm), Class II = temporary/reversible harm, Class III = unlikely to cause harm. Leave empty for all.
## `status` (type: `string`):

Ongoing = still active. Leave empty for all.
## `state` (type: `string`):

Two-letter US state of the recalling firm, e.g. 'CA', 'NJ'. Leave empty for all.
## `reportedSince` (type: `string`):

Only recalls reported on or after this date (YYYY-MM-DD). Great for weekly monitoring. Note: FDA publishes enforcement data on a ~weekly cycle, so the newest recalls can lag 1-2 weeks.
## `reportedUntil` (type: `string`):

Only recalls reported on or before this date (YYYY-MM-DD).
## `maxResults` (type: `integer`):

Upper bound on recalls returned per run (across all selected product types).

## Actor input object example

```json
{
  "productTypes": [
    "drug",
    "device",
    "food"
  ],
  "keyword": "listeria",
  "reportedSince": "2026-06-01",
  "maxResults": 1000
}
````

# 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("maydit/us-fda-recalls-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("maydit/us-fda-recalls-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 maydit/us-fda-recalls-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "FDA Recalls Scraper - Drug, Device & Food",
        "description": "Scrape & monitor FDA drug, medical device, and food recalls from the openFDA enforcement API in one run. Filter by type, class, state, and date. Export CSV/JSON.",
        "version": "1.0",
        "x-build-id": "qXCV8b2XMfDeWamI2"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/maydit~us-fda-recalls-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-maydit-us-fda-recalls-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/maydit~us-fda-recalls-scraper/runs": {
            "post": {
                "operationId": "runs-sync-maydit-us-fda-recalls-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/maydit~us-fda-recalls-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-maydit-us-fda-recalls-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": {
                    "productTypes": {
                        "title": "Product types",
                        "type": "array",
                        "description": "Which FDA-regulated product categories to pull recalls for.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "drug",
                                "device",
                                "food"
                            ],
                            "enumTitles": [
                                "Drugs",
                                "Medical devices",
                                "Food"
                            ]
                        },
                        "default": [
                            "drug",
                            "device",
                            "food"
                        ]
                    },
                    "keyword": {
                        "title": "Keyword",
                        "type": "string",
                        "description": "Filter recalls whose product description, recall reason, or recalling firm matches this term — e.g. 'listeria', 'salmonella', a drug name, or a company name. Leave empty for all."
                    },
                    "classification": {
                        "title": "Recall classification",
                        "enum": [
                            "Class I",
                            "Class II",
                            "Class III"
                        ],
                        "type": "string",
                        "description": "Class I = most serious (risk of death/serious harm), Class II = temporary/reversible harm, Class III = unlikely to cause harm. Leave empty for all."
                    },
                    "status": {
                        "title": "Recall status",
                        "enum": [
                            "Ongoing",
                            "Completed",
                            "Terminated"
                        ],
                        "type": "string",
                        "description": "Ongoing = still active. Leave empty for all."
                    },
                    "state": {
                        "title": "Recalling firm state",
                        "type": "string",
                        "description": "Two-letter US state of the recalling firm, e.g. 'CA', 'NJ'. Leave empty for all."
                    },
                    "reportedSince": {
                        "title": "Reported since",
                        "type": "string",
                        "description": "Only recalls reported on or after this date (YYYY-MM-DD). Great for weekly monitoring. Note: FDA publishes enforcement data on a ~weekly cycle, so the newest recalls can lag 1-2 weeks."
                    },
                    "reportedUntil": {
                        "title": "Reported until",
                        "type": "string",
                        "description": "Only recalls reported on or before this date (YYYY-MM-DD)."
                    },
                    "maxResults": {
                        "title": "Max results",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Upper bound on recalls returned per run (across all selected product types).",
                        "default": 1000
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```