# FDA Recalls & Enforcement Monitor (`anywhere-web-repair/fda-recalls-monitor`) Actor

Monitor FDA food, drug, and medical-device recalls by class, status, firm, state, and keyword. Returns clean, structured recall records straight from the FDA's free openFDA enforcement API.

- **URL**: https://apify.com/anywhere-web-repair/fda-recalls-monitor.md
- **Developed by:** [Jeremy](https://apify.com/anywhere-web-repair) (community)
- **Stats:** 2 total users, 1 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $4.00 / 1,000 recall records

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/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

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

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

## FDA Recalls & Enforcement Monitor

Know about FDA recalls the week they're published. Point this Actor at product types, recall classes, firms, states, or keywords and get back clean, structured recall records — ready for spreadsheets, alerts, compliance dashboards, LLM pipelines, or your own database.

Built on the FDA's official, free **openFDA** enforcement API (the same data behind FDA's weekly Enforcement Report). No credentials required, no scraping of third-party sites — this Actor identifies itself to openFDA and stays well inside its published rate limits.

### What it does

- **Three feeds, one dataset** — food (incl. dietary supplements, cosmetics, animal food), human & veterinary drugs, and medical devices, merged and sorted newest-first.
- **Filter by what matters** — recall class (I/II/III), status (Ongoing/Completed/Terminated/Pending), recalling firm, firm's state, and free-text keywords matched against the product description, reason for recall, and firm name.
- **Pick your clock** — filter and sort by FDA report date (best for "what's new this week"), recall initiation date, or classification date.
- Each record includes: product type, recall number, event ID, class, status, voluntary/mandated, firm and location, product description, quantity, lot/code info, reason for recall, distribution pattern, all four dates (ISO format), drug brand/generic/NDC when openFDA has them, and a direct link to the primary-source record.

### Common uses

- Weekly digest of Class I food recalls for a grocery, restaurant, or food-service compliance team.
- Watch specific manufacturers or suppliers ("Abbott", "Medtronic") across all three feeds.
- Allergen monitoring: keywords like `undeclared peanuts`, `undeclared milk`, `listeria`, `salmonella`.
- Device-safety tracking for hospitals and clinics (`sterility`, `pump`, `catheter`).
- Feed fresh recalls into a Slack/email alert, a RAG pipeline, or a research workflow.

### Input

| Field | Meaning |
| --- | --- |
| `productTypes` | Any of `food`, `drug`, `device`. Default: all three. |
| `classifications` | `Class I`, `Class II`, `Class III`. Empty = all. |
| `statuses` | `Ongoing`, `Completed`, `Terminated`, `Pending`. Empty = all. |
| `keywords` | Phrases matched against product description, reason for recall, and firm. Each keyword is searched separately and tagged on its results. |
| `firms` | Recalling-firm names to watch. |
| `states` | Two-letter US state codes of the recalling firm's location. |
| `dateField` | `report_date` (default), `recall_initiation_date`, or `center_classification_date` — used for both the lookback window and sorting. |
| `lookbackDays` | Only recalls whose chosen date is within the last N days (default 30). |
| `maxResults` | Cap on returned records — this is what you're billed on. |
| `openFdaApiKey` | Optional. Raises openFDA's daily request allowance from 1,000 per IP to 120,000 per key. Only needed for very large or frequent runs; get one free at open.fda.gov. |

Running with no input at all returns the last 30 days of recalls across all three feeds (up to 100 records).

### Output

One dataset item per recall:

```json
{
  "source": "openFDA enforcement",
  "productType": "Food",
  "recallNumber": "H-1258-2026",
  "eventId": "99571",
  "classification": "Class I",
  "status": "Terminated",
  "voluntaryMandated": "Voluntary: Firm initiated",
  "recallingFirm": "H & U Inc. dba Sun Noodle",
  "city": "Honolulu",
  "state": "HI",
  "country": "United States",
  "postalCode": "96819-3248",
  "productDescription": "Sura Tanmen Hot and Sour Flavor Premium Japanese Noodles & Soup Base. Retail package net wt. 15.4oz ...",
  "productQuantity": "140 packages",
  "codeInfo": "Production Lot: 1226183 ...",
  "reasonForRecall": "Soba sauce packet, which contains bonito, sardine, and mackerel (fish), ... not declared on finished product label.",
  "distributionPattern": "Distribute in HI.",
  "initialFirmNotification": "Two or more of the following: Email, Fax, Letter, Press Release, Telephone, Visit",
  "recallInitiationDate": "2026-08-04",
  "centerClassificationDate": "2026-08-21",
  "reportDate": "2026-09-02",
  "terminationDate": "2026-08-27",
  "brandNames": null,
  "genericNames": null,
  "manufacturerNames": null,
  "productNdc": null,
  "matchedKeyword": null,
  "recordUrl": "https://api.fda.gov/food/enforcement.json?search=recall_number%3A%22H-1258-2026%22"
}
```

