# Recall Exposure Matcher – Check Your Catalog Against CPSC & FDA (`parviz_a/recall-exposure-matcher-check-your-catalog-against-cpsc-fda`) Actor

Automate recall exposure monitoring for your product catalog. Cross-references your SKUs, UPCs, and brand names against CPSC and openFDA (food, drug, device) databases using exact and fuzzy matching. Outputs row-by-row safety compliance reports to flag affected inventory instantly.

- **URL**: https://apify.com/parviz\_a/recall-exposure-matcher-check-your-catalog-against-cpsc-fda.md
- **Developed by:** [Parviz Abbasov](https://apify.com/parviz_a) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.20 / 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.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#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

## Recall Exposure Matcher – Check Your Catalog Against CPSC & FDA

Every "recall monitor" on the market hands you a firehose of every recall published this week and expects you to figure out if any of it affects you. **This one flips that around: give it your own product catalog, and it tells you — product by product — whether you're exposed.**

Built for e-commerce sellers, marketplace merchants, distributors, and retail compliance teams who need a direct answer to *"do I need to pull anything from my shelves or listings?"*, not another feed to manually cross-reference.

### How it works

1. You give the Actor your product catalog: SKU, name, brand, and (ideally) UPC.
2. The Actor pulls recent recalls from the official CPSC (SaferProducts.gov) and openFDA (food/drug/device) databases.
3. Each of your products is checked against every fetched recall:
   - **High confidence** — your product's UPC exactly matches a UPC on a CPSC recall.
   - **Medium confidence** — your product's brand matches a recalling company **and** a real word from your product name appears in that recall's product description. Both conditions have to hold — brand overlap alone, or name overlap alone, isn't enough. This keeps false alarms down.
   - **No match** — nothing found in either source within your lookback window.
4. You get one output row **per your product**, not per recall — a direct answer, with links back to the official source for any hit.

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `products` | array | 3 example products | `sku`, `name`, `brand`, `upc` (optional but recommended). |
| `sources` | array | all four | Which of CPSC / FDA-Food / FDA-Drug / FDA-Device to check. |
| `lookbackDays` | integer | `730` | How far back to search. A recall from 3 years ago is still relevant if the product is still in your inventory — raise this for a full audit. |
| `maxRecallsPerSource` | integer | `2000` | Safety cap on records fetched per source. |

### Output

```json
{
  "sku": "DEMO-001",
  "productName": "Portable Space Heater 1500W",
  "brand": "Example Home Co",
  "upc": "012345678905",
  "matchFound": true,
  "confidence": "high",
  "matchedRecalls": [
    {
      "source": "cpsc",
      "recallNumber": "24-001",
      "title": "Recall of XYZ Space Heaters",
      "date": "2024-01-10",
      "reason": "Fire hazard",
      "url": "https://www.saferproducts.gov/..."
    }
  ],
  "checkedAt": "2026-09-11T10:00:00.000Z"
}
```

Every product you submit gets a row, including the ones with `matchFound: false` — a documented "checked, clear" record is itself useful for a compliance audit trail.

### Why UPC matters

Providing a UPC lets the Actor do an **exact** match against CPSC's recall data — the strongest possible signal. Without a UPC, matching falls back to brand + keyword text matching, which is clearly labeled as `medium` confidence and should be manually verified before you act on it. FDA food/drug/device recalls generally don't publish UPCs at all, so FDA matches are always text-based regardless of whether you supply a UPC.

### Pricing

Pay-per-event:

- A small flat fee per run.
- **Per product where a recall match is found** — the outcome you're actually looking for.
- **Per product checked and confirmed clear** — priced lower, since it's still real work done, just a different (lower-urgency) outcome.

### Limitations

- Covers CPSC (general consumer products) and openFDA (food, drug, device). It does not cover NHTSA (vehicle) recalls in this version.
- `medium` confidence matches are text-based and can occasionally be wrong — verify against the source link before acting on anything without a UPC-based `high` confidence match.
- CPSC's raw API response has some inconsistency in exactly how UPCs are nested per record; this Actor handles the common variants defensively, but if you notice a UPC that should have matched and didn't, please report it.
- FDA recall records are matched on brand/description text only — lot numbers and NDC codes are not checked in this version.

### API usage example

**Python**

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_API_TOKEN")
run = client.actor("YOUR_USERNAME/recall-exposure-matcher").call(run_input={
    "products": [
        {"sku": "SKU-100", "name": "Kids Bike Helmet", "brand": "Acme Sports", "upc": "012345678905"},
    ],
})
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    status = "MATCH FOUND" if item["matchFound"] else "clear"
    print(item["sku"], "-", status)
```

# Actor input Schema

## `products` (type: `array`):

Each entry: sku (your internal ID, any string), name (product title), brand (manufacturer or brand name), upc (optional, digits only – greatly improves match accuracy when available).

## `sources` (type: `array`):

Which agencies/categories to check your catalog against.

## `lookbackDays` (type: `integer`):

Recalls older than this are not checked. A recalled product already in your inventory is a risk regardless of age, but a longer window means a bigger, slower, more expensive run. 730 days (2 years) is a reasonable default; increase for a full compliance audit.

## `maxRecallsPerSource` (type: `integer`):

Upper bound on how many recall records are pulled from each source before matching. Protects against extremely large date windows.

## Actor input object example

```json
{
  "products": [
    {
      "sku": "DEMO-001",
      "name": "Portable Space Heater 1500W",
      "brand": "Example Home Co",
      "upc": ""
    },
    {
      "sku": "DEMO-002",
      "name": "Infant Sleep Positioner Wedge",
      "brand": "Example Baby Co",
      "upc": ""
    },
    {
      "sku": "DEMO-003",
      "name": "Stainless Steel Water Bottle 32oz",
      "brand": "Example Outdoor Co",
      "upc": ""
    }
  ],
  "sources": [
    "cpsc",
    "fda-food",
    "fda-drug",
    "fda-device"
  ],
  "lookbackDays": 730,
  "maxRecallsPerSource": 2000
}
```

# Actor output Schema

## `results` (type: `string`):

No description

# 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("parviz_a/recall-exposure-matcher-check-your-catalog-against-cpsc-fda").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("parviz_a/recall-exposure-matcher-check-your-catalog-against-cpsc-fda").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 '{}' |
apify call parviz_a/recall-exposure-matcher-check-your-catalog-against-cpsc-fda --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,parviz_a/recall-exposure-matcher-check-your-catalog-against-cpsc-fda"
        }
    }
}
```

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/K16zkJvEOItbjK1nC/builds/muzQH4PLSafmAtwrJ/openapi.json