# UK and EU Product Recalls and Safety Alerts Feed (`yappman/uk-eu-recalls-feed`) Actor

Product recalls API for the UK and EU. Search or monitor OPSS product recalls, FSA food and allergy alerts, MHRA drug and medical device alerts and EU Safety Gate (RAPEX) notices in one schema, by brand or barcode (GTIN/EAN). Alert mode for scheduled watch lists. Official sources, pay per result.

- **URL**: https://apify.com/yappman/uk-eu-recalls-feed.md
- **Developed by:** [Russell Yapp](https://apify.com/yappman) (community)
- **Categories:** E-commerce, Business
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 recall records

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

## UK and EU Product Recalls and Safety Alerts Feed

Search and monitor product recalls and safety alerts from official sources in one fixed row schema: UK OPSS consumer product recalls, UK FSA food alerts, UK MHRA drug and device alerts and EU Safety Gate (the former RAPEX) by default, plus Canada's recalls and safety alerts if you add `canada` to `sources` (five sources when enabled). No login, no API keys, no proxies.

**A default run costs up to $0.065: $0.005 for the run and $0.003 for each of the 20 newest recalls. The $0.005 run fee applies to every run that read at least one source, including a run that finds nothing new (an alert with no new items still costs $0.005). Runs refused before anything is read (invalid input) and runs where no source could be read are not charged.**

### Modes

| Mode | You give | Question it answers |
| --- | --- | --- |
| `search` | Filters and `sinceDays` | Which toy recalls were published in the last 30 days? |
| `new-since` | `since` date and filters | What is new since Monday for my brands? |
| `alert` | `alertId` (lower-case letters, digits, `-`) and filters | Which recalls matching my barcodes are new since my last run? (Schedule it.) |

Filters: `keywords` (all must match), `brands`, `categories`, `riskLevels`, `barcodes` (GTIN/EAN), `countriesOfOrigin`. Sources: `opss`, `fsa`, `mhra`, `safetygate` (these four by default) and `canada` (opt-in: add it to `sources`). `kinds` filters by row kind, for example `food recall`, `vehicle recall`, `medical device recall`, `allergy alert`.

### Input examples

Each example is valid against the input schema.

Search the last 30 days for toy recalls, UK and EU:

```json
{ "mode": "search", "sources": ["opss", "safetygate"], "categories": ["toys"], "sinceDays": 30, "maxItems": 50 }
```

Everything new since a date, for two brands:

```json
{ "mode": "new-since", "since": "2026-11-01", "brands": ["Primark", "Jojo Maman Bébé"], "maxItems": 200 }
```

Check whether a product barcode is in any alert in the last year:

```json
{ "mode": "search", "barcodes": ["5054298241091"], "sinceDays": 365, "maxItems": 10 }
```

New alerts only, for a watch list (run on a schedule):

```json
{ "mode": "alert", "alertId": "my-brands", "brands": ["Primark", "Argos"], "sinceDays": 7, "maxItems": 100 }
```

### What it costs

Pricing is pay per event: $0.005 per run that read data and $0.003 per row returned.

| Run | Rows | Cost |
| --- | --- | --- |
| Default search (20 rows) | 20 | $0.005 + 20 x $0.003 = $0.065 |
| Barcode check, one match | 1 | $0.005 + $0.003 = $0.008 |
| Daily alert, nothing new | 0 | $0.005 |
| Daily alert, 4 new items | 4 | $0.005 + 4 x $0.003 = $0.017 |
| 200-row brand sweep | 200 | $0.005 + 200 x $0.003 = $0.605 |

### New alerts: scheduling a Task

1. Open the Actor and save your input (mode `alert`, your `alertId`, your filters) as a Task.
2. Add a schedule to the Task, for example every weekday morning. OPSS, FSA and MHRA publish on working days; Safety Gate publishes weekly on Fridays.
3. Add an integration to the Task (Slack, e-mail, webhook, Google Sheets) on "run succeeded" so the new rows are sent on.
4. Add a failure alert on the Task for Failed, Timed out and Aborted.

The Actor remembers what it has sent in a key-value store named `recalls-alert-<alertId>` in your account, so each run returns only rows it has not sent before. The first run returns the window you set. A run with nothing new returns no rows and still costs the $0.005 run fee, because it still read the sources.

Restart safety: rows are written to the alert's memory after each batch of up to 50 rows is stored and charged, so a spending-limit stop does not make the next run re-send rows you were already charged for. If a run is killed in the instant between a batch being stored and its memory write, that one batch can be sent (and charged) again on the next run; this is at-least-once delivery, not exactly-once.

### What it does not do

- It does not cover the US, Australia, New Zealand or other regions. Canada is available only when you add it to `sources`. It does not cover UK vehicle recalls.
- It does not copy images, attachments, PDFs or seller and reporter contact details.
- It does not give safety, legal or medical advice, and it does not tell you whether a product you own is affected beyond matching the text and barcode a publisher printed.
- Matching is by the text the publishers publish. Barcodes and brands are often missing, and a missing barcode never matches a barcode filter.
- It is not real time: it returns what the sources have published when the run reads them. Safety Gate alerts appear when its weekly report is published.
- It does not guarantee completeness: if a request cap stops a long-window read, `RUN_SUMMARY` says so.
- It does not work around a refusal. If a source refuses, that source stops for the run.

### Canada (opt-in)

Add `"canada"` to `sources` to read Canada's recalls and safety alerts (Health Canada, Canadian Food Inspection Agency, Transport Canada: food, vehicles, consumer products, medical devices, drugs and health products). Licence: Open Government Licence - Canada; every row carries "Contains information licensed under the Open Government Licence – Canada". Notes: the file has no first-published date, so `publishedAt` and `updatedAt` are both its "last updated" date and in `search` and `new-since` an edited recall can reappear as new, while in `alert` mode each Canadian recall (`canada:<NID>`) is sent once and an edit is not sent again; `status` says `current` or `archived`; `riskLevel` is the Canadian recall class where given. Example, Canadian food recalls this month:

```json
{ "mode": "search", "sources": ["canada"], "kinds": ["food recall"], "sinceDays": 30, "maxItems": 50 }
```

### Brand and barcode watch lists

Watch lists can hold up to 2,000 barcodes (GTIN/EAN/UPC in any of their 8 to 14 digit forms: 12, 13 and 14 digit versions of one code match each other, and matching is exact, never a prefix) and up to 200 brands, keywords, kinds, categories and risk levels. Every row returned by a filtered run has `matchedOn`: the entries that matched it, for example `["brand:Primark"]` or `["barcode:5054298241091"]`. In `alert` mode `RUN_SUMMARY.newItems` is the number of new rows sent, and a run with nothing new ends with the message "No new alerts for this alertId since the last run".

Matching is substring matching on the publisher's text (brands) and exact matching on barcodes. Short or common brand words can match unrelated rows; add `categories` or `riskLevels` to narrow them, and list aliases yourself ("M\&S" and "Marks & Spencer"). A recall with no published barcode never matches a barcode watch, so a quiet barcode alert is not proof that nothing is recalled.

### Feedback

If this Actor was useful, or if something did not work as described, an honest review on this Actor's Store page is welcome and helps other people decide. For problems or questions, please use the Issues tab.

### Example row

| publishedAt | source | kind | title | brand | riskLevel | barcode |
| --- | --- | --- | --- | --- | --- | --- |
| 2026-11-10T00:00:00Z | safetygate | safety gate alert | Children's jacket - Jojo Maman Bébé | Jojo Maman Bébé | serious risk | 5054298241091 |

Each row has: `id`, `source`, `sourceId`, `kind`, `title`, `publishedAt`, `updatedAt`, `url` (the official page), `category`, `productName`, `brand`, `company`, `model`, `barcode`, `batch`, `description`, `hazardType`, `hazard`, `riskLevel`, `action`, `countryOfOrigin`, `notifyingCountry`, `recallUrl`, `licence`, `licenceUrl`, `attribution`. A field a source does not publish is `null`: OPSS carries brand, model and risk level; FSA carries product names, allergens and the reporting business; MHRA carries title, class and reference; Safety Gate carries barcode, batch, origin and hazard type.

### Data, licences and attribution

- UK OPSS, FSA and MHRA data: Open Government Licence v3.0. Contains public sector information published by the Office for Product Safety and Standards, the Food Standards Agency and the Medicines and Healthcare products Regulatory Agency, licensed under the Open Government Licence v3.0.
- EU Safety Gate: CC BY 4.0. Source: European Commission, Safety Gate. Text is normalised into fixed fields; images are not copied.
- Every row carries its licence and attribution. If you republish rows, keep them.

This Actor is not an official service and is not endorsed by any of these bodies. It is not safety, legal or medical advice: the `url` on each row is the authoritative record.

### Privacy

Rows hold product, brand and business names and regulator text. E-mail addresses, phone numbers, images and attachments are removed. Business names can include sole-trader trading names exactly as the regulator published them; to have a record changed, ask the publisher via the `url`.

### Politeness and failure behaviour

One request at a time, at least one second apart, honest User-Agent, `robots.txt` read once per host and obeyed, at most 250 requests a source and 800 a run. If a source answers 401, 403, 429 or 451, or its `robots.txt` disallows the path, the Actor stops reading that source at once: no retry, no proxy, no workaround. The other sources continue and `RUN_SUMMARY` says which source stopped and why. If every source stopped, the run fails and nothing is charged.

### Limits

- Dates: date-only sources (FSA, Safety Gate) have midnight UTC times. A row's time is the publisher's date, not when we read it.
- Safety Gate is published in weekly reports (Fridays); an alert appears when its report does.
- MHRA field safety notice rows are weekly list pages, not one row per device.
- `maxItems` up to 5,000; `sinceDays` up to 400.
- Alert memory is kept in a named key-value store in your account, `recalls-alert-<alertId>`, so it persists between scheduled runs. Delete that store to reset the alert. The newest 5,000 sent ids are kept.
- Filtered searches and alerts read the whole window before filtering (up to 250 requests per source and 800 per run, one a second). If a cap stops a read, `RUN_SUMMARY` marks that source `truncated` and says so in `warnings`; older matches may then be missing, so narrow the window or the filters.

### Output

Rows go to the default dataset. `RUN_SUMMARY` (key-value store) records mode, window, per-source status and counts, requests made, warnings and attribution lines.

# Actor input Schema

## `mode` (type: `string`):

search reads the last sinceDays days; new-since reads everything published on or after the date in since; alert returns only items your alertId has never been sent.

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

Which sources to read. Canada is opt-in and is not read unless you add it.

## `keywords` (type: `array`):

Every keyword must appear in the title, product, brand, hazard or category. Up to 200 entries.

## `kinds` (type: `array`):

Match any (substring) of the row kind, for example food recall, vehicle recall, medical device recall, allergy alert, field safety notices. Up to 200 entries.

## `brands` (type: `array`):

Match any (substring). Up to 200 entries.

## `categories` (type: `array`):

Match any (substring), for example toys or cosmetics. Up to 200 entries.

## `riskLevels` (type: `array`):

Match any (substring), for example serious or high. The wording differs by source. Up to 200 entries.

## `barcodes` (type: `array`):

Match any, up to 2,000 GTIN/EAN/UPC codes: digits only (spaces or hyphens allowed), 8 to 14 digits each; anything else is refused before the run starts. 12, 13 and 14-digit forms of one code match each other. Rows with no barcode never match.

## `countriesOfOrigin` (type: `array`):

Match any (Safety Gate rows only carry this). Up to 200 entries.

## `sinceDays` (type: `integer`):

How many days back to read, counted from today (1 to 400). Used by search and alert; new-since uses the since date instead.

## `since` (type: `string`):

Read everything published on or after this date (YYYY-MM-DD). Required for new-since mode; ignored otherwise unless you also set it for search.

## `alertId` (type: `string`):

Your name for this alert: 1 to 40 lower-case letters, digits or hyphens. The Actor remembers what it sent in a key-value store named recalls-alert-<alertId> in your account.

## `maxItems` (type: `integer`):

Rows are charged one by one; the run never returns more than this.

## Actor input object example

```json
{
  "mode": "search",
  "sources": [
    "opss",
    "fsa",
    "mhra",
    "safetygate"
  ],
  "sinceDays": 30,
  "maxItems": 20
}
```

# Actor output Schema

## `recalls` (type: `string`):

No description

## `runSummary` (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 = {
    "maxItems": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("yappman/uk-eu-recalls-feed").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 = { "maxItems": 20 }

# Run the Actor and wait for it to finish
run = client.actor("yappman/uk-eu-recalls-feed").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 '{
  "maxItems": 20
}' |
apify call yappman/uk-eu-recalls-feed --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,yappman/uk-eu-recalls-feed"
        }
    }
}
```

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/ywHeOJMXiyJHyMuYB/builds/hEOFDaW0Rd6h6l3e4/openapi.json
