# FDA & NHTSA Recall Monitor – Official Gov Data (`scrapepilot/fda-nhtsa-recall-monitor---official-gov-data`) Actor

Live recalls from FDA (food/drugs/devices) & NHTSA (vehicles). Official US gov data, no API key. Risk levels: Class I (urgent) to III. Get scope, product description, affected units. Perfect for compliance, retail, auto, healthcare. Export JSON/CSV.

- **URL**: https://apify.com/scrapepilot/fda-nhtsa-recall-monitor---official-gov-data.md
- **Developed by:** [Scrape Pilot](https://apify.com/scrapepilot) (community)
- **Categories:** Automation, Developer tools, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

$17.99/month + usage

To use this Actor, you pay a monthly rental fee to the developer. The rent is subtracted from your prepaid usage every month after the free trial period.You also pay for the Apify platform usage, which gets cheaper the higher Apify subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#rental-actors

## 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 & NHTSA Product Recall Monitor | Real-Time US Government Recall Alerts

> **Monitor FDA food, drug, and medical device recalls — plus NHTSA vehicle recalls — directly from official US government APIs. Real data. No scraping. No delays. Certified compliance-grade output.**

---

### 📌 Table of Contents

- [What Does This Actor Do?](#what-does-this-actor-do)
- [Quick Start — 3 Steps](#quick-start--3-steps)
- [Why This Actor?](#why-this-actor)
- [Use Cases](#use-cases)
- [Data Sources — Official Government APIs](#data-sources--official-government-apis)
- [What Data You Get](#what-data-you-get)
- [Risk Classification Explained](#risk-classification-explained)
- [How It Works](#how-it-works)
- [Input Parameters](#input-parameters)
- [Example Input & Output](#example-input--output)
- [Vehicle Recall Search](#vehicle-recall-search)
- [Performance & Speed](#performance--speed)
- [Cost Estimate](#cost-estimate)
- [Limitations](#limitations)
- [Integrations](#integrations)
- [FAQ](#faq)
- [Changelog](#changelog)
- [Legal & Compliance Notice](#legal--compliance-notice)

---

### 🚨 What Does This Actor Do?

This actor monitors **US government product recall databases in real time** — pulling directly from the FDA and NHTSA official public APIs — and returns structured, compliance-grade recall records ready for alerts, dashboards, and regulatory workflows.

**One run returns:**

- ✅ **FDA Food Recalls** — contamination, mislabeling, undeclared allergens
- ✅ **FDA Drug Recalls** — prescription and OTC medications, controlled substances
- ✅ **FDA Medical Device Recalls** — surgical equipment, diagnostics, implantables
- ✅ **NHTSA Vehicle Recalls** — cars, trucks, motorcycles, child safety seats
- ✅ **Risk classification** — Class I (urgent/life-threatening), Class II (moderate), Class III (low)
- ✅ **Full recall details** — product, brand, reason, scope, affected units, remedy, date

All data comes directly from `api.fda.gov` and `api.nhtsa.dot.gov` — the same official government systems used by compliance teams, law firms, and regulatory professionals. No third-party aggregators. No data lag.

---

### ⚡ Quick Start — 3 Steps

**Step 1 — Configure your search**
```json
{
  "monitor_source": "ALL",
  "keyword":        "peanut",
  "max_results":    30
}
````

**Step 2 — Click Run**
The actor queries FDA and NHTSA APIs, parses and classifies every recall, applies your filters, and returns structured records.

**Step 3 — Get your recall data**

```json
{
  "Recall_ID":     "F-0123-2024",
  "Product":       "Sunshine Foods — Peanut Butter Crackers 12oz",
  "Reason":        "Undeclared peanut allergen — risk of allergic reaction",
  "Risk_Level":    "CLASS I (URGENT) — Serious adverse health consequences or death",
  "Recall_Date":   "2024-10-15",
  "Status":        "Active",
  "Source":        "FDA",
  "Compliance_Grade": "CERTIFIED"
}
```

Data appears in the **Dataset** tab — export as JSON, CSV, or Excel instantly.

***

### 🏛️ Why This Actor?

| Feature | This Actor | News Scrapers | Paid Compliance SaaS |
|---|---|---|---|
| **Official government API source** | ✅ FDA + NHTSA direct | ❌ Aggregated/delayed | ✅ But costly |
| **FDA food + drug + device** | ✅ All three categories | ⚠️ Partial | ✅ |
| **NHTSA vehicle recalls** | ✅ By make/model/year | ❌ | ✅ |
| **Class I / II / III risk labeling** | ✅ Auto-classified | ❌ | ✅ |
| **Keyword search across recall text** | ✅ Built-in | ❌ | ⚠️ |
| **Vehicle-specific search** | ✅ Make + Model + Year | ❌ | ⚠️ |
| **Risk filter (Class I only)** | ✅ Built-in | ❌ | ⚠️ |
| **Structured JSON output** | ✅ API/CRM ready | ❌ | ⚠️ |
| **Compliance-grade data label** | ✅ CERTIFIED flag | ❌ | ✅ |
| **No API key needed** | ✅ | ✅ | ❌ Requires account |
| **Monthly cost** | ✅ $17.99 | Free but unreliable | ❌ $200–$2,000+ |

> **Same official data as enterprise compliance platforms — at a fraction of the cost. All records carry a `"Compliance_Grade": "CERTIFIED"` flag sourced directly from US government APIs.**

***

### 🎯 Use Cases

#### 🏭 Product Safety & Compliance Monitoring

Automatically monitor FDA recalls for products your company manufactures, distributes, or sells. Get structured alerts the moment a Class I recall is issued in your product category — without manually checking the FDA website daily.

#### 🚗 Automotive Safety & Fleet Management

Search NHTSA vehicle recalls by make, model, and year across your entire fleet. Identify open recalls on company vehicles before inspections or before purchasing used inventory. Essential for fleet managers, dealerships, and rental companies.

#### ⚖️ Legal & Litigation Research

Pull complete FDA and NHTSA recall records for products involved in personal injury, product liability, or class action cases. All data is sourced from government APIs and carries a certification flag usable in legal documentation.

#### 🏪 Retail & Supply Chain Risk Management

Monitor FDA food and drug recalls for products on your shelves or in your supply chain. Trigger automated removal or quarantine workflows when a recall matches a SKU or brand you carry.

#### 📊 Insurance Underwriting & Risk Assessment

Integrate recall frequency and severity data into product liability underwriting models. Query historical recall patterns by product type, manufacturer, and risk class.

#### 🏥 Healthcare & Pharmacy Compliance

Monitor FDA drug and medical device recalls relevant to your formulary, hospital supply chain, or patient-facing products. Class I drug recalls require immediate action — this actor surfaces them automatically.

#### 📰 Journalism & Consumer Advocacy

Track and publish recall alerts for a specific product category, brand, or region. Get the same data journalists at major publications use — directly from government sources — without building a custom scraper.

#### 🤖 Automated Alert Systems

Schedule this actor hourly or daily and connect via Zapier, Make, or the Apify API to fire Slack alerts, emails, or SMS notifications whenever a new recall matches your keywords, product type, or risk class.

***

### 🏛️ Data Sources — Official Government APIs

Every record returned by this actor originates from a US federal government system:

#### FDA — Food and Drug Administration

**Endpoint:** `api.fda.gov` (free public API, no authentication)

Covers four enforcement categories queried independently:

- **Food recalls** — contamination (Salmonella, Listeria, E. coli), undeclared allergens, foreign objects, mislabeling
- **Drug recalls** — prescription medications, OTC drugs, controlled substances, contamination, labeling errors
- **Medical device recalls** — diagnostic equipment, surgical instruments, implants, monitors
- **Other** — biologics, veterinary products, cosmetics

FDA uses a standardized Lucene query syntax allowing precise keyword search across `product_description` and `reason_for_recall` fields.

#### NHTSA — National Highway Traffic Safety Administration

**Endpoint:** `api.nhtsa.dot.gov` (free public API, no authentication)

Covers all vehicle-related safety recalls including passenger cars, light trucks, motorcycles, child safety seats, and tires. Supports exact search by vehicle make, model, and model year — or broad queries across recent recalls.

NHTSA records include defect description, consequence summary, remedy description, and the number of potentially affected units.

***

### 📋 What Data You Get

#### FDA Recall Fields

| Field | Type | Description | Example |
|---|---|---|---|
| `Recall_ID` | string | Official FDA recall number | `"F-0123-2024"` |
| `Product` | string | Brand + product description | `"Sunshine Foods — Crackers 12oz"` |
| `Brand` | string | Recalling firm / manufacturer | `"Sunshine Foods Inc."` |
| `Product_Description` | string | Full product details (up to 500 chars) | `"Peanut Butter Crackers, 12oz..."` |
| `Reason` | string | Reason for recall (up to 500 chars) | `"Undeclared peanut allergen"` |
| `Scope` | string | Distribution pattern / affected regions | `"Nationwide"` |
| `Recall_Date` | string | Date recall was initiated (YYYY-MM-DD) | `"2024-10-15"` |
| `Risk_Level` | string | Full risk classification with description | `"CLASS I (URGENT) — Serious adverse..."` |
| `Classification` | string | Raw FDA classification | `"Class I"` |
| `Status` | string | Recall status | `"Active"` / `"Terminated"` |
| `Product_Type` | string | FDA product category | `"Food"` / `"Drug"` / `"Medical Device"` |
| `Voluntary_Mandated` | string | Whether recall was voluntary | `"Voluntary: Firm Initiated"` |
| `Source_Link` | string | FDA recall safety alerts page | `"https://www.fda.gov/..."` |
| `Source` | string | Data origin | `"FDA"` |
| `Compliance_Grade` | string | Data certification flag | `"CERTIFIED"` |
| `Timestamp` | string | ISO 8601 extraction timestamp | `"2024-11-01T10:30:00Z"` |

#### NHTSA Recall Fields

| Field | Type | Description | Example |
|---|---|---|---|
| `Recall_ID` | string | NHTSA campaign number | `"24V-001"` |
| `Product` | string | Year + Make + Model + Component | `"2022 Ford F-150 — Brake System"` |
| `Brand` / `Vehicle_Make` | string | Vehicle manufacturer | `"Ford"` |
| `Vehicle_Model` | string | Vehicle model name | `"F-150"` |
| `Vehicle_Year` | string | Model year | `"2022"` |
| `Component` | string | Affected vehicle component | `"Brake System"` |
| `Defect` | string | Description of the defect | `"Brake fluid may leak..."` |
| `Consequence` | string | Risk to drivers/passengers | `"Increased risk of crash"` |
| `Remedy` | string | How the recall will be fixed | `"Dealers will replace..."` |
| `Affected_Units` | integer | Estimated vehicles affected | \`\`142000`|
|`Recall\_Date`| string | Date recall was reported |`"2024-09-28"`|
|`Risk\_Level`| string | Fixed label for vehicle safety |`"Safety Critical"`|
|`Source\_Link`| string | NHTSA recall detail URL |`"https://www.nhtsa.gov/recalls?nhtsaId=..."`|
|`Source`| string | Data origin |`"NHTSA"`|
|`Compliance\_Grade`| string | Data certification flag |`"CERTIFIED"\` |

***

### 🔴 Risk Classification Explained

FDA assigns every recall a formal classification. This actor maps each class to a plain-language risk label:

| FDA Class | Risk Level Label | What It Means |
|---|---|---|
| **Class I** | `CLASS I (URGENT) — Serious adverse health consequences or death` | Highest severity. Immediate action required. Products that can cause serious injury or death. |
| **Class II** | `CLASS II (MODERATE) — May cause adverse health consequences` | Products that may cause temporary or reversible health problems, or where the probability of serious harm is low. |
| **Class III** | `CLASS III (LOW) — Unlikely to cause harm` | Products unlikely to cause harm, but violate FDA regulations. Often labeling or minor quality issues. |

**For alert workflows:** Filter by `risk_filter: "Class I"` to receive only urgent, life-threatening recall notices.

NHTSA vehicle recalls are always classified as `"Safety Critical"` — the NHTSA system uses a single severity designation for all vehicle safety defects.

***

### ⚙️ How It Works

#### Step 1 — Source Routing

Based on the `monitor_source` parameter, the actor routes to FDA only, NHTSA only, or both. Within FDA, the `product_type` parameter narrows the query to a single enforcement endpoint (food, drug, device) — or all four in parallel.

#### Step 2 — Government API Query

FDA queries use Lucene search syntax to match `product_description` and `reason_for_recall` against your keyword. NHTSA supports direct vehicle lookup by make, model, and year — or a general recent-recalls query across major manufacturers.

#### Step 3 — Risk Classification

FDA classification fields are mapped to the standardized plain-language risk labels. Records without a classification receive `"Under Review"`. NHTSA records are always marked `"Safety Critical"`.

#### Step 4 — SSL & Rate-Limit Handling

US government APIs occasionally have SSL certificate chain issues. The actor handles these automatically by retrying without proxy on SSL errors. On `429 Too Many Requests`, the actor waits and retries up to 3 times with increasing delay before moving on.

#### Step 5 — Risk Filter & Output

If `risk_filter` is set, only records matching that class are kept. All records are trimmed to `max_results`, pushed to the Dataset, and saved to the Key-Value Store as `results.json`.

***

### ⚙️ Input Parameters

```json
{
  "monitor_source": "ALL",
  "keyword":        "listeria",
  "product_type":   "food",
  "vehicle_make":   "",
  "vehicle_model":  "",
  "vehicle_year":   "",
  "risk_filter":    "Class I",
  "max_results":    30,
  "proxyConfiguration": {
    "useApifyProxy":    true,
    "apifyProxyGroups": ["RESIDENTIAL"]
  }
}
```

| Parameter | Type | Default | Description |
|---|---|---|---|
| `monitor_source` | string | `"ALL"` | Which agencies to query: `"ALL"`, `"FDA"`, or `"NHTSA"` |
| `keyword` | string | `""` | Search term matched against product description and recall reason (FDA uses Lucene syntax) |
| `product_type` | string | `""` | FDA product category filter: `"food"`, `"drug"`, `"device"`, or `""` for all. Use `"vehicle"` / `"auto"` to query NHTSA only |
| `vehicle_make` | string | `""` | NHTSA: Vehicle manufacturer (e.g., `"FORD"`, `"TOYOTA"`) |
| `vehicle_model` | string | `""` | NHTSA: Vehicle model (e.g., `"F-150"`, `"CAMRY"`) |
| `vehicle_year` | string | `""` | NHTSA: Four-digit model year (e.g., `"2022"`) |
| `risk_filter` | string | `""` | Filter output to a specific risk class: `"Class I"`, `"Class II"`, `"Class III"`, or `"Safety Critical"` |
| `max_results` | integer | `30` | Maximum total records returned across all sources |
| `proxyConfiguration` | object | Off | Apify proxy config — optional for government APIs |

***

### 📦 Example Input & Output

#### Example 1 — Search All Allergen-Related FDA Recalls

**Input:**

```json
{
  "monitor_source": "FDA",
  "keyword":        "allergen",
  "risk_filter":    "Class I",
  "max_results":    10
}
```

**Output (one record):**

```json
{
  "Recall_ID":          "F-2456-2024",
  "Product":            "Nature's Best — Granola Bars Variety Pack 18ct",
  "Brand":              "Nature's Best Foods LLC",
  "Product_Description": "Granola Bars Variety Pack, 18 count, UPC 0-12345-67890-1",
  "Reason":             "Undeclared milk allergen due to cross-contamination on shared equipment",
  "Scope":              "Nationwide — distributed through major retail chains",
  "Recall_Date":        "2024-10-22",
  "Risk_Level":         "CLASS I (URGENT) — Serious adverse health consequences or death",
  "Classification":     "Class I",
  "Status":             "Active",
  "Product_Type":       "Food",
  "Voluntary_Mandated": "Voluntary: Firm Initiated",
  "Source_Link":        "https://www.fda.gov/safety/recalls-market-withdrawals-safety-alerts",
  "Source":             "FDA",
  "Compliance_Grade":   "CERTIFIED",
  "Timestamp":          "2024-11-01T10:30:00Z"
}
```

***

#### Example 2 — NHTSA Vehicle Recall Search by Make & Model

**Input:**

```json
{
  "monitor_source": "NHTSA",
  "vehicle_make":   "FORD",
  "vehicle_model":  "F-150",
  "vehicle_year":   "2022",
  "max_results":    10
}
```

**Output (one record):**

```json
{
  "Recall_ID":      "24V-112",
  "Product":        "2022 Ford F-150 — Brake System",
  "Brand":          "Ford",
  "Vehicle_Make":   "FORD",
  "Vehicle_Model":  "F-150",
  "Vehicle_Year":   "2022",
  "Component":      "HYDRAULIC BRAKE SYSTEM:ANTILOCK",
  "Defect":         "Brake fluid may leak from the master cylinder reservoir",
  "Consequence":    "Brake fluid leakage may increase braking distance, increasing the risk of a crash",
  "Remedy":         "Dealers will inspect and replace the brake master cylinder as necessary",
  "Affected_Units": 142000,
  "Recall_Date":    "2024-09-28",
  "Risk_Level":     "Safety Critical",
  "Source_Link":    "https://www.nhtsa.gov/recalls?nhtsaId=24V-112",
  "Source":         "NHTSA",
  "Compliance_Grade": "CERTIFIED",
  "Timestamp":      "2024-11-01T10:31:00Z"
}
```

***

#### Example 3 — Scheduled Daily Alert: All Class I Recalls

**Input:**

```json
{
  "monitor_source": "ALL",
  "risk_filter":    "Class I",
  "max_results":    50
}
```

**Use this as a daily scheduled run** to surface every new Class I recall — across food, drugs, devices, and vehicles — in a single dataset. Connect to Zapier or Make to fire email or Slack alerts automatically.

***

### 🚗 Vehicle Recall Search

The NHTSA vehicle search supports three lookup modes:

**By Make + Model + Year (most precise)**

```json
{
  "vehicle_make":  "TOYOTA",
  "vehicle_model": "CAMRY",
  "vehicle_year":  "2021"
}
```

Returns all open recalls for that exact vehicle configuration.

**By Make only**

```json
{
  "vehicle_make": "BMW"
}
```

Returns all recent recalls across all BMW models and years.

**General recent recalls (no vehicle specified)**

```json
{
  "monitor_source": "NHTSA",
  "max_results":    20
}
```

Returns a sample of recent NHTSA recalls across major manufacturers — useful for broad monitoring.

> **Note:** Vehicle make and model values are **case-insensitive** — the actor converts them to uppercase automatically for the NHTSA API.

***

### ⚡ Performance & Speed

| Configuration | Estimated Time |
|---|---|
| FDA single category (food only), 20 records | ~10–20 seconds |
| FDA all categories, 30 records | ~20–40 seconds |
| NHTSA specific vehicle, 10 records | ~10–15 seconds |
| ALL sources, 50 records | ~30–60 seconds |
| ALL sources, 100 records | ~1–2 minutes |

Government APIs are fast and reliable. Most runs complete in under 60 seconds for typical workloads.

***

### 💰 Cost Estimate

**Subscription:** $17.99/month · **Free Trial: 1 Full Day** (no credit card required)

| Run Type | Apify Compute Units | Approx. Compute Cost |
|---|---|---|
| Single source, 30 records | ~0.01–0.03 CU | < $0.01 |
| All sources, 50 records | ~0.03–0.06 CU | < $0.01 |
| Scheduled hourly (30-day month) | ~0.5–1.5 CU/month | ~$0.04–$0.12 |
| Scheduled daily (30-day month) | ~0.05–0.15 CU/month | < $0.01 |

Apify provides **$5 free compute credit per month** on the free plan. This actor's compute costs are minimal — most users will pay only the $17.99 subscription regardless of how often they run it.

**Use the 1-day free trial** to verify the actor returns the recall categories you need before subscribing.

***

### ⚠️ Limitations

Being transparent about what this actor cannot do:

- ❌ **CPSC recalls** — The Consumer Product Safety Commission (CPSC) is mentioned in the code comments as planned. CPSC is not yet active in the current version.
- ❌ **Historical archive beyond FDA API limits** — The FDA free API returns up to 100 records per endpoint per call. Very old archived recalls may not appear in default queries.
- ❌ **Real-time push notifications** — This actor fetches on demand or on schedule. It does not maintain a persistent connection to government systems. For real-time alerts, schedule it hourly and connect to an alerting tool.
- ❌ **Non-US recalls** — Only covers US federal agencies (FDA and NHTSA). European (RAPEX), Canadian (Health Canada), or other international recall systems are not included.
- ❌ **Recall outcome or resolution tracking** — The actor captures the recall status at time of run. It does not track whether a recall has been resolved, terminated, or extended over time.
- ❌ **PDF/document attachments** — Some FDA recalls include detailed PDF documents. This actor extracts structured text fields only — not binary attachments.
- ❌ **Proxy required for government APIs** — FDA and NHTSA APIs are open to the public. Proxy is optional and generally not needed unless your IP is geo-blocked.

***

### 🔌 Integrations

#### Slack or Email Alerts via Zapier / Make

Schedule this actor daily and connect to Zapier or Make. When a new Class I recall matches your product category or vehicle, fire a Slack message or email automatically — no code required.

#### Google Sheets Compliance Dashboard

Export results directly to Google Sheets. Use conditional formatting to highlight Class I recalls in red. Build a rolling log of all recalls by running daily and appending new records.

#### Apify API — Programmatic Integration

```javascript
// Trigger a recall monitor run via API
const run = await fetch("https://api.apify.com/v2/acts/YOUR_ACTOR_ID/runs", {
  method: "POST",
  headers: {
    "Content-Type":  "application/json",
    "Authorization": "Bearer YOUR_TOKEN"
  },
  body: JSON.stringify({
    monitor_source: "FDA",
    keyword:        "salmonella",
    risk_filter:    "Class I",
    max_results:    50
  })
});
```

#### Legal Case Management

Export the structured JSON output with `Compliance_Grade: "CERTIFIED"` fields for use in product liability case documentation. All records include `Recall_ID`, `Recall_Date`, `Source_Link`, and full product/reason text.

#### n8n Workflow Automation

Use the Apify node in n8n to pull recall data on a schedule and route records by risk class — Class I to an urgent Slack channel, Class II to a daily digest email, Class III to a compliance database.

***

### ❓ FAQ

**Q: Is this data actually from the FDA and NHTSA — or a third-party aggregator?**
A: Directly from `api.fda.gov` and `api.nhtsa.dot.gov`. No third-party aggregators, no middlemen, no data lag. Every record includes a `"Compliance_Grade": "CERTIFIED"` flag confirming the government source.

**Q: Do I need an FDA or NHTSA API key?**
A: No. Both `api.fda.gov` and `api.nhtsa.dot.gov` are free public APIs with no authentication required. This actor works out of the box with no setup.

**Q: How current is the recall data?**
A: The FDA API reflects the current state of the openFDA enforcement database, which is updated continuously by the FDA. NHTSA data is similarly near-real-time. Each record includes a `Timestamp` showing exactly when it was fetched.

**Q: Can I monitor only Class I (life-threatening) recalls?**
A: Yes. Set `"risk_filter": "Class I"` to receive only the most urgent FDA recalls. For NHTSA, all vehicle recalls are labeled `"Safety Critical"` — there is no sub-classification in the NHTSA system.

**Q: Can I search for a specific product brand or drug name?**
A: Yes. Use the `keyword` parameter. It searches across `product_description` and `reason_for_recall` using FDA's Lucene query syntax. Examples: `"keyword": "tylenol"`, `"keyword": "beef"`, `"keyword": "battery"`.

**Q: Can I search NHTSA recalls for a specific car I own?**
A: Yes. Provide `vehicle_make`, `vehicle_model`, and `vehicle_year` in the input. For example: `"HONDA"`, `"CIVIC"`, `"2020"`. The actor returns all open safety recalls for that exact vehicle.

**Q: What happens if a government API is temporarily unavailable?**
A: The actor retries up to 3 times with increasing delay (20s, 40s, 60s) on rate limits. On SSL errors, it retries without proxy. On persistent failure, it logs the error, skips that source, and returns whatever data was successfully collected.

**Q: Can I use this data in a legal or compliance document?**
A: The data originates from official US government APIs and carries a `"Compliance_Grade": "CERTIFIED"` flag. However, always consult a legal professional for regulatory or litigation use. The actor is a data retrieval tool — it does not constitute legal advice.

**Q: How do I set up daily recall alerts for my team?**
A: Use Apify's built-in **Schedule** feature to run daily with your chosen keywords and risk filter. Connect the run completion webhook to Zapier or Make to send a formatted email or Slack digest to your team.

**Q: Is proxy needed to access FDA and NHTSA APIs?**
A: Generally no — these are fully public US government APIs. Proxy is optional and only recommended if you are running from an IP with restricted access to US government servers.

***

### 📜 Changelog

#### v1.0.0 (Current)

- ✅ FDA Food Recalls via `api.fda.gov/food/enforcement.json`
- ✅ FDA Drug Recalls via `api.fda.gov/drug/enforcement.json`
- ✅ FDA Medical Device Recalls via `api.fda.gov/device/enforcement.json`
- ✅ FDA Other (biologics, veterinary, cosmetics) via `api.fda.gov/other/enforcement.json`
- ✅ NHTSA Vehicle Recalls via `api.nhtsa.dot.gov/recalls/recallsByVehicle`
- ✅ Vehicle search by make, model, and model year
- ✅ FDA Class I / II / III risk classification with plain-language labels
- ✅ `risk_filter` parameter for Class I-only alert runs
- ✅ `keyword` parameter with FDA Lucene query syntax
- ✅ `product_type` filter to narrow FDA query to a single category
- ✅ SSL error handling with automatic proxy bypass retry
- ✅ Rate-limit retry with exponential backoff (up to 3 attempts)
- ✅ `"Compliance_Grade": "CERTIFIED"` flag on all records
- ✅ Results saved to Dataset and Key-Value Store (`results.json`)
- ✅ Residential proxy support via `curl_cffi` Chrome 110 impersonation
- 🔜 **Coming next:** CPSC (Consumer Product Safety Commission) recalls

***

### ⚖️ Legal & Compliance Notice

This actor retrieves data from **official US federal government public APIs** — `api.fda.gov` (Food and Drug Administration) and `api.nhtsa.dot.gov` (National Highway Traffic Safety Administration). Both APIs are free, public, and intended for use by developers, researchers, and compliance professionals.

**Data use guidelines:**

- All recall data retrieved is publicly available and published by US government agencies
- Data is provided for informational, research, compliance monitoring, and alerting purposes
- This actor is not affiliated with, endorsed by, or operated by the FDA, NHTSA, or any US government agency
- Recall data accuracy depends on the government source — always verify critical safety actions directly with the issuing agency
- Do not use this data as a substitute for professional legal, medical, or regulatory advice

**Safety Disclaimer:** If you believe a product poses an immediate safety risk, contact the FDA at 1-800-FDA-1088 or NHTSA at 1-888-327-4236 directly. Do not rely solely on this actor for real-time emergency safety decisions.

***

### 🤝 Support

- **Bug or broken endpoint?** Contact via the Apify actor page — government API endpoints occasionally change and fixes are prioritized
- **Need CPSC, RAPEX, or other recall agencies?** Drop a feature request — expansion is actively planned
- **Works well for your compliance workflow?** A ⭐ review on the Apify Store helps others find this actor and keeps it actively maintained

***

<p align="center">
  <strong>FDA & NHTSA Product Recall Monitor · Built on Apify</strong><br/>
  <em>FDA · NHTSA · Official Government APIs · Food · Drug · Device · Vehicle · Compliance Grade · Real-Time</em>
</p>

# Actor input Schema

## `monitor_source` (type: `string`):

Which recall database to query

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

Search by product name or keyword. E.g: 'baby food', 'Toyota', 'peanut butter', 'brake system', 'airbag'

## `product_type` (type: `string`):

Filter FDA recalls by product category

## `vehicle_make` (type: `string`):

Vehicle brand for NHTSA search. E.g: TOYOTA, FORD, TESLA, BMW, HONDA, GM

## `vehicle_model` (type: `string`):

Vehicle model. E.g: CAMRY, F-150, MODEL 3, CIVIC

## `vehicle_year` (type: `string`):

4-digit model year. E.g: 2022, 2023, 2024

## `risk_filter` (type: `string`):

Filter by risk/classification level

## `max_results` (type: `integer`):

Maximum recall records to return

## `proxyConfiguration` (type: `object`):

RESIDENTIAL proxy recommended. FDA/NHTSA APIs are public.

## Actor input object example

```json
{
  "monitor_source": "ALL",
  "product_type": "",
  "risk_filter": "",
  "max_results": 30,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# 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 = {
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapepilot/fda-nhtsa-recall-monitor---official-gov-data").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 = { "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    } }

# Run the Actor and wait for it to finish
run = client.actor("scrapepilot/fda-nhtsa-recall-monitor---official-gov-data").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 '{
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call scrapepilot/fda-nhtsa-recall-monitor---official-gov-data --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=scrapepilot/fda-nhtsa-recall-monitor---official-gov-data",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "FDA & NHTSA Recall Monitor – Official Gov Data",
        "description": "Live recalls from FDA (food/drugs/devices) & NHTSA (vehicles). Official US gov data, no API key. Risk levels: Class I (urgent) to III. Get scope, product description, affected units. Perfect for compliance, retail, auto, healthcare. Export JSON/CSV.",
        "version": "0.0",
        "x-build-id": "Ds5gejTiBAYHh9Sdp"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapepilot~fda-nhtsa-recall-monitor---official-gov-data/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapepilot-fda-nhtsa-recall-monitor---official-gov-data",
                "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/scrapepilot~fda-nhtsa-recall-monitor---official-gov-data/runs": {
            "post": {
                "operationId": "runs-sync-scrapepilot-fda-nhtsa-recall-monitor---official-gov-data",
                "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/scrapepilot~fda-nhtsa-recall-monitor---official-gov-data/run-sync": {
            "post": {
                "operationId": "run-sync-scrapepilot-fda-nhtsa-recall-monitor---official-gov-data",
                "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": {
                    "monitor_source": {
                        "title": "Data Source",
                        "enum": [
                            "ALL",
                            "FDA",
                            "NHTSA"
                        ],
                        "type": "string",
                        "description": "Which recall database to query",
                        "default": "ALL"
                    },
                    "keyword": {
                        "title": "Product / Keyword Search",
                        "type": "string",
                        "description": "Search by product name or keyword. E.g: 'baby food', 'Toyota', 'peanut butter', 'brake system', 'airbag'"
                    },
                    "product_type": {
                        "title": "FDA Product Type",
                        "enum": [
                            "",
                            "food",
                            "drug",
                            "device"
                        ],
                        "type": "string",
                        "description": "Filter FDA recalls by product category",
                        "default": ""
                    },
                    "vehicle_make": {
                        "title": "Vehicle Make (NHTSA)",
                        "type": "string",
                        "description": "Vehicle brand for NHTSA search. E.g: TOYOTA, FORD, TESLA, BMW, HONDA, GM"
                    },
                    "vehicle_model": {
                        "title": "Vehicle Model (NHTSA)",
                        "type": "string",
                        "description": "Vehicle model. E.g: CAMRY, F-150, MODEL 3, CIVIC"
                    },
                    "vehicle_year": {
                        "title": "Vehicle Year (NHTSA)",
                        "type": "string",
                        "description": "4-digit model year. E.g: 2022, 2023, 2024"
                    },
                    "risk_filter": {
                        "title": "Risk Level Filter",
                        "enum": [
                            "",
                            "CLASS I",
                            "CLASS II",
                            "CLASS III"
                        ],
                        "type": "string",
                        "description": "Filter by risk/classification level",
                        "default": ""
                    },
                    "max_results": {
                        "title": "Max Records",
                        "type": "integer",
                        "description": "Maximum recall records to return",
                        "default": 30
                    },
                    "proxyConfiguration": {
                        "title": "Proxy (RESIDENTIAL Recommended)",
                        "type": "object",
                        "description": "RESIDENTIAL proxy recommended. FDA/NHTSA APIs are public."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
