CPSC Product Recall Monitor

Search and monitor product recalls issued by the U.S. Consumer Product Safety Commission (CPSC). This Apify actor queries the official SaferProducts.gov API and returns structured, clean data on recalled consumer products including hazard details, remedy options, manufacturer information, injury reports, and product images. No API key required.

Why Use This Actor?

The CPSC SaferProducts.gov API returns deeply nested JSON with inconsistent field structures. This actor normalizes everything into a flat, predictable schema suitable for spreadsheets, databases, and automated workflows. Key advantages:

• No infrastructure to manage — Runs in the Apify cloud. No servers, rate limiting, or API pagination to handle.
• Scheduled monitoring — Use Apify schedules to run daily or weekly and get notified when new recalls match your criteria. Ideal for brand protection and supply chain compliance.
• Clean, flat output — The raw CPSC API has 13+ nested object arrays (Products, Hazards, Remedies, Manufacturers, etc.). This actor flattens them into a single record per recall.
• No API key required — The CPSC SaferProducts.gov API is free and open. Zero authentication setup.
• Client-side manufacturer filtering — The CPSC API doesn't support manufacturer search, but this actor filters across manufacturers, importers, and distributors locally.

Features

• Search recalls by keyword, product name, manufacturer, or date range
• Client-side manufacturer filtering across manufacturers, importers, and distributors
• Configurable result limits (up to 10,000 records per run)
• Optional product image URLs in output
• Complete hazard and remedy information for each recall
• UPC codes for affected products when available
• Injury report summaries
• Full supply chain details: manufacturers, retailers, importers, distributors, and countries of manufacture
• Flat JSON output ready for spreadsheets, databases, and APIs

How to Use

1. Go to the CPSC Product Recall Monitor actor page on Apify
2. Click Start to open the input form
3. Enter your search criteria (you can combine multiple filters):
   • Search Keyword: Searches across recall titles (e.g., "battery fire", "lead paint", "choking hazard")
   • Product Name: Filters by specific product type (e.g., "laptop", "stroller", "space heater")
   • Manufacturer: Filters results by manufacturer, importer, or distributor name
   • Start Date / End Date: Restricts results to a date range in YYYY-MM-DD format
4. Set Max Results to control how many records are returned (default: 100)
5. Toggle Include Images on or off depending on whether you need product photo URLs
6. Click Start and wait for the run to complete
7. Download results from the Dataset tab in JSON, CSV, or Excel format

If you leave all filters empty, the actor fetches the most recent recalls from the CPSC database.

Input Parameters

Input Examples

Search for battery-related recalls in 2024:

{
    "keyword": "battery fire",
    "recallDateStart": "2024-01-01",
    "maxResults": 50,
    "includeImages": true
}

Monitor a specific manufacturer's recalls:

{
    "manufacturer": "Fisher-Price",
    "recallDateStart": "2023-01-01",
    "maxResults": 0
}

Child safety product recalls:

{
    "keyword": "choking hazard",
    "productName": "toy",
    "recallDateStart": "2024-06-01",
    "maxResults": 100
}

Latest recalls (no filters):

{
    "maxResults": 50,
    "includeImages": true
}

Tips for Input

• Combine filters for precision — Use a keyword plus a date range (e.g., "choking hazard" + start date "2024-01-01") to narrow results.
• Manufacturer filter — This is applied client-side and searches across manufacturers, importers, and distributors. Use partial names (e.g., "Samsung" will match "Samsung Electronics America").
• Set maxResults to 0 for comprehensive data — retrieves all matching records.
• Date format — All dates must be in YYYY-MM-DD format.

Output Example

Each recall record in the dataset contains the following fields:

{
    "recallId": 25432,
    "recallNumber": "24-117",
    "recallDate": "2024-03-14",
    "title": "Lithium-Ion Battery Packs Recalled Due to Fire and Burn Hazards",
    "description": "The battery packs can overheat, posing fire and burn hazards to consumers. The firm has received 23 reports of the battery packs overheating, including 4 reports of fires and 2 reports of minor burn injuries.",
    "url": "https://www.cpsc.gov/Recalls/2024/Lithium-Ion-Battery-Packs-Recalled",
    "consumerContact": "Contact ExampleCorp toll-free at 800-555-0199 from 8 a.m. to 5 p.m. ET Monday through Friday",
    "lastPublishDate": "2024-03-14",
    "products": "ExampleCorp 20V Lithium-Ion Battery Pack",
    "productTypes": ["Batteries"],
    "units": "About 145,000 (In addition, about 12,000 were sold in Canada)",
    "hazardDescription": "The battery packs can overheat, posing fire and burn hazards.",
    "hazardTypes": ["Fire", "Burn"],
    "remedyDescription": "Consumers should immediately stop using the recalled battery packs and contact ExampleCorp for a free replacement.",
    "remedyOptions": ["Replace"],
    "injuries": ["Two reports of minor burn injuries"],
    "manufacturers": "ExampleCorp Manufacturing Ltd.",
    "retailers": "Home Depot; Lowe's; Amazon.com",
    "importers": "",
    "distributors": "ExampleCorp Tools Inc.",
    "manufacturerCountries": ["China"],
    "upcs": ["012345678901"],
    "images": [
        "https://www.cpsc.gov/s3fs-public/styles/recall_item/public/ExampleBattery.jpg"
    ],
    "extractedAt": "2024-03-15T10:30:00.000Z"
}

