# US Recalls Scraper (`zerobreak/us-recalls-scraper`) Actor

US Recalls Scraper is a Python tool designed to extract public product safety recall data across major U.S. government agencies (FDA, CPSC, USDA, NHTSA). It exports hazard details, affected products, and dates into structured CSV or JSON formats for compliance and safety research.

- **URL**: https://apify.com/zerobreak/us-recalls-scraper.md
- **Developed by:** [ZeroBreak](https://apify.com/zerobreak) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.99 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## 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.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## US Recalls Scraper: FDA, NHTSA and CPSC Recalls in One Dataset (Free)

<p align="center">
  <img src="https://imgur.com/0P5e7kl.png" alt="US Recalls Scraper" width="800">
</p>

US Recalls Scraper collects US government product recall information into a unified dataset. It covers FDA food, drug, and medical device recalls, NHTSA vehicle recalls, and CPSC consumer-product recalls.

Choose a collection mode, specify a date range, and optionally filter by keywords, recalling firms, vehicle details, or campaign numbers. The scraper also supports VIN decoding and can retrieve matching vehicle recalls.

Export structured records as JSON, CSV, or Excel for product safety monitoring, compliance research, automotive recall checks, and reporting.

### Use Cases

- **Retailers and Amazon sellers:** Monitor product recalls to support product safety checks.
- **Compliance and QA teams:** Collect food, drug, and medical device recall records for a selected date range.
- **Car dealers and fleets:** Look up vehicle recalls by make, model, year, or campaign number.
- **VIN recall checks:** Decode vehicle identification numbers and retrieve matching recall campaigns.
- **Insurers:** Research vehicles associated with specific recall campaigns.
- **Journalists and researchers:** Track recalling firms, product hazards, and recall trends.
- **Consumer applications:** Incorporate structured vehicle and product recall records into data workflows.

### Collection Modes

| Mode | Input | Results |
|---|---|---|
| `all` | Date range and optional keyword | FDA food, drug, and device recalls, plus CPSC recalls |
| `fda` | Categories, keyword, firm, classification, and dates | FDA enforcement recall records |
| `cpsc` | Date range and optional keyword | Consumer-product recall records |
| `vehicle` | Make, model, year, or campaign numbers | NHTSA vehicle recall records |
| `vin` | One or more 17-character VINs | Vehicle decoding results and optional matching NHTSA recalls |

USDA FSIS meat and poultry recalls are not included because the source returns HTTP 403 from a datacenter IP.

### Input Parameters

| Parameter | Type | Default | Description |
|---|---|---|---|
| `mode` | string | `all` | Select `all`, `fda`, `cpsc`, `vehicle`, or `vin`. |
| `fdaCategories` | array | `food`, `drug`, `device` | FDA datasets to search. |
| `keyword` | string | Empty | Filters FDA product descriptions and reasons, or CPSC titles and descriptions. |
| `recallingFirm` | string | Empty | Filter FDA recalls by recalling firm. |
| `fdaClassification` | string | `any` | Select FDA Class I, Class II, Class III, or any classification. |
| `dateFrom` | string | 30 days ago | Start date for recall collection. |
| `dateTo` | string | Today (UTC) | End date for recall collection. |
| `vehicles` | array | Honda Accord 2020 | Vehicle objects containing `make`, `model`, and `modelYear`. |
| `campaignNumbers` | array | Empty | NHTSA campaign numbers to look up. |
| `vins` | array | Empty | Vehicle identification numbers, one per item. |
| `vinCheckRecalls` | boolean | `true` | Retrieve matching NHTSA recalls for decoded vehicles when possible. |
| `maxItems` | integer | `200` | Maximum number of recall and VIN rows. Hard maximum: 5,000. |
| `includeRaw` | boolean | `false` | Include the original source record in the `raw` field. |
| `openFdaApiKey` | string | Empty | Optional key to increase the available daily request allowance. The key is not saved in dataset records or logs. |
| `timeoutSecs` | integer | `300` | Maximum runtime in seconds. |
| `requestTimeoutSecs` | integer | `30` | Per-request timeout. CPSC requests use at least 90 seconds. |

### Example Input

```json
{
  "mode": "all",
  "keyword": "listeria",
  "dateFrom": "2026-09-12",
  "dateTo": "2026-10-12",
  "maxItems": 200
}
```

For vehicle mode, use the default vehicle or provide your own make, model, and model year. You can also supply campaign numbers.

For VIN mode, provide 17-character VINs. A VIN with an invalid check digit may still return decoded information, with `errorCode` and `errorText` indicating the result.

### What Data Does This Actor Extract?

Each recall record follows a consistent schema. The `recallTitle` field contains the display title and is also stored as `title`.

#### Example Recall Record

```json
{
  "rowKind": "recall",
  "source": "nhtsa",
  "recallId": "20V771000",
  "recallTitle": "HONDA ACCORD 2020 - ELECTRICAL SYSTEM:BODY CONTROL MODULE:SOFTWARE",
  "title": "HONDA ACCORD 2020 - ELECTRICAL SYSTEM:BODY CONTROL MODULE:SOFTWARE",
  "reason": "Honda is recalling certain 2018-2020 Accord Sedan vehicles.",
  "company": "Honda (American Honda Motor Co.)",
  "recallDate": "2020-10-12",
  "remedy": "Honda will notify owners, and dealers will update the BCM software, free of charge.",
  "consequence": "The software can increase the risk of a crash.",
  "vehicle": {
    "make": "HONDA",
    "model": "ACCORD",
    "modelYear": "2020",
    "component": "ELECTRICAL SYSTEM:BODY CONTROL MODULE:SOFTWARE"
  }
}
```

#### Output Fields

| Field | Type | Description |
|---|---|---|
| `source` | string | Source category: `fda_food`, `fda_drug`, `fda_device`, `nhtsa`, or `cpsc`. |
| `recallId` | string | FDA recall number, NHTSA campaign number, or CPSC recall number. |
| `recallTitle` | string | Short recall title, also stored as `title`. FDA product text is limited to 120 characters in this field. |
| `productDescription` | string | Product description or additional summary text. |
| `reason` | string | Recall reason or CPSC hazard description. |
| `hazard` | string or array | CPSC hazard information, when available. |
| `classification` | string | FDA recall classification. |
| `status` | string | FDA recall status, when available. |
| `company` | string | Recalling firm, manufacturer, or importer. |
| `companyCountry` | string | Company country, when available. |
| `companyState` | string | FDA firm state, when available. |
| `recallDate` | string | Recall date in ISO format. |
| `reportDate` | string | Report date in ISO format. |
| `terminationDate` | string | FDA termination date, when available. |
| `distribution` | string | FDA distribution information. |
| `quantity` | string | Quantity or units, preserving source formatting where applicable. |
| `remedy` | string | Repair, replacement, refund, or other remedy information. |
| `consequence` | string | Potential vehicle consequence, when available. |
| `injuries` | string | CPSC injury information, when available. |
| `url` | string | CPSC recall page, when provided. |
| `images` | array | CPSC product image references. |
| `vehicle` | object | Vehicle make, model, year, component, and unit information. |
| `identifiers` | object | Identifiers such as NDC, brand name, UPC, and event ID. |
| `raw` | object | Original source record, included when `includeRaw` is enabled. |

#### VIN Output

VIN records use `rowKind: "vin_decode"` and may include:

- `vin`
- `make`
- `model`
- `modelYear`
- `trim`
- `bodyClass`
- `vehicleType`
- `manufacturer`
- `plantCountry`
- `fuelTypePrimary`
- `errorCode`
- `errorText`
- `isValid`
- `recallCount`

The `isValid` field is `true` only when `errorCode` is `0`.

#### Error Records

Failed inputs are saved as error rows with fields such as `sourceInput`, `error`, and `statusCode`. One invalid VIN does not stop the entire run.

A “No matches found” response from FDA is treated as an empty result rather than a request failure.

The dataset includes separate views for **Recalls, Vehicles, VINs, and Errors**.

### How It Works

1. Read the selected mode, date range, filters, and record limit.
2. Use default dates covering the last 30 days through the current UTC date when dates are not supplied.
3. Retrieve records for the selected source and collection mode.
4. Normalize dates from supported formats, including `YYYYMMDD`, `MM/DD/YYYY`, and ISO timestamps.
5. Standardize the recall fields across sources.
6. Remove duplicate recall records while preserving separate vehicle-specific campaign records when appropriate.
7. Sort recall records by date, newest first.
8. Stop when the record limit or runtime limit is reached.
9. Save successful records and applicable error rows to the dataset.

### Dataset and Export

The actor produces structured data suitable for:

- JSON, CSV, and Excel exports.
- Product safety and compliance reports.
- Vehicle fleet and VIN recall research.
- Recall history tracking.
- Data analysis with Python and Pandas.
- Scheduled monitoring and downstream automation.

### Schedules and Alerts

Schedule recurring runs to monitor a keyword, recalling firm, product category, or vehicle list. Scheduled datasets can be connected to supported notification and automation workflows.

For example, a retailer can schedule regular recall checks and review newly collected records, while a fleet manager can monitor recalls associated with selected vehicle models.

### Limits and Data Usage

- FDA enforcement records may be refreshed approximately weekly. Results depend on what has been published by the agency.
- Without an optional FDA key, the actor observes a limit of 1,000 requests per day per IP for FDA requests.
- With an FDA key, the documented daily allowance is higher, subject to the applicable service limits.
- FDA request pacing is at least 0.3 seconds between calls.
- FDA page size is limited to 1,000 records per request, and the skip value does not exceed 25,000.
- Larger result sets may be split into date windows.
- CPSC requests can take longer than other requests, so they use a minimum request timeout of 90 seconds.
- CPSC date ranges are processed in windows of 31 days. The end date and keyword are applied locally.
- VINs are decoded individually.
- The maximum number of rows per run is 5,000.
- The maximum overall runtime is 3,600 seconds.
- Only information returned by the relevant source can be collected; unpublished or unavailable records may not appear.

### Frequently Asked Questions

#### Does this scraper include USDA meat and poultry recalls?

No. USDA FSIS meat and poultry recalls are excluded because the service returns HTTP 403 from a datacenter IP.

#### Do I need an FDA API key?

No. An FDA key is optional. It increases the available daily request allowance, while runs without a key remain subject to the lower request limit.

#### How does a VIN recall check work?

The actor decodes the supplied VIN. When the decoded vehicle has a make, model, and year, the scraper can retrieve matching NHTSA recall records if `vinCheckRecalls` is enabled.

#### Can a VIN with an invalid check digit return data?

Yes. The decoder may return vehicle information while providing `errorCode` and `errorText` to indicate the validation result.

#### How fresh is the recall data?

Freshness depends on the source. FDA enforcement information may be refreshed approximately weekly, while CPSC and NHTSA results depend on the records available when the run executes.

#### Can I export the results?

Yes. Export the dataset in JSON, CSV, or Excel format.

#### Can I receive recall alerts?

Yes. Schedule recurring runs and connect supported integrations to send notifications or transfer new records to other systems.

#### What happens if one request fails?

The actor records relevant errors in the dataset and continues processing other inputs whenever possible.

### Pricing

The actor is free to run. Apify platform usage is billed separately according to the applicable plan.

### Integrations

The dataset can be used with supported integrations, spreadsheet tools, automation platforms, databases, and webhooks.

### Trademark Notice

The U.S. Food and Drug Administration, the National Highway Traffic Safety Administration, the U.S. Consumer Product Safety Commission, and their respective names, logos, and trademarks belong to their owners. Their use in this documentation is solely to identify the data sources and does not imply affiliation, sponsorship, endorsement, or partnership.

### Disclaimer

This actor is an independent tool and is not affiliated with, endorsed by, sponsored by, or officially associated with the U.S. Food and Drug Administration, the National Highway Traffic Safety Administration, or the U.S. Consumer Product Safety Commission.

Users are responsible for complying with applicable source terms, rate limits, licensing conditions, and attribution requirements.

### Is Web Scraping Legal?

Collecting information that is already public is generally legal. Scraping is not the same thing as hacking, and there is no single law that bans it. The limits are the usual ones: do not break into accounts, do not take private or confidential data, and be careful with personal data and copyrighted works. A site's terms can also restrict how you access it. Facts such as a public name, price, or rating are not the same thing as republishing someone's article or photo.

This actor collects publicly accessible recall information. It does not log in and it does not bypass access controls.

# Actor input Schema

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

Which public source to query. All runs FDA and CPSC for the date range. Vehicle and VIN modes use NHTSA and vPIC.

## `fdaCategories` (type: `array`):

openFDA enforcement datasets to search in FDA and All modes. Food, drug, and device are separate APIs.

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

Matched in FDA product_description/reason_for_recall and CPSC title/description (CPSC filtered client-side).

## `recallingFirm` (type: `string`):

FDA recalling firm name. Sent to openFDA as a quoted recalling_firm search. Leave empty to skip.

## `fdaClassification` (type: `string`):

FDA recall class. Class I is the most serious. Any leaves the classification filter off.

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

Default: 30 days ago. FDA filters report_date. CPSC uses this as RecallDateStart and drops newer rows past dateTo locally.

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

Last report date to include. Defaults to today (UTC). FDA includes this day. CPSC rows after this date are dropped locally.

## `vehicles` (type: `array`):

List of {"make":"honda","model":"accord","modelYear":2020}. Used in Vehicle mode.

## `campaignNumbers` (type: `array`):

NHTSA campaign numbers, one per line, such as 20V314000. Used in Vehicle mode. One campaign can return several make/model/year rows.

## `vins` (type: `array`):

17-character vehicle identification numbers, one per line. Used in VIN mode. Each VIN is decoded with NHTSA vPIC.

## `vinCheckRecalls` (type: `boolean`):

After a VIN decodes, look up NHTSA recalls for that make, model, and model year.

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

Free version cap: 5,000 per run. Counts recall rows and VIN decode rows. Error rows are extra.

## `includeRaw` (type: `boolean`):

Store the source API object on each recall row in raw. Leave off to keep the dataset small.

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

Raises openFDA limits; free at open.fda.gov. Without a key the run stays at or under 1,000 openFDA requests and waits at least 0.3 seconds between them.

## `timeoutSecs` (type: `integer`):

Stop the run after this many seconds and keep rows already collected. Default 300. Maximum 3600.

## `requestTimeoutSecs` (type: `integer`):

Per-request timeout for openFDA, NHTSA, and vPIC. CPSC uses at least 90 seconds because that API is slow.

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

Optional proxy for requests. Default is no proxy. These government APIs are public. Turn on Apify Proxy only if a source blocks the run IP.

## Actor input object example

```json
{
  "mode": "all",
  "fdaCategories": [
    "food",
    "drug",
    "device"
  ],
  "keyword": "listeria",
  "recallingFirm": "Pharmatech LLC",
  "fdaClassification": "any",
  "vehicles": [
    {
      "make": "honda",
      "model": "accord",
      "modelYear": 2020
    }
  ],
  "campaignNumbers": [
    "20V314000"
  ],
  "vins": [
    "1HGCV1F30LA000001"
  ],
  "vinCheckRecalls": true,
  "maxItems": 200,
  "includeRaw": false,
  "timeoutSecs": 300,
  "requestTimeoutSecs": 30,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

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

Source, recall date, title, company, class, and reason.

## `vehicles` (type: `string`):

NHTSA campaign, make, model, year, and title.

## `vins` (type: `string`):

Decoded VIN, make, model, year, vPIC error code, and recall count.

## `errors` (type: `string`):

Inputs that failed, with the error code and HTTP status.

## `dataset` (type: `string`):

Every row from the run, without a table view applied.

# 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 = {
    "vehicles": [
        {
            "make": "honda",
            "model": "accord",
            "modelYear": 2020
        }
    ],
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("zerobreak/us-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 = {
    "vehicles": [{
            "make": "honda",
            "model": "accord",
            "modelYear": 2020,
        }],
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("zerobreak/us-recalls-scraper").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 '{
  "vehicles": [
    {
      "make": "honda",
      "model": "accord",
      "modelYear": 2020
    }
  ],
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call zerobreak/us-recalls-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,zerobreak/us-recalls-scraper"
        }
    }
}
```

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/a1e7s73bgPDqSR9tR/builds/B4quM5jqDP2MYfsyx/openapi.json