A `SUMMARY` record in the key-value store lists the window, filters, request count, records fetched per feed, and the total returned.

### Pricing

Pay per event: a small charge per run start plus a per-recall-record charge. You control cost directly with `maxResults`.

### Fair use & disclaimers

Data comes from the U.S. Food and Drug Administration's openFDA API (FDA Recall Enterprise System, 2004–present, updated weekly). This Actor is not affiliated with or endorsed by the FDA. Per FDA's own disclaimer, openFDA data is unvalidated and must not be relied on for decisions about medical care; FDA does not update a recall's status after classification. This Actor respects openFDA's rate limits (declared User-Agent, throttled requests) and never logs your API key.

***

Built and maintained by **Anywhere Web Repair** (anywherewebrepair.com), with AI-assisted development, human-reviewed.

# Actor input Schema

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

Which FDA enforcement feeds to query. Leave all three selected to cover food, drugs, and medical devices.

## `classifications` (type: `array`):

Class I = reasonable probability of serious harm or death; Class II = temporary or reversible harm; Class III = unlikely to cause harm. Leave empty for all classes.

## `statuses` (type: `array`):

Ongoing = still in progress; Completed = firm finished its actions; Terminated = FDA closed the recall; Pending = not yet classified. Leave empty for all.

## `keywords` (type: `array`):

Optional phrases matched against the product description, reason for recall, and recalling firm — e.g. "undeclared peanuts", "listeria", "sterility", "insulin". Each keyword is searched separately and tagged on the results.

## `firms` (type: `array`):

Optional company names to watch (matched against the recalling firm), e.g. "Abbott", "Medtronic".

## `states` (type: `array`):

Optional two-letter US state codes of the recalling firm's location, e.g. CA, TX. (This is where the firm is based, not where the product was distributed.)

## `dateField` (type: `string`):

Report date = when FDA published the recall in its weekly Enforcement Report (best for 'what's new'). Recall initiation date = when the firm started the recall. Center classification date = when FDA assigned the class.

## `lookbackDays` (type: `integer`):

Only include recalls whose chosen date falls within the last N days. FDA publishes enforcement reports weekly, so 30 days covers roughly the last four reports.

## `maxResults` (type: `integer`):

Stop after this many recall records across all product types (each returned record is a billable event).

## `openFdaApiKey` (type: `string`):

Optional. Without a key openFDA allows 1,000 requests per day per IP; with a free key (open.fda.gov/apis/authentication) that becomes 120,000. Only needed for very large or very frequent runs. Stored encrypted; never logged.

## Actor input object example

```json
{
  "productTypes": [
    "food",
    "drug",
    "device"
  ],
  "classifications": [
    "Class I",
    "Class II"
  ],
  "dateField": "report_date",
  "lookbackDays": 30,
  "maxResults": 100
}
```

# Actor output Schema

## `recalls` (type: `string`):

One record per matched FDA recall, with product type, class, status, firm, product, reason, dates, and a link to the primary-source record.

## `summary` (type: `string`):

Window, filters, request count, records fetched per product type, and total records returned.

# 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 = {
    "productTypes": [
        "food",
        "drug",
        "device"
    ],
    "classifications": [
        "Class I",
        "Class II"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("anywhere-web-repair/fda-recalls-monitor").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 = {
    "productTypes": [
        "food",
        "drug",
        "device",
    ],
    "classifications": [
        "Class I",
        "Class II",
    ],
}

# Run the Actor and wait for it to finish
run = client.actor("anywhere-web-repair/fda-recalls-monitor").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "productTypes": [
    "food",
    "drug",
    "device"
  ],
  "classifications": [
    "Class I",
    "Class II"
  ]
}' |
apify call anywhere-web-repair/fda-recalls-monitor --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,anywhere-web-repair/fda-recalls-monitor"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/hwx2Pl97p03WI83xU/builds/iIrUD5Uk9r0HP692K/openapi.json