Output Fields

Use Cases

• Product safety researchers — Search the CPSC database for hazard trends, injury patterns, and recall frequency across product categories
• E-commerce businesses — Check supplier inventory against active recalls before listing products for sale
• Compliance teams — Monitor industry-specific recalls to ensure your products meet current safety standards
• Journalists — Track recall trends, identify repeat offenders, and build data-driven stories about product safety
• Brand protection — Monitor recalls mentioning your company name or product lines, set up alerts for new entries
• Supply chain managers — Track recalls by manufacturer country to assess geographic supply chain risks
• Parents and consumer advocates — Stay informed about child safety recalls for toys, cribs, and baby products

API & Programmatic Access

Python

from apify_client import ApifyClient

client = ApifyClient("YOUR_API_TOKEN")

run = client.actor("ryanclinton/cpsc-recall-monitor").call(run_input={
    "keyword": "battery fire",
    "recallDateStart": "2024-01-01",
    "maxResults": 50,
    "includeImages": True,
})

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(f"[{item['recallNumber']}] {item['title']}")
    print(f"  Hazards: {', '.join(item['hazardTypes'])}")
    print(f"  Remedy: {', '.join(item['remedyOptions'])}")
    print(f"  Units: {item['units']}")

JavaScript

import { ApifyClient } from 'apify-client';

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

