# Product Recall Catalog Monitor (`corbostudio/product-recall-catalog-monitor`) Actor

Catalog-specific product recall screening for CPSC and EU Safety Gate sources.

- **URL**: https://apify.com/corbostudio/product-recall-catalog-monitor.md
- **Developed by:** [Corbo Studio](https://apify.com/corbostudio) (community)
- **Categories:** E-commerce, Automation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.75 / 1,000 catalog product rows

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/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use 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

### What does Product Recall Catalog Monitor do?

Product Recall Catalog Monitor checks a user-provided product catalog against official [CPSC Recalls API](https://www.cpsc.gov/Recalls/CPSC-Recalls-Application-Program-Interface-API-Information) records and official [EU Safety Gate](https://ec.europa.eu/safety-gate-alerts/) alerts. It is not a raw recall feed exporter; it turns official Recall Notices into SKU-level Match Results with Confidence Scores, Match Evidence, official URLs, images when available, and a Markdown review report.

This Actor uses official source systems only. EU Safety Gate records are loaded from European Commission Safety Gate endpoints, not from derived public mirrors.

### Why use Product Recall Catalog Monitor?

E-commerce operators, marketplace sellers, importers, distributors, product safety consultants, and compliance teams often need to know whether their own catalog contains products that may require recall review. Manually searching recall pages SKU by SKU does not scale.

This Actor helps by:

- Loading catalogs from pasted CSV, public CSV URL, pasted JSON, or an Apify Dataset ID.
- Mapping user columns into canonical catalog fields such as SKU, product name, brand, model, GTIN/EAN/UPC, category, supplier, manufacturer, lot, batch, and product URL.
- Validating rows before matching and preserving invalid catalog feedback separately from Match Results.
- Fetching CPSC recalls and EU Safety Gate alerts for a configured inclusive date range.
- Generating indexed candidates by identifier, model, brand, rare product tokens, category, and supplier/manufacturer signals.
- Scoring matches by exact identifiers, model, brand, product name similarity, category, market, supplier/manufacturer, and lot/batch evidence where available.
- Producing Confidence Scores, Confidence Bands, score breakdowns, signal details, Match Evidence, and recommended human-review actions.
- Writing a Markdown report that can be reviewed by operations or compliance teams.

Because this runs on Apify, you can schedule it, call it through the Apify API, use webhooks, and download output datasets as JSON, CSV, Excel, HTML, RSS, or XML from the Apify platform.

### What data can Product Recall Catalog Monitor output?

| Output | Type | Description |
| --- | --- | --- |
| Match Results dataset | Dataset rows | Flat SKU-level possible matches with catalog fields, recall fields, Confidence Score, evidence, official URL, human-review flag, and optional incremental `deltaStatus`. |
| `OUTPUT` | JSON | Run Summary with selected sources, Source Status entries, catalog counts, source record count, match total, Billing Summary, and incremental delta fields when enabled. |
| `REPORT.md` | Markdown | Human-readable summary with immediate review, possible matches, source status, incremental delta sections when enabled, and disclaimer sections. |
| `SOURCE_STATUS.json` | JSON | Per-source success, error, or spending-limit skip status for CPSC and EU Safety Gate. |
| `MATCHING_STATS.json` | JSON | Matching counts by confidence band, source, returned status, and selected matching controls. |
| `INVALID_ROWS.csv` | CSV | Invalid Catalog Rows excluded from matching, such as rows missing product name. |
| `CATALOG_QUALITY.json` | JSON | Catalog Quality Warnings such as missing recommended fields, invalid identifiers, duplicates, or truncation. |
| `RAW_SOURCE_RECORDS.json` | JSON | Optional normalized Recall Notices with raw source fields, written only when `includeRawSourceRecords` is enabled. |

### How to scan a catalog against CPSC and EU Safety Gate notices

1. Choose one catalog input mode: public CSV URL, pasted CSV text, pasted JSON text, or Apify Dataset ID.
2. Map your catalog columns in the `fieldMapping` object. At minimum, map SKU and product name. Brand, model, GTIN/EAN/UPC, and category improve match quality.
3. Set `sources` to `["cpsc"]`, `["eu_safety_gate"]`, or both.
4. Choose `dateMode`. Use `last_days` for the default rolling range, or `custom_range` with `fromDate` and `toDate`.
5. Set `maxSourceRecords` if you need a deterministic per-source cap on normalized Recall Notices.
6. Run the Actor and review the default dataset plus `REPORT.md`.
7. Verify any Match Result against the official source URL before taking business, legal, product safety, or compliance action.

### How much will it cost to scan official recall sources?

This Actor uses pay-per-event billing hooks. In local or non-PPE beta runs, the Actor simulates the same events and writes them to `OUTPUT.billingSummary`; in Apify PPE runs, custom events are charged through `Actor.charge()`.

Beta pricing:

| Event | When it is counted | Price |
| --- | --- | ---: |
| `apify-actor-start` | Actor run start, handled by Apify's synthetic start event | Store configuration |
| `catalog-product-row` | Each processed catalog row, including Invalid Catalog Rows and excluding truncated rows | $0.75 / 1,000 rows |
| `recall-notice-checked` | Each Recall Notice actually fetched and used | $0.20 / 1,000 notices |
| `report-generated` | Full Markdown report generation | $0.50 |

Example estimate: a run that processes 5,000 catalog rows, fetches 700 Recall Notices, and generates one report would cost `$3.75 + $0.14 + $0.50 = $4.39`, plus the configured Apify Actor start event.

If the configured spending limit is reached, the Actor performs a Spending Limit Stop. It writes a clear `OUTPUT`, Source Status entries, any dataset rows already produced, and a minimal `REPORT.md` explaining the stop instead of continuing into more chargeable work.

### Input

See the Actor input tab for the full configuration. The most important fields are:

- `catalogInputMode`: exactly one of `public_csv_url`, `csv_text`, `json_text`, or `apify_dataset`.
- `fieldMapping`: maps user column names into canonical catalog fields.
- `sources`: one or both of `cpsc` and `eu_safety_gate`.
- `dateMode`, `lastDays`, `fromDate`, `toDate`: controls the inclusive source date range.
- `maxCatalogRows`: caps catalog processing and emits a Catalog Quality Warning when truncated.
- `maxSourceRecords`: caps normalized Recall Notices per source after dedupe and deterministic date ordering.
- `matchingMode`: choose `strict`, `balanced`, `broad`, or `debug`. Strict is conservative, balanced is the default, broad supports lower-confidence review when combined with lower thresholds, and debug includes discarded candidates for troubleshooting.
- `minConfidence`: default `65`, which includes medium, high, and very_high Confidence Bands.
- `includeLowConfidenceMatches`: includes low-confidence Match Results when enabled.
- `includeRawSourceRecords`: writes `RAW_SOURCE_RECORDS.json` with normalized Recall Notices and their source `raw` fields. Raw source records are not added to the Match Results dataset.
- `incrementalMode`: uses a named Key-Value Store to classify current Match Results as `new` or `previously_seen` across scheduled runs.
- `stateStoreName`: required when `incrementalMode` is enabled; choose a stable name per scheduled monitoring setup.
- `reportFormat`: `markdown` in the beta Actor.
- `debugMode`: writes diagnostic artifacts such as `MATCHING_STATS.json`. To include discarded candidates in the dataset, set `matchingMode` to `debug`.

### Output

The default dataset is designed for review in Apify Output. Each Match Result is flattened so the most useful fields are visible as table columns.

When `incrementalMode` is enabled, each dataset row includes `deltaStatus`. `OUTPUT` and `REPORT.md` also include `newMatches`, `previouslySeenMatches`, `lastSuccessfulRunAt`, `catalogFingerprintChanged`, and a `deltaSummary`. Incremental mode is source-notice centric: a Recall Notice is considered previously seen by `source` and `sourceRecordId`, even if a changed catalog makes it match a new or changed Catalog Item.

Example dataset row with `incrementalMode` enabled:

```json
{
  "confidenceScore": 95,
  "confidenceBand": "very_high",
  "matchStatus": "possible_match",
  "deltaStatus": "new",
  "sku": "A-1",
  "productName": "Acme Wooden Train",
  "model": "WT-200",
  "gtin": "012345678905",
  "source": "cpsc",
  "jurisdiction": "US",
  "sourceRecordId": "26-123",
  "recallTitle": "Acme Recalls Wooden Toy Trains Due to Choking Hazard",
  "officialUrl": "https://www.cpsc.gov/Recalls/2026/acme-recalls-wooden-toy-trains",
  "imageUrls": [],
  "identifierMatch": true,
  "matchedFields": ["identifier", "model", "category"],
  "scoreBreakdown": [
    {
      "signal": "identifier_exact",
      "points": 70,
      "details": "Catalog identifier matches recall identifier."
    }
  ],
  "signalDetails": {
    "candidateReasons": ["identifier", "model", "category"],
    "scoringVersion": "explainable-v1"
  },
  "requiresHumanReview": true
}
````

### Demo catalogs and expected outputs

The release demo matrix is documented in
[`examples/release-demo-matrix.md`](examples/release-demo-matrix.md), with structured expected
outcomes in [`examples/release-demo-matrix.json`](examples/release-demo-matrix.json).

The matrix covers exact identifier matching, name-based review matching, a no-match control,
Incremental Monitoring State / Delta Summary behavior, and Spending Limit Stop behavior. Each
demo defines the expected Match Result shape, Confidence Band, Human Review Flag, Run Summary,
Billing Summary, source fixtures, and verification command. The demos remain limited to CPSC and
EU Safety Gate and do not imply openFDA, USDA FSIS, food, pharma, medical-device, or global recall
coverage.

The original beta catalog demos are also available in `examples/`:

| Demo | Catalog | Input file | Expected-output examples |
| --- | --- | --- | --- |
| Toy catalog | `examples/toy_catalog_demo.csv` | `examples/demo_toy_catalog_input.json` | `examples/expected-output/toy_catalog/` |
| Mixed ecommerce catalog | `examples/mixed_ecommerce_catalog_demo.csv` | `examples/demo_mixed_ecommerce_input.json` | `examples/expected-output/mixed_ecommerce/` |

Run a catalog demo locally without editing source code. For deterministic fixture-backed release
demo runs, set the fixture environment variables shown in
[`examples/release-demo-matrix.md`](examples/release-demo-matrix.md) first.

```bash
apify run --purge --entrypoint src/main.py --input-file examples/demo_toy_catalog_input.json
apify run --purge --entrypoint src/main.py --input-file examples/demo_mixed_ecommerce_input.json
apify run --purge --entrypoint src/main.py --input-file examples/demo_name_review_input.json
apify run --purge --entrypoint src/main.py --input-file examples/demo_no_match_control_input.json
```

Verify the complete release matrix:

```bash
uv run --locked pytest tests/test_release_demo_matrix.py
```

In Apify Console, paste the corresponding input JSON or use the catalog CSV values from the demo catalog files. The expected-output examples and release matrix show representative `OUTPUT`, `MATCHING_STATS.json`, dataset item, Billing Summary, Delta Summary, and `REPORT.md` shape for beta review.

### Store listing and onboarding package

The Apify Store launch package is split into three repository docs:

- [`docs/apify-store-listing.md`](docs/apify-store-listing.md): Store title, short description, long description, keywords, categories, use cases, pricing, limitations, and support copy.
- [`docs/apify-store-onboarding.md`](docs/apify-store-onboarding.md): first-run onboarding flow aligned with the current input schema, output schema, dataset schema, and Key-Value Store artifacts.
- [`docs/apify-store-assets.md`](docs/apify-store-assets.md): sample-output and screenshot source list traced to verified release evidence under `docs/release-evidence/2026-07-06-beta/`.

### Beta learning and launch gates

The internal beta learning plan and publish/hold launch gate criteria are documented in
[`docs/beta-learning-plan.md`](docs/beta-learning-plan.md). Use that plan to decide whether the
current CPSC and EU Safety Gate scope has enough evidence to publish or whether the release
should hold before any v1.1 source expansion.

The beta measurement cadence and feedback intake path are documented in
[`docs/beta-measurement-and-feedback.md`](docs/beta-measurement-and-feedback.md). Use the GitHub
beta feedback issue template for false positives, false negatives, requested sources, pricing
confusion, and source reliability complaints.

### Tips and advanced options

Confidence Bands are `very_high`, `high`, `medium`, `low`, and `discard`. Exact UPC/EAN/GTIN matches score very high by default unless strong contradictory evidence is present. Name-only matches are conservative, and generic name-only matches without brand, model, or identifier evidence cannot exceed low confidence. Invalid Catalog Rows and Catalog Quality Warnings are not mixed into the Match Results dataset; they are written to key-value store artifacts so the dataset stays reserved for possible recall matches.

### FAQ, disclaimers, and support

#### Does this Actor confirm that a product is recalled?

No. A Match Result is an automated possible match that requires human review. Always verify the official CPSC or EU Safety Gate notice before taking action.

#### Does EU Safety Gate use a fallback mirror?

No. This Actor intentionally uses official EU Safety Gate endpoints only. If the official source fails or changes shape, the run records an EU Safety Gate Source Status error and continues with other selected sources.

#### Is this legal, medical, food safety, regulatory, or compliance advice?

No. This Actor is an automated monitoring aid. False positives and false negatives are possible. It does not provide legal, medical, food safety, regulatory, or compliance advice.

#### Where should issues or feature requests go?

Use the repository issue tracker for feedback and follow-up work. During beta, use the beta
feedback issue template so reports include the run ID, source, source record ID, Match Result ID
when available, observed behavior, expected behavior, and supporting Actor output fields.

### Development

Required tools:

- Python 3.14
- uv
- just
- apify-cli

Common commands:

```bash
just bootstrap
just check
just actor-validate
just actor-run
```

# Actor input Schema

## `catalogInputMode` (type: `string`):

Select exactly one way to provide the product catalog.

## `catalogUrl` (type: `string`):

Publicly accessible CSV URL used when Catalog input mode is Public CSV URL.

## `catalogCsvText` (type: `string`):

CSV catalog text used when Catalog input mode is Pasted CSV text.

## `catalogJsonText` (type: `string`):

JSON list of catalog objects used when Catalog input mode is Pasted JSON text.

## `apifyDatasetId` (type: `string`):

Dataset ID used when Catalog input mode is Apify Dataset ID.

## `fieldMapping` (type: `object`):

Map catalog columns into canonical catalog item fields.

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

Official recall and safety alert sources to scan in this run.

## `dateMode` (type: `string`):

Choose whether to scan the last N days or an explicit source date range.

## `lastDays` (type: `integer`):

Number of days before the run date to include when Date mode is Last days.

## `fromDate` (type: `string`):

Inclusive source start date used when Date mode is Custom range.

## `toDate` (type: `string`):

Inclusive source end date used when Date mode is Custom range.

## `matchingMode` (type: `string`):

Controls candidate thresholds: strict is conservative, balanced is the default, broad can return more low-confidence matches when requested, and debug includes discarded candidates for troubleshooting.

## `minConfidence` (type: `integer`):

Minimum Confidence Score included in the dataset unless low-confidence matches are explicitly included.

## `includeLowConfidenceMatches` (type: `boolean`):

Include low-confidence Match Results in the dataset and report.

## `includeRawSourceRecords` (type: `boolean`):

Write normalized Recall Notices with their raw source fields to RAW\_SOURCE\_RECORDS.json for debugging and audit review. Raw records are not added to the Match Results dataset.

## `incrementalMode` (type: `boolean`):

Use a named Key-Value Store to classify current Match Results as new or previously seen across scheduled runs.

## `stateStoreName` (type: `string`):

Named Key-Value Store used for Incremental Monitoring State when Incremental mode is enabled.

## `maxCatalogRows` (type: `integer`):

Maximum number of catalog rows to validate in this run. Extra rows are skipped with a catalog-quality warning.

## `maxSourceRecords` (type: `integer`):

Maximum normalized Recall Notices to use per source after dedupe and deterministic date ordering.

## `reportFormat` (type: `string`):

Human-readable report format to generate. Markdown is the beta-supported format.

## `debugMode` (type: `boolean`):

Include additional diagnostic artifacts such as matching statistics. To return discarded Match Results in the dataset, set Matching mode to Debug.

## Actor input object example

```json
{
  "catalogInputMode": "csv_text",
  "catalogUrl": "",
  "catalogCsvText": "sku,title,brand,model,barcode,category\nA-1,Acme Wooden Train,Acme,WT-200,012345678905,Toys\nA-2,,Acme,,,",
  "catalogJsonText": "",
  "apifyDatasetId": "",
  "fieldMapping": {
    "sku": "sku",
    "productName": "title",
    "brand": "brand",
    "model": "model",
    "gtin": "barcode",
    "ean": "",
    "upc": "",
    "category": "category",
    "description": "description",
    "market": "market",
    "supplier": "supplier",
    "manufacturer": "manufacturer",
    "lotNumber": "lot",
    "batchNumber": "batch",
    "batchLot": "",
    "productUrl": "productUrl"
  },
  "sources": [
    "cpsc",
    "eu_safety_gate"
  ],
  "dateMode": "last_days",
  "lastDays": 90,
  "fromDate": "",
  "toDate": "",
  "matchingMode": "balanced",
  "minConfidence": 65,
  "includeLowConfidenceMatches": false,
  "includeRawSourceRecords": false,
  "incrementalMode": false,
  "stateStoreName": "",
  "maxCatalogRows": 10000,
  "maxSourceRecords": 5000,
  "reportFormat": "markdown",
  "debugMode": false
}
```

# Actor output Schema

## `summary` (type: `string`):

No description

## `report` (type: `string`):

No description

## `sourceStatus` (type: `string`):

No description

## `matchingStats` (type: `string`):

No description

## `rawSourceRecords` (type: `string`):

No description

## `invalidRows` (type: `string`):

No description

## `catalogQuality` (type: `string`):

No description

## `matches` (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 = {
    "catalogCsvText": `sku,title,brand,model,barcode,category
A-1,Acme Wooden Train,Acme,WT-200,012345678905,Toys
A-2,,Acme,,,`,
    "sources": [
        "cpsc",
        "eu_safety_gate"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("corbostudio/product-recall-catalog-monitor").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 = {
    "catalogCsvText": """sku,title,brand,model,barcode,category
A-1,Acme Wooden Train,Acme,WT-200,012345678905,Toys
A-2,,Acme,,,""",
    "sources": [
        "cpsc",
        "eu_safety_gate",
    ],
}

# Run the Actor and wait for it to finish
run = client.actor("corbostudio/product-recall-catalog-monitor").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 '{
  "catalogCsvText": "sku,title,brand,model,barcode,category\\nA-1,Acme Wooden Train,Acme,WT-200,012345678905,Toys\\nA-2,,Acme,,,",
  "sources": [
    "cpsc",
    "eu_safety_gate"
  ]
}' |
apify call corbostudio/product-recall-catalog-monitor --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=corbostudio/product-recall-catalog-monitor",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Product Recall Catalog Monitor",
        "description": "Catalog-specific product recall screening for CPSC and EU Safety Gate sources.",
        "version": "0.0",
        "x-build-id": "qA7CpNqUO05xepi18"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/corbostudio~product-recall-catalog-monitor/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-corbostudio-product-recall-catalog-monitor",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/corbostudio~product-recall-catalog-monitor/runs": {
            "post": {
                "operationId": "runs-sync-corbostudio-product-recall-catalog-monitor",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/corbostudio~product-recall-catalog-monitor/run-sync": {
            "post": {
                "operationId": "run-sync-corbostudio-product-recall-catalog-monitor",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "catalogInputMode"
                ],
                "properties": {
                    "catalogInputMode": {
                        "title": "Catalog input mode",
                        "enum": [
                            "public_csv_url",
                            "csv_text",
                            "json_text",
                            "apify_dataset"
                        ],
                        "type": "string",
                        "description": "Select exactly one way to provide the product catalog.",
                        "default": "csv_text"
                    },
                    "catalogUrl": {
                        "title": "Public CSV URL",
                        "type": "string",
                        "description": "Publicly accessible CSV URL used when Catalog input mode is Public CSV URL.",
                        "default": ""
                    },
                    "catalogCsvText": {
                        "title": "Catalog CSV text",
                        "type": "string",
                        "description": "CSV catalog text used when Catalog input mode is Pasted CSV text.",
                        "default": ""
                    },
                    "catalogJsonText": {
                        "title": "Catalog JSON text",
                        "type": "string",
                        "description": "JSON list of catalog objects used when Catalog input mode is Pasted JSON text.",
                        "default": ""
                    },
                    "apifyDatasetId": {
                        "title": "Apify Dataset ID",
                        "type": "string",
                        "description": "Dataset ID used when Catalog input mode is Apify Dataset ID.",
                        "default": ""
                    },
                    "fieldMapping": {
                        "title": "Field mapping",
                        "type": "object",
                        "description": "Map catalog columns into canonical catalog item fields.",
                        "properties": {
                            "sku": {
                                "type": "string",
                                "title": "SKU column",
                                "description": "Column containing the catalog SKU."
                            },
                            "productName": {
                                "type": "string",
                                "title": "Product name column",
                                "description": "Column containing the required product name."
                            },
                            "brand": {
                                "type": "string",
                                "title": "Brand column",
                                "description": "Column containing the product brand."
                            },
                            "model": {
                                "type": "string",
                                "title": "Model column",
                                "description": "Column containing the model number or model name."
                            },
                            "gtin": {
                                "type": "string",
                                "title": "GTIN column",
                                "description": "Column containing GTIN values."
                            },
                            "ean": {
                                "type": "string",
                                "title": "EAN column",
                                "description": "Column containing EAN values."
                            },
                            "upc": {
                                "type": "string",
                                "title": "UPC column",
                                "description": "Column containing UPC values."
                            },
                            "category": {
                                "type": "string",
                                "title": "Category column",
                                "description": "Column containing the product category."
                            },
                            "description": {
                                "type": "string",
                                "title": "Description column",
                                "description": "Column containing product description text."
                            },
                            "market": {
                                "type": "string",
                                "title": "Market column",
                                "description": "Column containing the market or country market."
                            },
                            "supplier": {
                                "type": "string",
                                "title": "Supplier column",
                                "description": "Column containing the supplier name."
                            },
                            "manufacturer": {
                                "type": "string",
                                "title": "Manufacturer column",
                                "description": "Column containing the manufacturer name."
                            },
                            "lotNumber": {
                                "type": "string",
                                "title": "Lot column",
                                "description": "Column containing lot numbers."
                            },
                            "batchNumber": {
                                "type": "string",
                                "title": "Batch column",
                                "description": "Column containing batch numbers."
                            },
                            "batchLot": {
                                "type": "string",
                                "title": "Batch/lot column",
                                "description": "Column containing combined batch or lot values."
                            },
                            "productUrl": {
                                "type": "string",
                                "title": "Product URL column",
                                "description": "Column containing product page URLs."
                            }
                        },
                        "default": {
                            "sku": "sku",
                            "productName": "title",
                            "brand": "brand",
                            "model": "model",
                            "gtin": "barcode",
                            "ean": "",
                            "upc": "",
                            "category": "category",
                            "description": "description",
                            "market": "market",
                            "supplier": "supplier",
                            "manufacturer": "manufacturer",
                            "lotNumber": "lot",
                            "batchNumber": "batch",
                            "batchLot": "",
                            "productUrl": "productUrl"
                        }
                    },
                    "sources": {
                        "title": "Sources",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Official recall and safety alert sources to scan in this run.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "cpsc",
                                "eu_safety_gate"
                            ],
                            "enumTitles": [
                                "CPSC",
                                "EU Safety Gate"
                            ]
                        },
                        "default": [
                            "cpsc",
                            "eu_safety_gate"
                        ]
                    },
                    "dateMode": {
                        "title": "Date mode",
                        "enum": [
                            "last_days",
                            "custom_range"
                        ],
                        "type": "string",
                        "description": "Choose whether to scan the last N days or an explicit source date range.",
                        "default": "last_days"
                    },
                    "lastDays": {
                        "title": "Last days",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Number of days before the run date to include when Date mode is Last days.",
                        "default": 90
                    },
                    "fromDate": {
                        "title": "From date",
                        "type": "string",
                        "description": "Inclusive source start date used when Date mode is Custom range.",
                        "default": ""
                    },
                    "toDate": {
                        "title": "To date",
                        "type": "string",
                        "description": "Inclusive source end date used when Date mode is Custom range.",
                        "default": ""
                    },
                    "matchingMode": {
                        "title": "Matching mode",
                        "enum": [
                            "strict",
                            "balanced",
                            "broad",
                            "debug"
                        ],
                        "type": "string",
                        "description": "Controls candidate thresholds: strict is conservative, balanced is the default, broad can return more low-confidence matches when requested, and debug includes discarded candidates for troubleshooting.",
                        "default": "balanced"
                    },
                    "minConfidence": {
                        "title": "Minimum confidence",
                        "minimum": 0,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Minimum Confidence Score included in the dataset unless low-confidence matches are explicitly included.",
                        "default": 65
                    },
                    "includeLowConfidenceMatches": {
                        "title": "Include low-confidence matches",
                        "type": "boolean",
                        "description": "Include low-confidence Match Results in the dataset and report.",
                        "default": false
                    },
                    "includeRawSourceRecords": {
                        "title": "Include raw source records",
                        "type": "boolean",
                        "description": "Write normalized Recall Notices with their raw source fields to RAW_SOURCE_RECORDS.json for debugging and audit review. Raw records are not added to the Match Results dataset.",
                        "default": false
                    },
                    "incrementalMode": {
                        "title": "Incremental mode",
                        "type": "boolean",
                        "description": "Use a named Key-Value Store to classify current Match Results as new or previously seen across scheduled runs.",
                        "default": false
                    },
                    "stateStoreName": {
                        "title": "State store name",
                        "type": "string",
                        "description": "Named Key-Value Store used for Incremental Monitoring State when Incremental mode is enabled.",
                        "default": ""
                    },
                    "maxCatalogRows": {
                        "title": "Max catalog rows",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Maximum number of catalog rows to validate in this run. Extra rows are skipped with a catalog-quality warning.",
                        "default": 10000
                    },
                    "maxSourceRecords": {
                        "title": "Max source records",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Maximum normalized Recall Notices to use per source after dedupe and deterministic date ordering.",
                        "default": 5000
                    },
                    "reportFormat": {
                        "title": "Report format",
                        "enum": [
                            "markdown"
                        ],
                        "type": "string",
                        "description": "Human-readable report format to generate. Markdown is the beta-supported format.",
                        "default": "markdown"
                    },
                    "debugMode": {
                        "title": "Debug mode",
                        "type": "boolean",
                        "description": "Include additional diagnostic artifacts such as matching statistics. To return discarded Match Results in the dataset, set Matching mode to Debug.",
                        "default": false
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
