FDA Food Recall Monitor

What does FDA Food Recall Monitor do?

FDA Food Recall Monitor searches and extracts food recall and enforcement data directly from the U.S. Food and Drug Administration's openFDA API. It provides structured, machine-readable access to FDA food safety enforcement actions, including product recalls triggered by contamination (salmonella, listeria, E. coli), undeclared allergens, foreign object contamination, mislabeling, and other hazards.

The actor queries the FDA's food enforcement endpoint and returns detailed recall records, including the recalling company, product descriptions, the reason for the recall, recall classification severity (Class I, II, or III), geographic distribution, recall status, and key dates. All data is returned in clean, normalized JSON format ready for analysis, monitoring dashboards, or integration into downstream workflows.

Why use FDA Food Recall Monitor on Apify?

• No query syntax required -- The openFDA API uses a complex query language with +AND+ joins, bracket date ranges, and multi-field keyword searches. This actor translates a simple form into the correct query automatically.
• Automatic pagination -- The openFDA API returns at most 100 results per request. The actor pages through automatically with built-in 300 ms rate limiting.
• Clean date formatting -- Raw API dates (YYYYMMDD) are converted to ISO format (YYYY-MM-DD). Address fields are combined.
• Schedule for monitoring -- Run daily or weekly to track new recalls matching your criteria, with webhook alerts to Slack, email, or any endpoint.
• No API key required -- Uses the free openFDA public endpoint.

Key features

• Keyword search across product descriptions and recall reasons (e.g., "salmonella", "undeclared peanut", "glass fragments")
• Company filter to monitor recalls from specific food manufacturers or distributors
• Classification filter for Class I (dangerous), Class II (temporary health problems), or Class III (unlikely adverse effects)
• State filter to focus on recalls originating from a specific U.S. state
• Date range filter to search recalls within a specific time window
• Status filter to show only Ongoing, Terminated, or Completed recalls
• Up to 10,000 results per run with automatic pagination

How to use FDA Food Recall Monitor

1. Navigate to the FDA Food Recall Monitor on the Apify Store.
2. Click Try for free to open the actor in Apify Console.
3. Enter a keyword (e.g., "salmonella"), optionally specify company, classification, state, date range, or status.
4. Click Start and wait for the run to complete.
5. Download your results from the Dataset tab in JSON, CSV, or Excel format.

Input parameters

Input examples

Serious salmonella recalls in 2024:

{
    "keyword": "salmonella",
    "classification": "Class I",
    "dateStart": "20240101",
    "dateEnd": "20241231",
    "maxResults": 500
}

Undeclared allergen recalls:

{
    "keyword": "undeclared peanut",
    "classification": "Class I",
    "maxResults": 200
}

Active recalls from California:

{
    "state": "CA",
    "statusFilter": "Ongoing",
    "maxResults": 100
}

All recalls from a specific company:

{
    "recallingFirm": "Fresh Harvest Foods",
    "maxResults": 500
}

Input tips

• Use specific keywords for targeted results. "undeclared peanut" is more precise than "peanut" and surfaces allergen recalls specifically.
• Combine filters for narrow results -- e.g., Class I + date range to find only the most serious recent recalls.
• Schedule daily runs with a date range covering the last 7 days to catch new recalls automatically.
• Date format is YYYYMMDD (no dashes), e.g., 20240101 for January 1, 2024.
• Class I is most serious -- situations with reasonable probability of serious health consequences or death.

Output example

{
    "recallNumber": "F-0123-2024",
    "eventId": "92847",
    "status": "Ongoing",
    "classification": "Class I",
    "recallingFirm": "Fresh Harvest Foods Inc.",
    "city": "Salinas",
    "state": "CA",
    "country": "United States",
    "address": "1200 Valley Industrial Blvd",
    "postalCode": "93901",
    "productDescription": "Fresh Harvest Organic Baby Spinach, 5 oz clamshell containers, UPC 0 12345 67890 1",
    "productQuantity": "14,832 cases",
    "reasonForRecall": "Product was found to contain Salmonella after routine sampling by the FDA revealed contamination.",
    "distributionPattern": "Nationwide distribution to retail stores in all 50 states.",
    "recallDate": "2024-06-15",
    "reportDate": "2024-06-22",
    "terminationDate": null,
    "codeInfo": "Lot codes 2024-A155 through 2024-A162, Best By dates 06/20/2024 through 06/27/2024",
    "voluntaryMandated": "Voluntary",
    "initialNotification": "Press Release",
    "extractedAt": "2025-01-15T14:32:07.123Z"
}

Output fields

Use cases

• Food safety monitoring -- Track active recalls for contamination, allergens, or specific hazard types. Schedule daily runs with webhook alerts.
• Supply chain compliance -- Monitor your suppliers' recall history to assess vendor risk and compliance.
• Insurance and risk analysis -- Analyze recall patterns by company, state, and classification to assess food industry liability risk.
• Journalism -- Investigate contamination patterns, repeat offenders, or geographic trends in food safety enforcement.
• Consumer protection -- Build apps or dashboards that alert consumers about recalled products in their area.
• Regulatory compliance -- Track FDA enforcement trends for food industry regulatory planning.

Programmatic access (API)

Python:

from apify_client import ApifyClient

client = ApifyClient("YOUR_API_TOKEN")

run = client.actor("ryanclinton/fda-food-recall-monitor").call(run_input={
    "keyword": "salmonella",
    "classification": "Class I",
    "dateStart": "20240101",
    "maxResults": 500,
})

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(f"[{item['classification']}] {item['recallingFirm']}: {item['reasonForRecall'][:80]}")
    print(f"  Product: {item['productDescription'][:80]}")
    print(f"  Status: {item['status']} | Date: {item['recallDate']}")

