# CPSC Recall Matcher: Check Seller Catalogs (`althorlabs/seller-catalog-recall-match`) Actor

Compare up to 100 seller catalog items with recent U.S. CPSC recalls. Get source-linked possible matches by UPC or model, coverage counts and clear limits. No source credentials needed.

- **URL**: https://apify.com/althorlabs/seller-catalog-recall-match.md
- **Developed by:** [Althor Labs](https://apify.com/althorlabs) (community)
- **Categories:** E-commerce, Business
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$200.00 / 1,000 completed catalog scans

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?

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

## Seller catalog CPSC recall matching

Compare a catalog of up to 100 seller-owned products with recent U.S. Consumer
Product Safety Commission (CPSC) recall notices. The Actor returns source-linked
possible matches and the notice fields used to identify them.

### Input

Provide inline JSON rows or choose a key-value store using the READ-only
resource picker and name one JSON or CSV key. Each row needs a unique
`seller_sku`; `upc`, `brand`, `model`, and `product_name` are optional. Catalog
input is limited to 100 rows and 1 MiB. A rolling recent seven-day publication
window is selected automatically. An explicit window may be supplied with both
date bounds and must span no more than seven days.

The Actor queries the fixed CPSC Recalls API endpoint. It does not fetch URLs
from catalog input or open recall notice URLs. One source response is limited to
2 MiB, 20 seconds and 500 notices. HTTP 403 and 429 end the scan. A server
error may receive one retry after at least 60 seconds. The adapter honors
`Retry-After` up to five minutes, then stops. A successful response is
cached for up to 168 hours for the same date window in an Actor-owned key-value
store. The cache best-effort spaces requests by at least 60 seconds in that
Actor context. Concurrent runs can race, so this is not a cross-run or global
request-spacing guarantee.

### Output

One dataset item contains retrieval time, the queried window, coverage counts,
identifier availability, per-SKU statuses and linked candidate notices. A
possible match requires an exact 12 to 14 digit UPC or an exact model value.
Model and official `Description` identifier matches also require a separate
brand or full product-name context match. A product-name or generic-word
overlap alone never creates a candidate. Description-based evidence includes
its source field and a short excerpt.

#### Example from one cloud run

This excerpt is from an actual cloud run using the prefilled synthetic SKU
`EXAMPLE-001` and live CPSC notices in the 2026-10-14 through 2026-10-21 window.
It returned no candidate; this does not determine product safety.

```json
{
  "queried_window": {
    "LastPublishDateStart": "2026-10-14",
    "LastPublishDateEnd": "2026-10-21"
  },
  "retrieval": {
    "retrieved_at_utc": "2026-10-21T23:08:07.326108Z",
    "earlier_recalls_omitted": true
  },
  "results": [
    {
      "seller_sku": "EXAMPLE-001",
      "status": "no_candidates",
      "matches": []
    }
  ]
}
```

The output explicitly omits recalls published before the selected window.
The scan does not cover historical recalls outside that window, promise a
source update schedule, guarantee matching completeness, determine product
safety, or provide legal advice. A no-match result does not establish that a
product is safe. Confirm candidates against the official notice.

CPSC material is attributed. This product is not affiliated with or endorsed
by CPSC. Notice photos and contact details are excluded.

### Price

Pay-per-event pricing is active at $0.20 per completed `catalog-window-scan`.
One event covers 1-100 seller-owned SKUs in one selected publication window,
including scans with zero matches. There is no Actor-start or dataset-item fee;
standard Apify platform usage is included in the event price.

# Actor input Schema

## `catalog` (type: `array`):

Inline JSON rows. Each row requires seller_sku and may include upc, brand, model, and product_name. Use this or select one key-value-store item below. Up to 100 rows and 1 MiB.

## `inputStore` (type: `string`):

Optional owner-selected store. The Actor reads only catalogKey from this store.

## `catalogKey` (type: `string`):

Exact JSON or CSV item key in the selected key-value store.

## `windowStart` (type: `string`):

Optional inclusive LastPublishDateStart. Leave both dates blank to use the rolling recent seven-day window.

## `windowEnd` (type: `string`):

Optional inclusive LastPublishDateEnd. Leave both dates blank to use the rolling recent seven-day window.

## Actor input object example

```json
{
  "catalog": [
    {
      "seller_sku": "EXAMPLE-001",
      "upc": "000000000000",
      "brand": "Example",
      "model": "MODEL-001",
      "product_name": "Example product"
    }
  ]
}
```

# Actor output Schema

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

One dataset item containing the full 1-100 SKU scan.

# 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 = {
    "catalog": [
        {
            "seller_sku": "EXAMPLE-001",
            "upc": "000000000000",
            "brand": "Example",
            "model": "MODEL-001",
            "product_name": "Example product"
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("althorlabs/seller-catalog-recall-match").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 = { "catalog": [{
            "seller_sku": "EXAMPLE-001",
            "upc": "000000000000",
            "brand": "Example",
            "model": "MODEL-001",
            "product_name": "Example product",
        }] }

# Run the Actor and wait for it to finish
run = client.actor("althorlabs/seller-catalog-recall-match").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 '{
  "catalog": [
    {
      "seller_sku": "EXAMPLE-001",
      "upc": "000000000000",
      "brand": "Example",
      "model": "MODEL-001",
      "product_name": "Example product"
    }
  ]
}' |
apify call althorlabs/seller-catalog-recall-match --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,althorlabs/seller-catalog-recall-match"
        }
    }
}
```

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/LvXz48AYCZEbkQjaJ/builds/2wmZqURLPhwxQsegj/openapi.json