# FDA Recalls Database Scraper (`crawlerbros/fda-recalls-scraper`) Actor

Scrape FDA recalls from the openFDA REST API. Search food, drug, device, biologics, cosmetics, and veterinary recalls by keyword, product type, firm name, or classification. No API key required.

- **URL**: https://apify.com/crawlerbros/fda-recalls-scraper.md
- **Developed by:** [Crawler Bros](https://apify.com/crawlerbros) (community)
- **Categories:** Automation, Developer tools, Integrations
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
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

## FDA Recalls Database Scraper

Scrape FDA product recall data from the [openFDA REST API](https://api.fda.gov) — completely free with no API key required. Search across food, drug, medical device, biologics, cosmetics, and veterinary recalls with powerful filters.

### What data can you scrape?

- **All FDA recall categories**: Food & Beverages, Drugs & Pharmaceuticals, Medical Devices, Biologics, Cosmetics, Veterinary Products
- **Full recall details**: recall number, classification, reason, firm, product description, distribution pattern, code info, dates, and location
- **Historical data**: search recalls going back decades
- **Up-to-date**: openFDA data is updated weekly

### Input Parameters

| Parameter | Type | Description |
|-----------|------|-------------|
| `mode` | Select | Search mode: `searchByKeyword`, `searchByProductType`, `searchByFirm`, `byClassification` |
| `keyword` | Text | Search term for keyword search |
| `productType` | Select | `food`, `drug`, `device`, `biologics`, `cosmetics`, `veterinary` |
| `firmName` | Text | Recalling company/firm name |
| `classification` | Select | `Class I`, `Class II`, `Class III` |
| `dateFrom` | Text | Start date filter (YYYY-MM-DD) |
| `dateTo` | Text | End date filter (YYYY-MM-DD) |
| `maxItems` | Integer | Maximum records to return (default: 50, max: 5000) |

### Search Modes

- **searchByKeyword** — Full-text search across all recall fields. Best for general queries like `"salmonella"`, `"listeria"`, or `"peanut butter"`.
- **searchByProductType** — Browse all recalls for a specific FDA product category.
- **searchByFirm** — Find all recalls by a specific company (e.g., `"Tyson Foods"`).
- **byClassification** — Filter by recall severity: Class I (most serious health risk), Class II, or Class III.

### Output Fields

| Field | Description |
|-------|-------------|
| `recall_number` | Unique recall identifier |
| `status` | Ongoing / Terminated / Completed |
| `classification` | Class I / Class II / Class III |
| `product_type` | FDA product category |
| `recalling_firm` | Company issuing the recall |
| `product_description` | Product name and description |
| `reason_for_recall` | Why the product was recalled |
| `distribution_pattern` | Geographic scope of distribution |
| `report_date` | Date recall was reported |
| `recall_initiation_date` | Date recall was initiated |
| `voluntary_mandated` | Whether recall was voluntary or FDA-mandated |
| `city`, `state`, `country` | Firm location |
| `code_info` | Lot numbers, expiration dates, UPC codes |

### Example Use Cases

1. **Food safety monitoring** — Track all food recalls for a specific allergen or pathogen
2. **Pharmaceutical compliance** — Monitor drug recalls by classification severity
3. **Company due diligence** — Check recall history for a specific manufacturer
4. **Market research** — Analyze recall trends by product category and date range
5. **Supply chain risk** — Identify recently recalled products in your supply chain

### Sample Input

```json
{
  "mode": "searchByKeyword",
  "keyword": "peanut",
  "productType": "food",
  "maxItems": 50
}
````

### FAQs

**Q: Do I need an API key?**
A: No. The openFDA API is free and requires no registration for standard usage (up to 1000 requests/day without a key, much more with one).

**Q: How fresh is the data?**
A: openFDA enforcement data is updated weekly by the FDA.

**Q: Can I get all recalls ever?**
A: Yes — use `searchByProductType` without any keyword to browse all recalls for a category. The API covers recalls going back decades.

**Q: What is the difference between recall classes?**
A: Class I = most serious (reasonable probability of serious health consequence), Class II = may cause adverse health consequences, Class III = not likely to cause health problems.

**Q: Why are some fields missing from output?**
A: Only non-empty fields are included. If an FDA record lacks a value (e.g., no termination date for an ongoing recall), that field is omitted.

# Actor input Schema

## `mode` (type: `string`):

How to search recalls.

## `keyword` (type: `string`):

Search term across all recall fields (reason, product description, firm name, etc.). Used in searchByKeyword mode.

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

Filter by product category. Use 'food' for food/beverage recalls, 'drug' for pharmaceutical recalls, etc.

## `firmName` (type: `string`):

Filter recalls by the recalling firm or company name. Used in searchByFirm mode.

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

Class I = most serious (health hazard). Class II = may cause adverse health. Class III = unlikely to cause harm.

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

Filter recalls initiated on or after this date. Format: YYYY-MM-DD (e.g. 2023-01-01).

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

Filter recalls initiated on or before this date. Format: YYYY-MM-DD (e.g. 2023-12-31).

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

Maximum number of recall records to return.

## Actor input object example

```json
{
  "mode": "searchByKeyword",
  "keyword": "peanut",
  "productType": "food",
  "maxItems": 10
}
```

# Actor output Schema

## `records` (type: `string`):

Dataset containing all scraped FDA recall records.

# API

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

## JavaScript example

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

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

// Prepare Actor input
const input = {
    "mode": "searchByKeyword",
    "keyword": "peanut",
    "productType": "food",
    "maxItems": 10
};

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

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "FDA Recalls Database Scraper",
        "description": "Scrape FDA recalls from the openFDA REST API. Search food, drug, device, biologics, cosmetics, and veterinary recalls by keyword, product type, firm name, or classification. No API key required.",
        "version": "1.0",
        "x-build-id": "kawkHq1kR5rxPWssa"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/crawlerbros~fda-recalls-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-crawlerbros-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/crawlerbros~fda-recalls-scraper/runs": {
            "post": {
                "operationId": "runs-sync-crawlerbros-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/crawlerbros~fda-recalls-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-crawlerbros-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",
                "required": [
                    "mode"
                ],
                "properties": {
                    "mode": {
                        "title": "Mode",
                        "enum": [
                            "searchByKeyword",
                            "searchByProductType",
                            "searchByFirm",
                            "byClassification"
                        ],
                        "type": "string",
                        "description": "How to search recalls.",
                        "default": "searchByKeyword"
                    },
                    "keyword": {
                        "title": "Keyword",
                        "type": "string",
                        "description": "Search term across all recall fields (reason, product description, firm name, etc.). Used in searchByKeyword mode.",
                        "default": "peanut"
                    },
                    "productType": {
                        "title": "Product Type",
                        "enum": [
                            "food",
                            "drug",
                            "device",
                            "biologics",
                            "cosmetics",
                            "veterinary"
                        ],
                        "type": "string",
                        "description": "Filter by product category. Use 'food' for food/beverage recalls, 'drug' for pharmaceutical recalls, etc.",
                        "default": "food"
                    },
                    "firmName": {
                        "title": "Firm / Company Name",
                        "type": "string",
                        "description": "Filter recalls by the recalling firm or company name. Used in searchByFirm mode."
                    },
                    "classification": {
                        "title": "Recall Classification",
                        "enum": [
                            "Class I",
                            "Class II",
                            "Class III"
                        ],
                        "type": "string",
                        "description": "Class I = most serious (health hazard). Class II = may cause adverse health. Class III = unlikely to cause harm."
                    },
                    "dateFrom": {
                        "title": "Date From (YYYY-MM-DD)",
                        "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
                        "type": "string",
                        "description": "Filter recalls initiated on or after this date. Format: YYYY-MM-DD (e.g. 2023-01-01)."
                    },
                    "dateTo": {
                        "title": "Date To (YYYY-MM-DD)",
                        "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
                        "type": "string",
                        "description": "Filter recalls initiated on or before this date. Format: YYYY-MM-DD (e.g. 2023-12-31)."
                    },
                    "maxItems": {
                        "title": "Max Items",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Maximum number of recall records to return.",
                        "default": 50
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