JavaScript:

import { ApifyClient } from "apify-client";

const client = new ApifyClient({ token: "YOUR_API_TOKEN" });

const run = await client.actor("ryanclinton/fda-food-recall-monitor").call({
    keyword: "salmonella",
    classification: "Class I",
    dateStart: "20240101",
    maxResults: 500,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
for (const item of items) {
    console.log(`[${item.classification}] ${item.recallingFirm}`);
    console.log(`  Reason: ${item.reasonForRecall.substring(0, 100)}`);
}

cURL:

# Start a run
curl "https://api.apify.com/v2/acts/ryanclinton~fda-food-recall-monitor/runs" \
    -X POST \
    -H "Content-Type: application/json" \
    -H "Authorization: Bearer YOUR_API_TOKEN" \
    -d '{
        "keyword": "salmonella",
        "classification": "Class I",
        "dateStart": "20240101",
        "maxResults": 500
    }'

# Fetch results (after run completes)
curl "https://api.apify.com/v2/datasets/DATASET_ID/items?format=json" \
    -H "Authorization: Bearer YOUR_API_TOKEN"

How it works -- technical details

Input (keyword, company, classification, state, dates, status)
  │
  ▼
┌─────────────────────────────────────────────┐
│  1. Query Builder                           │
│  • keyword → search reason_for_recall       │
│    AND product_description with OR (+)      │
│  • recallingFirm → recalling_firm:"..."     │
│  • classification → classification:"..."    │
│  • state → state:XX (uppercased)            │
│  • statusFilter → status:"Ongoing"          │
│  • Date range → report_date:[start TO end]  │
│  • All parts joined with +AND+              │
└──────────────────┬──────────────────────────┘
                   │
                   ▼
┌─────────────────────────────────────────────┐
│  2. Paginated Fetcher                       │
│  • GET api.fda.gov/food/enforcement.json    │
│  • 100 results per page (API max)           │
│  • Increment skip by limit each page        │
│  • 300 ms delay between requests            │
│  • NOT_FOUND on first page = zero results   │
└──────────────────┬──────────────────────────┘
                   │
                   ▼
┌─────────────────────────────────────────────┐
│  3. Transform                               │
│  • Dates: YYYYMMDD → YYYY-MM-DD            │
│  • Address: address_1 + address_2 combined  │
│  • terminationDate: null if not terminated  │
│  • All fields renamed to camelCase          │
└──────────────────┬──────────────────────────┘
                   │
                   ▼
┌─────────────────────────────────────────────┐
│  4. Output & Summary                        │
│  • Each recall → Apify dataset             │
│  • Summary: classification breakdown,       │
│    state count, status breakdown            │
└─────────────────────────────────────────────┘

Query construction

The actor builds an openFDA search query using the same syntax as other openFDA endpoints:

Recall classifications

How much does it cost to use?

The openFDA API is completely free. Apify's free tier includes $5 of monthly platform usage.

Limitations

1. 10,000 result maximum -- The actor caps at 10,000 results per run. Use date ranges to split larger datasets across multiple runs.
2. Food recalls only -- This actor queries the food enforcement endpoint only. For medical device recalls, drug events, or non-food products, use separate actors.
3. openFDA data lag -- There may be a delay between when a recall is initiated and when it appears in the openFDA database.
4. Keyword search is broad -- The keyword searches both reason_for_recall and product_description fields. Very common terms may return many results.
5. YYYYMMDD date format -- Dates must be entered in YYYYMMDD format (no dashes). Output dates are converted to YYYY-MM-DD.
6. No notification tracking -- The actor captures the initialNotification field but does not track subsequent FDA communications about the recall.
7. Address data varies -- Some recall records have incomplete address information. The actor combines address_1 and address_2 fields.
8. Rate limiting -- The openFDA public endpoint allows 240 requests/minute. The built-in 300 ms delay prevents hitting this limit.

Responsible use

• FDA recall data is public information. Use it for food safety monitoring, research, and consumer protection.
• Follow the openFDA Terms of Service when using the data.
• Do not use recall data to make unsubstantiated claims about food companies. Recalls can occur for many reasons and do not necessarily indicate ongoing safety issues.
• When building consumer-facing applications, ensure recall information is presented accurately with appropriate context.

FAQ

Do I need an API key? No. The openFDA enforcement API is free and publicly accessible.

How current is the data? The FDA updates its enforcement database regularly, typically within days of a recall being reported.

Can I search for non-food recalls? No. This actor queries the /food/enforcement endpoint. For medical device recalls, see FDA Medical Device Recall Search. For drug adverse events, see openFDA Drug Event Monitor.

What do the recall classifications mean? Class I is the most serious (risk of serious health consequences or death). Class II may cause temporary health problems. Class III is unlikely to cause adverse health effects.

What is the difference between recall date and report date? The recall date (recallDate) is when the company initiated the recall. The report date (reportDate) is when it was reported to the FDA. There can be a gap of days or weeks between the two.

Integrations and related actors

The output dataset can be exported in JSON, CSV, or Excel format, or accessed programmatically via the Apify API. Use webhooks to trigger automated workflows when a run completes. Connect with Google Sheets, Zapier, Make (Integromat), Amazon S3, and custom API endpoints to build automated food safety monitoring workflows.

FDA regulatory intelligence suite

Other safety and regulatory actors