const run = await client.actor('ryanclinton/cpsc-recall-monitor').call({
    keyword: 'battery fire',
    recallDateStart: '2024-01-01',
    maxResults: 50,
    includeImages: true,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach(item => {
    console.log(`[${item.recallNumber}] ${item.title}`);
    console.log(`  Hazards: ${item.hazardTypes.join(', ')}`);
    console.log(`  Remedy: ${item.remedyOptions.join(', ')}`);
});

cURL

# Start the actor
curl -X POST "https://api.apify.com/v2/acts/ryanclinton~cpsc-recall-monitor/runs?token=YOUR_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "keyword": "battery fire",
    "recallDateStart": "2024-01-01",
    "maxResults": 50
  }'

# Fetch results (use defaultDatasetId from the response above)
curl "https://api.apify.com/v2/datasets/DATASET_ID/items?token=YOUR_API_TOKEN&format=json"

How It Works — Technical Details

Input: keyword, productName, manufacturer, dates, maxResults
  │
  ▼
┌─────────────────────────────────────────────────────────┐
│ BUILD API URL                                           │
│                                                         │
│ Base: saferproducts.gov/RestWebServices/Recall           │
│ Params:                                                  │
│   format=json                                            │
│   RecallTitle={keyword}                                  │
│   ProductName={productName}                              │
│   RecallDateStart={recallDateStart}                      │
│   RecallDateEnd={recallDateEnd}                           │
│                                                         │
│ Note: No pagination — single request returns all matches │
│ Note: No API key required                                │
└────────────────────────┬────────────────────────────────┘
                         │
                         ▼
┌─────────────────────────────────────────────────────────┐
│ FETCH CPSC API                                          │
│                                                         │
│ GET request → parse JSON response                       │
│ Returns array of CpscRecallRaw objects                  │
│ (13+ nested arrays per recall record)                    │
└────────────────────────┬────────────────────────────────┘
                         │
                         ▼
┌─────────────────────────────────────────────────────────┐
│ MANUFACTURER FILTER (client-side)                       │
│                                                         │
│ CPSC API does NOT support manufacturer search            │
│ Actor filters locally with case-insensitive substring:   │
│   - Manufacturers[].Name                                │
│   - Importers[].Name                                    │
│   - Distributors[].Name                                 │
│ Matches if ANY entity name includes the search term      │
└────────────────────────┬────────────────────────────────┘
                         │
                         ▼
┌─────────────────────────────────────────────────────────┐
│ TRANSFORM: Nested → Flat                                │
│                                                         │
│ For each recall:                                        │
│  Products[]          → products (joined with ";")       │
│  Products[].Type     → productTypes (deduplicated Set)  │
│  Products[].NumberOfUnits → units (joined)              │
│  Hazards[].Name      → hazardDescription (joined)       │
│  Hazards[].HazardType → hazardTypes (deduplicated Set)  │
│  Remedies[].Name     → remedyDescription (joined)       │
│  RemedyOptions[].Option → remedyOptions (array)         │
│  Injuries[].Name     → injuries (filtered non-empty)    │
│  Manufacturers/Retailers/Importers/Distributors          │
│    → joined with ";"                                    │
│  ManufacturerCountries → array of country names          │
│  ProductUPCs[]       → upcs (filtered non-empty)        │
│  Images[].URL        → images (if includeImages=true)   │
└────────────────────────┬────────────────────────────────┘
                         │
                         ▼
              Push to Dataset
              (cap at maxResults)

CPSC API Parameter Mapping

Data Normalization

The CPSC API returns 13+ nested object arrays per recall. This actor flattens them:

• Multi-value string fields (products, manufacturers, retailers, etc.) are joined with "; " separators
• Typed arrays (hazardTypes, productTypes) are deduplicated using Set to remove duplicates
• Images are conditionally included based on the includeImages input flag
• UPCs and injuries are filtered to remove empty strings

How Much Does It Cost?

The CPSC Product Recall Monitor is very lightweight. It makes a single API call to the CPSC SaferProducts.gov endpoint and performs local data transformation.

The Apify Free plan includes $5 of monthly credits, which is enough for hundreds of runs per month. The CPSC API itself is completely free with no rate limits.

Tips

• Combine filters for precision — Use a keyword plus a date range to narrow results (e.g., "choking hazard" + start date "2024-01-01")
• Use manufacturer filtering for brand monitoring — Enter a company name to filter across manufacturers, importers, and distributors
• Schedule regular runs — Set up daily or weekly schedules with your search criteria for automatic recall alerts. Pair with Slack or email webhooks
• Set maxResults to 0 for comprehensive data — Retrieves all matching records for research or database building
• Export to CSV for spreadsheet analysis — The flat JSON output translates cleanly into spreadsheet columns
• Leave all fields empty for latest recalls — Running without any filters returns the most recent recalls, useful for a general safety news feed

Limitations

• US recalls only — This actor queries the US Consumer Product Safety Commission. It does not cover recalls from other countries (Canada, EU, etc.)
• No full-text search — The keyword parameter maps to the CPSC RecallTitle field. It searches titles, not the full description text
• No manufacturer search at API level — Manufacturer filtering is done client-side after fetching all results, which means the initial API call may return more data than needed
• No pagination — The CPSC API returns all matching results in a single response. Very broad queries may return large datasets
• Date format strict — Dates must be in YYYY-MM-DD format exactly
• Image availability — Not all recall records include product images. The images array may be empty even when includeImages is true
• Historical data — The CPSC database goes back decades, but older records may have fewer structured fields (missing UPCs, images, or detailed hazard types)

Responsible Use

This actor accesses the official, publicly available CPSC SaferProducts.gov API. The data is published by the U.S. federal government for public safety purposes and is in the public domain.

• Use recall data for legitimate safety, compliance, and research purposes
• Do not misrepresent recall information or use it to unfairly disparage companies
• If publishing recall data, attribute it to the CPSC and link to the official recall page
• See Apify's guide on web scraping legality for general guidance

FAQ

Do I need a CPSC API key? No. The SaferProducts.gov API is free and open to the public. No API keys or authentication required.

How often is the CPSC recall database updated? The CPSC publishes new recalls as they are announced, typically several times per week. Data returned by this actor is always live from the official API.

Can I monitor recalls from a specific date forward? Yes. Set recallDateStart to your desired start date and leave recallDateEnd empty. Schedule the actor to run periodically for ongoing monitoring.

Does manufacturer filtering work for importers and distributors too? Yes. The manufacturer filter searches across manufacturer names, importer names, and distributor names with case-insensitive substring matching.

Can I get UPC codes for recalled products? Yes. When available in the CPSC database, UPC codes are included in the upcs array. Useful for cross-referencing with inventory systems.

What happens if I leave all filters empty? The actor fetches the most recent recalls from the CPSC database. This is useful for a general safety news feed.

What date format should I use? All dates must be in YYYY-MM-DD format (e.g., "2024-01-01").

Integrations

Connect this actor to your existing tools and workflows:

• Google Sheets — Automatically push new recalls to a shared spreadsheet
• Slack — Get instant notifications when recalls match your criteria
• Zapier — Connect to thousands of apps for custom recall workflows
• Make — Build complex recall monitoring automation
• The Apify API — Programmatic access to results via REST API
• Apify Webhooks — Send recall data to your own endpoint when a run completes

Related Actors