# CPSC Product Recalls Scraper - SaferProducts Data (`maydit/us-product-recalls-scraper`) Actor

Scrape full CPSC product recall data from SaferProducts.gov - retailers, UPCs, hazards, remedies, units affected. No API key. Export JSON/CSV for compliance monitoring.

- **URL**: https://apify.com/maydit/us-product-recalls-scraper.md
- **Developed by:** [Brandt May](https://apify.com/maydit) (community)
- **Categories:** News, E-commerce
- **Stats:** 2 total users, 0 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.40 / 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/platform/actors/running/actors-in-store#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

## CPSC Product Recalls Scraper - Full SaferProducts.gov Recall Data

> The deepest, cleanest CPSC recall feed on Apify - every recall flattened to one row with retailers, UPCs, hazards, remedies, and units affected. No API key required.

### What it does

This **CPSC product recalls scraper** queries the official **CPSC SaferProducts.gov recalls API** and flattens deeply nested responses into one clean record per recall. Unlike a bare keyword scraper, it returns the *full* recall detail buyers actually need for automated compliance monitoring - recalling manufacturers, importers, and **retailers**, product **UPCs**, hazard descriptions, remedy options, and units affected. You can filter by keyword, product name, manufacturer, exact recall number, or date range, then export the **US consumer product recalls dataset** to JSON, CSV, or Excel. It requires no API key because it reads a public government data source. This is the CPSC leg of a three-agency recalls suite alongside FDA and NHTSA scrapers - combine all three for a single **FDA + NHTSA + CPSC recall aggregator** feed.

### Who it's for

- **Retail & e-commerce compliance teams** removing recalled SKUs from shelves and listings
- **Quality assurance & product-safety teams** monitoring hazards across their catalog
- **Online marketplaces** screening third-party listings against active recalls
- **Insurers** assessing risk tied to recalled products and reported injuries
- **Importers & distributors** tracking recall activity by manufacturer
- **Journalists & investigators** reporting on recall trends and safety incidents

### What you get / Output

Each run produces a flat dataset with one record per recall. Fields:

| Field | Description |
|---|---|
| `recallId` | Internal CPSC recall record identifier |
| `recallNumber` | Official CPSC recall number (e.g. `26596`) |
| `recallDate` | Date the recall was announced |
| `title` | Recall headline |
| `description` | Full recall description text |
| `products` | Recalled product name(s) |
| `productModels` | Affected model numbers / variants |
| `unitsAffected` | Number of units recalled |
| `hazards` | Hazard descriptions (fire, choking, suffocation, lithium battery, etc.) |
| `injuries` | Reported injuries or incidents |
| `remedies` | Remedy options (refund / repair / replace) |
| `manufacturers` | Recalling manufacturer(s) |
| `retailers` | Where the product was sold (retailer / channel) |
| `importers` | Importer(s) of record |
| `upcs` | Product UPC codes |
| `soldAt` | Sold-at labels / storefront details |
| `imageUrl` | Product image URL |
| `consumerContact` | Consumer contact info for the recall |
| `url` | Official CPSC recall webpage |

### Input / How to query

Set any combination of filters. Leave a field empty to skip it.

| Input | What it does |
|---|---|
| `keyword` | Full-text match across title, description, hazard, product, manufacturer, or retailer (e.g. `fire`, `lithium battery`, `Amazon`) |
| `productName` | Case-insensitive partial match on product name (e.g. `crib`, `heater`) |
| `manufacturer` | Case-insensitive partial match on manufacturer (e.g. `Samsung`) |
| `recallNumber` | Exact lookup of one recall by number - overrides all other filters |
| `recalledSince` | Only recalls on or after this date (`YYYY-MM-DD`) |
| `recalledUntil` | Only recalls on or before this date (`YYYY-MM-DD`) |

Under the hood the actor walks history in year-window chunks and applies your keyword filter client-side, so date-range pulls stay complete and reliable.

### Example use cases

- **E-commerce compliance sweep** - run `keyword` = `lithium battery` weekly to catch new battery-hazard recalls before they hit your marketplace listings.
- **Catalog match by manufacturer** - pull every recall for a supplier via `manufacturer` = `Samsung` and reconcile against your active SKUs.
- **UPC-level recall check** - export the full feed and join on the `upcs` field to flag any recalled UPC in your inventory system.
- **Litigation research** - use `recallNumber` for an exact recall, or `productName` to gather all recalls for a product family with hazards, injuries, and remedies attached.
- **Historical trend analysis** - set `recalledSince` and `recalledUntil` to pull a multi-year window for reporting on recall volume by hazard or category.

### Recurring use / scheduling

This actor is built for automated monitoring, not one-off pulls. Use Apify **Schedules** to run it on a cron (e.g. every morning or every Monday) with a rolling `recalledSince` window so each run only returns fresh recalls. Because `recallNumber` is a stable unique key, you can deduplicate across runs by keying on `recallNumber` (or `recallId`) in your downstream store - append only records you haven't seen before, and wire new rows into alerts, a Slack/email notification, or your compliance dashboard.

### FAQ

### How do I get CPSC product recall data without an API key?

This actor reads the public **CPSC SaferProducts.gov** recalls API directly - no key, no signup, no auth. Set your filters and run it; results land in an Apify dataset ready to export.

### Is there an API for SaferProducts.gov recalls?

Yes - CPSC publishes a public recalls API, and this actor wraps it into a clean, flat schema. You get one row per recall with retailers, UPCs, hazards, and remedies already unpacked from the raw nested JSON.

### How can I monitor new product recalls automatically?

Schedule the actor on a cron with a rolling `recalledSince` date. Each run returns recent recalls; dedupe on `recallNumber` and push new rows to an alert or dashboard for hands-off monitoring.

### How do I export CPSC recalls to CSV or Excel?

Every run writes a dataset you can download as CSV, Excel, JSON, or XML from the Apify console, or pull via the Apify API for a **product recall JSON / CSV export** into your own systems.

### How do I search product recalls by UPC or manufacturer?

Filter by `manufacturer` for partial-match manufacturer search, or export the full feed and match on the `upcs` field to find recalls tied to a specific UPC in your catalog.

### How do I get recall data with retailers, hazards, and remedies?

Those are first-class output fields here: `retailers`, `hazards`, and `remedies` (refund / repair / replace) come on every record, along with `unitsAffected` and `injuries` - the detail most bare recall scrapers drop.

### How do I set up product recall alerts for my e-commerce store?

Schedule the actor, dedupe on `recallNumber`, and connect the new rows to a notification integration (email, Slack, webhook) or your monitoring stack so your store is alerted the moment a relevant recall posts.

### What is the best way to track consumer product recalls for compliance?

Run a scheduled pull filtered to your product categories or hazards, store results keyed on `recallNumber` for a clean audit trail, and reconcile the `products`, `upcs`, and `manufacturers` fields against your inventory.

### How do I pull historical CPSC recalls by date range?

Set `recalledSince` and `recalledUntil` (both `YYYY-MM-DD`). The actor chunks history into year windows so multi-year pulls come back complete.

### Can I combine CPSC, FDA, and NHTSA recall data in one feed?

Yes - this is the CPSC leg of a three-agency suite. Pair it with the matching FDA and NHTSA actors and merge their datasets into a single **FDA + NHTSA + CPSC recall aggregator** feed on a shared schedule.

### Data source & notes

- **Source:** the official **U.S. Consumer Product Safety Commission (CPSC)** SaferProducts.gov recalls API - public U.S. government data, free to access and use.
- **No API key** is required.
- Coverage is limited to what CPSC publishes: consumer products (toys, appliances, electronics, furniture, nursery, sporting goods, etc.). Vehicle recalls are NHTSA's domain and food/drug/cosmetic recalls are FDA's - use the companion actors for those.
- The actor reflects CPSC's own data; it does not add, infer, or correct fields beyond flattening the API response.
- Actor: `maydit/us-product-recalls-scraper` (id `DqX2SMVuwVL8nPeYB`).

### Related actors

Part of a set of US public-records tools that work well together:

- [FDA Recalls Scraper](https://apify.com/maydit/us-fda-recalls-scraper) - drug, device and food recalls
- [NHTSA Recalls Scraper](https://apify.com/maydit/us-vehicle-recalls-scraper) - vehicle recalls and complaints

> Running all three recall sources together (FDA, CPSC and NHTSA) gives near-complete US recall coverage across regulated products.

See all fifteen at [apify.com/maydit](https://apify.com/maydit).

**Free guide:** [The CPSC SaferProducts API, pagination and all](https://mayd-it.com/data-tools/guides/cpsc-recall-api/) - the undocumented traps in this data source, measured against the live API.

### Found this useful?

If this actor saved you time, a short review on the Apify Store genuinely helps. Reviews are how the next person decides whether a tool is worth trying.

Something broken, missing a field, or a source you want covered? Open an issue on the **Issues** tab and it will get looked at - that is the fastest route to getting it changed.

# Actor input Schema

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

Filter recalls whose title, description, hazard, product, manufacturer, or retailer mentions this term — e.g. 'fire', 'choking', 'lithium battery', 'Amazon'. Leave empty for all.

## `productName` (type: `string`):

Filter by product name (case-insensitive partial match), e.g. 'bicycle', 'crib', 'heater'. Leave empty for all.

## `manufacturer` (type: `string`):

Filter by manufacturer name (case-insensitive partial match), e.g. 'Samsung'. Leave empty for all.

## `recallNumber` (type: `string`):

Look up one specific CPSC recall by its number (e.g. '26596'). When set, the other filters are ignored.

## `recalledSince` (type: `string`):

Only recalls announced on or after this date (YYYY-MM-DD). Defaults to the last 3 years if empty. Great for weekly monitoring.

## `recalledUntil` (type: `string`):

Only recalls announced on or before this date (YYYY-MM-DD).

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

Upper bound on recalls returned per run.

## Actor input object example

```json
{
  "keyword": "fire",
  "recalledSince": "2026-01-01",
  "maxResults": 500
}
```

# 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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("maydit/us-product-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 = {}

# Run the Actor and wait for it to finish
run = client.actor("maydit/us-product-recalls-scraper").call(run_input=run_input)

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

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

```

## CLI example

```bash
echo '{}' |
apify call maydit/us-product-recalls-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

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