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

Scrape FDA recall data for food, drugs, and medical devices. Get recall reasons, severity classifications, product descriptions, recalling firms, distribution patterns, and key dates. Filter by product type, class (I/II/III), status, state, and date range. Covers 84,000+ recalls.

- **URL**: https://apify.com/parseforge/fda-recalls-scraper.md
- **Developed by:** [ParseForge](https://apify.com/parseforge) (community)
- **Categories:** Automation, Developer tools, Other
- **Stats:** 3 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $6.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.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

![ParseForge Banner](https://raw.githubusercontent.com/ParseForge/apify-assets/main/banner.jpg)

## 🏥 FDA Recalls Scraper - Food, Drug & Device Safety

🚀 Collect structured FDA recall data for food, drugs, and medical devices. Get recall reasons, severity classifications, product descriptions, recalling firms, distribution patterns, and key dates from 84,000+ enforcement records.

🕒 Last updated: 2026-04-23

Whether you are a compliance officer monitoring product safety, a supply chain manager tracking recalls across your vendor network, or a researcher analyzing FDA enforcement trends, this tool delivers clean, structured recall data from the official openFDA enforcement database.

The FDA Recalls Scraper pulls enforcement actions for food, drugs, and medical devices. Every record includes recall reasons, classification levels (I/II/III), product descriptions, recalling firms, distribution patterns, and key dates. Filter by product type, classification severity, status, state, and date range to focus on exactly what matters to your team.

| | |
|---|---|
| **Target Audience** | Compliance officers, supply chain managers, food safety researchers, pharmaceutical companies, healthcare organizations, journalists |
| **Primary Use Cases** | Product safety monitoring, supply chain risk assessment, enforcement trend analysis, competitor recall tracking, regulatory research |

---

### 📋 What Does It Do

- Collects food safety recalls including contamination, allergen, and labeling issues
- Tracks pharmaceutical recall actions, dosage errors, and contamination events
- Monitors medical device safety issues, malfunctions, and defects
- Searches by keyword, classification severity, status, state, and date range
- Accesses 84,000+ records across food (28K+), drugs (17K+), and medical devices (38K+)
- Delivers 22+ structured data fields per recall record

---

### 🎬 How to Use - Full Demo

🚧 Demo video coming soon.

---

### ⚙️ Input

<table>
  <tr>
    <th>Field</th>
    <th>Type</th>
    <th>Description</th>
    <th>Default</th>
  </tr>
  <tr>
    <td><strong>Product Type</strong></td>
    <td>string</td>
    <td>Choose Food, Drugs, Medical Devices, or All Types</td>
    <td>all</td>
  </tr>
  <tr>
    <td><strong>Max Items</strong></td>
    <td>integer</td>
    <td>Free users: limited to 10 items. Paid users: up to 1,000,000</td>
    <td>10</td>
  </tr>
  <tr>
    <td><strong>Search Query</strong></td>
    <td>string</td>
    <td>Search across all fields (e.g., salmonella, peanut butter, insulin)</td>
    <td>-</td>
  </tr>
  <tr>
    <td><strong>Classification</strong></td>
    <td>string</td>
    <td>Class I (most serious), Class II, or Class III</td>
    <td>-</td>
  </tr>
  <tr>
    <td><strong>Status</strong></td>
    <td>string</td>
    <td>Ongoing, Terminated, or Completed</td>
    <td>-</td>
  </tr>
  <tr>
    <td><strong>State</strong></td>
    <td>string</td>
    <td>Filter by state where the recalling firm is located (e.g., CA, TX)</td>
    <td>-</td>
  </tr>
  <tr>
    <td><strong>Report Date From</strong></td>
    <td>string</td>
    <td>Only include recalls reported on or after this date (YYYYMMDD)</td>
    <td>-</td>
  </tr>
  <tr>
    <td><strong>Report Date To</strong></td>
    <td>string</td>
    <td>Only include recalls reported on or before this date (YYYYMMDD)</td>
    <td>-</td>
  </tr>
</table>

**Example 1:**

```json
{
    "productType": "food",
    "maxItems": 100,
    "searchQuery": "salmonella",
    "classification": "Class I",
    "status": "Ongoing"
}
````

**Example 2:**

```json
{
    "productType": "drug",
    "maxItems": 50,
    "state": "CA",
    "dateFrom": "20260101"
}
```

⚠️ Class I recalls indicate a reasonable probability of serious health consequences or death. Always verify critical safety decisions with official FDA sources.

***

### 📊 Output

🧾 **Schema:** recallNumber, productType, classification, status, recallingFirm, productDescription, reasonForRecall, productQuantity, distributionPattern, city, state, reportDate, scrapedAt

📦 **Sample 1:**

```json
{
    "recallNumber": "F-0276-2017",
    "productType": "food",
    "classification": "Class II",
    "status": "Terminated",
    "recallingFirm": "Pharmatech LLC",
    "productDescription": "CytoDetox, Dietary supplement",
    "reasonForRecall": "Potential risk of product contamination with Burkholderia cepacia.",
    "productQuantity": "1,990 bottles",
    "distributionPattern": "FL, MI, MS, and OH.",
    "city": "Davie",
    "state": "FL",
    "reportDate": "20161102",
    "scrapedAt": "2026-04-07T12:00:00.000Z"
}
```

📦 **Sample 2:**

```json
{
    "recallNumber": "D-1234-2026",
    "productType": "drug",
    "classification": "Class I",
    "status": "Ongoing",
    "recallingFirm": "National Pharma Inc.",
    "productDescription": "Metformin HCl Tablets, 500mg",
    "reasonForRecall": "NDMA impurity above acceptable daily intake limit.",
    "productQuantity": "50,000 bottles",
    "distributionPattern": "Nationwide",
    "city": "Philadelphia",
    "state": "PA",
    "reportDate": "20260315",
    "scrapedAt": "2026-04-07T12:00:00.000Z"
}
```

📦 **Sample 3:**

```json
{
    "recallNumber": "Z-5678-2025",
    "productType": "device",
    "classification": "Class III",
    "status": "Completed",
    "recallingFirm": "MedTech Solutions Corp.",
    "productDescription": "Sterile wound dressing kit",
    "reasonForRecall": "Labeling error: incorrect instructions for use.",
    "productQuantity": "12,000 units",
    "distributionPattern": "CA, TX, and NY.",
    "city": "San Jose",
    "state": "CA",
    "reportDate": "20250810",
    "scrapedAt": "2026-04-07T12:00:00.000Z"
}
```

***

### ✨ Why Choose This Tool?

| Feature | Details |
|---------|---------|
| Complete FDA database | Access 84,000+ recall records across food, drugs, and medical devices |
| 22+ structured fields | Every record includes classification, reasons, distribution, dates, and more |
| Powerful filtering | Search by product type, classification, status, state, and date range |
| Real-time data | 100 recalls in about 1 second directly from the official openFDA API |
| No coding required | Point-and-click interface with JSON, CSV, and Excel export |
| Scheduled monitoring | Set up daily or weekly runs to catch new recalls automatically |
| Pay-per-event support | Only pay for the data you actually use |

***

### 📈 How It Compares

| Capability | This Tool | Other Solutions |
|------------|-----------|-----------------|
| Output fields | 22+ structured fields per record | 8-12 basic fields |
| Product types | Food, drugs, devices, and all combined | Usually one type only |
| Batch collection | Up to 1,000,000 records per run | Manual page-by-page browsing |
| Filtering | Keyword, classification, status, state, date range | Limited or no filtering |
| Export formats | JSON, CSV, Excel | HTML pages only |
| Automated scheduling | Daily/weekly monitoring | Manual visits required |

***

### 🚀 How to Use

1. **Sign Up** - [Create a free account w/ $5 credit](https://console.apify.com/sign-up?fpr=vmoqkp) (takes 2 minutes)
2. **Find the Tool** - Search for "FDA Recalls Scraper" in the Apify Store
3. **Set Input** - Configure your search filters using the simple form
4. **Run It** - Click "Start" and let it collect your data
5. **Download Data** - Get your results in the "Dataset" tab as CSV, Excel, or JSON

***

### 💼 Business Use Cases

| Audience | How They Use It |
|----------|----------------|
| **Compliance Teams** | Monitor recalls daily to ensure your products and suppliers are not affected by safety actions |
| **Supply Chain Managers** | Track recalls across your supplier network and distribution channels to mitigate risk |
| **Food Safety Researchers** | Analyze contamination patterns, recall trends, and enforcement actions across the industry |
| **Pharmaceutical Companies** | Monitor drug recalls and enforcement actions to stay ahead of regulatory changes |

***

### ✨ Why choose this Actor

| | Capability |
|---|---|
| 🎯 | **Built for the job.** Scoped specifically to this data source so you skip the parser engineering entirely. |
| 🔖 | **Structured output.** Clean, typed fields ready for analysis, dashboards, or downstream pipelines. |
| ⚡ | **Fast.** Optimized request patterns return results in seconds, not minutes. |
| 🔁 | **Always fresh.** Every run pulls live data, so the dataset reflects the source as of run time. |
| 🌐 | **No infra to manage.** Apify handles proxies, retries, scaling, scheduling, and storage. |
| 🛡️ | **Reliable.** Battle-tested across many runs and edge cases, with graceful error handling. |
| 🚫 | **No code required.** Configure in the UI, run from CLI, schedule via cron, or call from any language with the Apify SDK. |

> 📊 Production-grade structured data without the engineering overhead of building and maintaining your own scraper.

***

### 📈 How it compares to alternatives

| Approach | Cost | Coverage | Refresh | Filters | Setup |
|---|---|---|---|---|---|
| **⭐ FDA Recalls Scraper - Food, Drug & Device Safety** *(this Actor)* | $5 free credit, then pay-per-use | Full source coverage | **Live per run** | Source-native filters supported | ⚡ 2 min |
| Build your own scraper | Engineering hours | Full once built | Whenever you maintain it | Custom code | 🐢 Days to weeks |
| Paid managed APIs | $$$ monthly | Vendor-defined | Live | Vendor-defined | ⏳ Hours |
| Third-party data dumps | Varies | Subset, often stale | Periodic | None | 🕒 Variable |

Pick this Actor when you want broad coverage, server-side filtering, and no pipeline maintenance.

***

### 🚀 How to use

1. 📝 **Sign up.** [Create a free account with $5 credit](https://console.apify.com/sign-up?fpr=vmoqkp) (takes 2 minutes).
2. 🌐 **Open the Actor.** Go to the FDA Recalls Scraper - Food, Drug & Device Safety page on the Apify Store.
3. 🎯 **Set input.** Configure the input fields in the form (or paste a JSON), then set `maxItems`.
4. 🚀 **Run it.** Click **Start** and let the Actor collect your data.
5. 📥 **Download.** Grab your results in the **Dataset** tab as CSV, Excel, JSON, or XML.

> ⏱️ Total time from signup to downloaded dataset: **3-5 minutes.** No coding required.

***

### 💼 Business use cases

<table>
<tr>
<td width="50%" valign="top">

#### 📊 Data & Analytics

- Build trend reports and dashboards from live source data
- Feed BI tools, warehouses, and ML pipelines with structured records
- Run periodic snapshots to track changes over time
- Compare segments, regions, or categories with consistent fields

</td>
<td width="50%" valign="top">

#### 🏢 Operations & Strategy

- Monitor competitor moves, pricing, and inventory shifts
- Build internal directories and lookup tools backed by current data
- Power workflows that depend on fresh source records
- Cut manual data-gathering time from hours to minutes

</td>
</tr>
<tr>
<td width="50%" valign="top">

#### 🎯 Marketing & Growth

- Identify market opportunities and trending topics
- Research target audiences and customer personas at scale
- Power lead-generation pipelines with verified records
- Track sentiment, reviews, or social signals over time

</td>
<td width="50%" valign="top">

#### 🛠️ Engineering & Product

- Prototype features that need real-world data without owning a crawler
- Replace fragile in-house scrapers with a managed Actor
- Wire datasets into your apps via the Apify API or webhooks
- Skip the proxy, retry, and parsing maintenance entirely

</td>
</tr>
</table>

***

### 🌟 Beyond business use cases

Data like this powers more than commercial workflows. The same structured records support research, education, civic projects, and personal initiatives.

<table>
<tr>
<td width="50%">

#### 🎓 Research and academia

- Empirical datasets for papers, thesis work, and coursework
- Longitudinal studies tracking changes across snapshots
- Reproducible research with cited, versioned data pulls
- Classroom exercises on data analysis and ethical scraping

</td>
<td width="50%">

#### 🎨 Personal and creative

- Side projects, portfolio demos, and indie app launches
- Data visualizations, dashboards, and infographics
- Content research for bloggers, YouTubers, and podcasters
- Hobbyist collections and personal trackers

</td>
</tr>
<tr>
<td width="50%">

#### 🤝 Non-profit and civic

- Transparency reporting and accountability projects
- Advocacy campaigns backed by public-interest data
- Community-run databases for local issues
- Investigative journalism on public records

</td>
<td width="50%">

#### 🧪 Experimentation

- Prototype AI and machine-learning pipelines with real data
- Validate product-market hypotheses before engineering spend
- Train small domain-specific models on niche corpora
- Test dashboard concepts with live input

</td>
</tr>
</table>

### 🔌 Automating Your Workflow

Schedule this tool to run daily, weekly, or monthly through the Apify platform. Set it and forget it. Your data will be waiting in your dataset every time. Combine with webhooks to trigger downstream actions whenever a run completes.

***

### 🤖 Ask an AI assistant about this scraper

Open a ready-to-send prompt about this ParseForge actor in the AI of your choice:

- 💬 [**ChatGPT**](https://chat.openai.com/?q=How%20do%20I%20use%20the%20FDA%20Recalls%20Scraper%20-%20Food%2C%20Drug%20%26%20Device%20Safety%20by%20ParseForge%20on%20Apify%3F%20Show%20me%20input%20examples%2C%20output%20fields%2C%20common%20use%20cases%2C%20and%20how%20to%20integrate%20it%20into%20a%20workflow.)
- 🧠 [**Claude**](https://claude.ai/new?q=How%20do%20I%20use%20the%20FDA%20Recalls%20Scraper%20-%20Food%2C%20Drug%20%26%20Device%20Safety%20by%20ParseForge%20on%20Apify%3F%20Show%20me%20input%20examples%2C%20output%20fields%2C%20common%20use%20cases%2C%20and%20how%20to%20integrate%20it%20into%20a%20workflow.)
- 🔍 [**Perplexity**](https://perplexity.ai/search?q=How%20do%20I%20use%20the%20FDA%20Recalls%20Scraper%20-%20Food%2C%20Drug%20%26%20Device%20Safety%20by%20ParseForge%20on%20Apify%3F%20Show%20me%20input%20examples%2C%20output%20fields%2C%20common%20use%20cases%2C%20and%20how%20to%20integrate%20it%20into%20a%20workflow.)
- 🅒 [**Copilot**](https://copilot.microsoft.com/?q=How%20do%20I%20use%20the%20FDA%20Recalls%20Scraper%20-%20Food%2C%20Drug%20%26%20Device%20Safety%20by%20ParseForge%20on%20Apify%3F%20Show%20me%20input%20examples%2C%20output%20fields%2C%20common%20use%20cases%2C%20and%20how%20to%20integrate%20it%20into%20a%20workflow.)

***

### ❓ Frequently Asked Questions

**Q1: What do the classification levels mean?**
Class I means there is a reasonable probability of serious health consequences or death. Class II means the product may cause temporary or medically reversible health problems. Class III means the product is unlikely to cause adverse health consequences.

**Q2: How many recalls are available?**
The database contains 84,000+ recall records across food (28K+), drugs (17K+), and medical devices (38K+).

**Q3: Can I search for specific products?**
Yes. Use the Search Query field to find recalls for specific products, ingredients, or issues such as listeria, infant formula, or hip implant.

**Q4: How fast is it?**
Very fast. 100 recalls take about 1 second. The data comes directly from the official openFDA API.

**Q5: Can I filter by state?**
Yes. Enter a two-letter state abbreviation (e.g., CA, TX, NY) to filter recalls by the state where the recalling firm is located.

**Q6: What date format should I use?**
Use YYYYMMDD format for date filters (e.g., 20260101 for January 1, 2026).

**Q7: Can I schedule regular runs?**
Yes. Use the Apify scheduler to run this tool daily, weekly, or monthly. Integrate with Make, Zapier, or Slack for automated notifications.

**Q8: Is this data official?**
Yes. All data comes directly from the official openFDA enforcement API maintained by the U.S. Food and Drug Administration.

**Q9: What export formats are available?**
You can download results as JSON, CSV, or Excel files from the Apify platform.

**Q10: Do I need an API key?**
No. This tool handles all authentication automatically. Just configure your search and click Start.

**Q11: Can I collect all recalls at once?**
Yes. Paid users can collect up to 1,000,000 records per run. Free users are limited to 10 items for preview.

**Q12: How often is the FDA database updated?**
The openFDA enforcement database is updated weekly by the FDA with new recall announcements.

***

### 🔌 Integrate with Your Favorite Apps

- [Make](https://docs.apify.com/platform/integrations/make) - Build automated workflows
- [Zapier](https://docs.apify.com/platform/integrations/zapier) - Connect 5,000+ apps
- [Slack](https://docs.apify.com/platform/integrations/slack) - Get instant notifications
- [Airbyte](https://docs.apify.com/platform/integrations/airbyte) - Sync to data warehouses
- [GitHub](https://docs.apify.com/platform/integrations/github) - Version control integration
- [Google Drive](https://docs.apify.com/platform/integrations/drive) - Export to spreadsheets

***

### 🔌 Integrate with any app

FDA Recalls Scraper - Food, Drug & Device Safety connects to any cloud service via [Apify integrations](https://apify.com/integrations):

- [**Make**](https://docs.apify.com/platform/integrations/make) - Automate multi-step workflows
- [**Zapier**](https://docs.apify.com/platform/integrations/zapier) - Connect with 5,000+ apps
- [**Slack**](https://docs.apify.com/platform/integrations/slack) - Get run notifications in your channels
- [**Airbyte**](https://docs.apify.com/platform/integrations/airbyte) - Pipe results into your warehouse
- [**GitHub**](https://docs.apify.com/platform/integrations/github) - Trigger runs from commits and releases
- [**Google Drive**](https://docs.apify.com/platform/integrations/drive) - Export datasets straight to Sheets

You can also use webhooks to trigger downstream actions when a run finishes. Push fresh data into your product backend, or alert your team in Slack.

***

### 🔗 Recommended Actors

Looking for more data collection tools? Check out these related actors:

| Actor | Description | Link |
|-------|-------------|------|
| Federal Register Scraper | Collect regulatory notices, rules, and presidential documents | [Federal Register Scraper](https://apify.com/parseforge/federal-register-regulatory-notices-rules-scraper) |
| GSA eLibrary Scraper | Extract government contract and vendor data | [GSA eLibrary Scraper](https://apify.com/parseforge/gsa-elibrary-scraper) |
| FINRA BrokerCheck Scraper | Look up broker and financial advisor registration data | [FINRA BrokerCheck Scraper](https://apify.com/parseforge/finra-brokercheck-scraper) |
| FAA Aircraft Registry Scraper | Extract aircraft registration and ownership data | [FAA Aircraft Registry Scraper](https://apify.com/parseforge/faa-aircraft-registry-scraper) |
| PR Newswire Scraper | Collect press releases and corporate news | [PR Newswire Scraper](https://apify.com/parseforge/pr-newswire-scraper) |

**Pro Tip:** 💡 Browse our complete collection of [data collection actors](https://apify.com/parseforge) to find the perfect tool for your business needs.

***

### 🆘 Need Help?

- Check the FAQ section above for common questions
- Visit the [Apify documentation](https://docs.apify.com) for platform guides
- Contact us at [Tally contact form](https://tally.so/r/BzdKgA)

***

> **⚠️ Disclaimer:** This Actor is an independent tool and is not affiliated with, endorsed by, or connected to the U.S. Food and Drug Administration (FDA). It accesses only publicly available data through the official openFDA API.

# Actor input Schema

## `productType` (type: `string`):

Type of FDA-regulated product to search recalls for.

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

Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000.

## `searchQuery` (type: `string`):

Search across all fields (e.g., 'salmonella', 'peanut butter', 'insulin'). Leave empty for all recalls.

## `classification` (type: `string`):

FDA recall classification. Class I is most serious (risk of death), Class III is least serious.

## `status` (type: `string`):

Current recall status.

## `state` (type: `string`):

Filter by state where the recalling firm is located (e.g., 'CA', 'TX', 'NY').

## `dateFrom` (type: `string`):

Only include recalls reported on or after this date (YYYYMMDD format, e.g., '20250101').

## `dateTo` (type: `string`):

Only include recalls reported on or before this date (YYYYMMDD format).

## Actor input object example

```json
{
  "productType": "all",
  "maxItems": 10
}
```

# Actor output Schema

## `overview` (type: `string`):

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

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

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "productType": "all",
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/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 = {
    "productType": "all",
    "maxItems": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("parseforge/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 '{
  "productType": "all",
  "maxItems": 10
}' |
apify call parseforge/fda-recalls-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "FDA Recalls Scraper - Food, Drug & Device Safety",
        "description": "Scrape FDA recall data for food, drugs, and medical devices. Get recall reasons, severity classifications, product descriptions, recalling firms, distribution patterns, and key dates. Filter by product type, class (I/II/III), status, state, and date range. Covers 84,000+ recalls.",
        "version": "1.0",
        "x-build-id": "c0ydk0EDY6zKPKipn"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~fda-recalls-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-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/parseforge~fda-recalls-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-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/parseforge~fda-recalls-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-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": {
                    "productType": {
                        "title": "Product Type",
                        "enum": [
                            "food",
                            "drug",
                            "device",
                            "all"
                        ],
                        "type": "string",
                        "description": "Type of FDA-regulated product to search recalls for.",
                        "default": "all"
                    },
                    "maxItems": {
                        "title": "Max Items",
                        "minimum": 1,
                        "maximum": 1000000,
                        "type": "integer",
                        "description": "Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000."
                    },
                    "searchQuery": {
                        "title": "Search Query",
                        "type": "string",
                        "description": "Search across all fields (e.g., 'salmonella', 'peanut butter', 'insulin'). Leave empty for all recalls."
                    },
                    "classification": {
                        "title": "Classification",
                        "enum": [
                            "",
                            "Class I",
                            "Class II",
                            "Class III"
                        ],
                        "type": "string",
                        "description": "FDA recall classification. Class I is most serious (risk of death), Class III is least serious."
                    },
                    "status": {
                        "title": "Status",
                        "enum": [
                            "",
                            "Ongoing",
                            "Terminated",
                            "Completed"
                        ],
                        "type": "string",
                        "description": "Current recall status."
                    },
                    "state": {
                        "title": "State",
                        "type": "string",
                        "description": "Filter by state where the recalling firm is located (e.g., 'CA', 'TX', 'NY')."
                    },
                    "dateFrom": {
                        "title": "Report Date From",
                        "type": "string",
                        "description": "Only include recalls reported on or after this date (YYYYMMDD format, e.g., '20250101')."
                    },
                    "dateTo": {
                        "title": "Report Date To",
                        "type": "string",
                        "description": "Only include recalls reported on or before this date (YYYYMMDD format)."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```