# EU RASFF Food & Feed Safety Alert Monitor (`codeclouds/eu-rasff-food-safety-alert-monitor`) Actor

Monitors EU RASFF food and feed safety alerts via the official EC backend. Filter by product category, origin or notifying country, risk decision or date. No API key — English JSON output for importers, retailers, compliance and AI agents.

- **URL**: https://apify.com/codeclouds/eu-rasff-food-safety-alert-monitor.md
- **Developed by:** [Dennis](https://apify.com/codeclouds) (community)
- **Categories:** Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 notificatie 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

## EU RASFF Food & Feed Safety Alert Monitor

The EU Rapid Alert System for Food and Feed (RASFF) is the official European Commission mechanism for food safety notifications — alerts, information notices and border rejections — updated daily. This Actor connects directly to the RASFF Window backend endpoint (`https://webgate.ec.europa.eu/rasff-window/backend/public/notification/search/consolidated/en/`), which serves the same structured JSON used by the public RASFF portal. No API key, no registration and no scraping are required: a single POST request returns the full notification list with pagination. The Actor filters results by product category, notifying or origin country, risk decision, notification classification or date range, then delivers clean, normalized JSON records for compliance monitoring and supply-chain risk tracking.

### When should an AI agent use this?

- "Show me all RASFF alerts from Sweden in the last 30 days that involve crustaceans."
- "What serious-risk food notifications originated from Iraq this week?"
- "List all published RASFF information notifications for 'other food product / mixed' since September 1."
- "Give me a CSV-ready dataset of EU food safety alerts with serious risk decisions."
- "Compare the number of border-rejection notifications per notifying country for this quarter."
- "Generate a compliance brief: any RASFF alert mentioning peanuts in products from Ecuador."

### What this Actor does

- Queries the official EC RASFF backend endpoint with pagination (up to 10,000+ pages / 32,500+ notifications observed in live tests).
- Normalizes each notification into a flat JSON record with consistent field names (reference, validation date, notifying country, origin countries, product category, risk decision, classification, published flag).
- Applies optional client-side filters: free-text search on subject, product category match, notifying or origin country (ISO), risk decision label, notification classification label, and date range on `ecValidationDate`.
- Respects the observed rate limit (`X-Rate-Limit-Remaining: 49` after first call) by using a conservative page size (50 items) and sequential page fetching.
- Charges one PPE event (`notificatie-record`) per returned notification, plus the standard Apify start fee.
- Includes a built-in safety cap (max 100 pages / ~5,000 raw items) to prevent runaway runs.

### Input

| Field | Type | Description |
|---|---|---|
| `query` | string | Free text filter on notification `subject`. Optional. |
| `productCategory` | string | Filter by `productCategory` description, e.g. `crustaceans and products thereof`. Optional. |
| `notifyingCountry` | string | ISO code of notifying country, e.g. `SE`, `EE`. Optional. |
| `originCountry` | string | ISO code of origin country, e.g. `IQ`, `EC`. Optional. |
| `riskDecision` | select | Filter by risk decision: `serious`, `not serious`, `potential risk`, `not decided`. Optional. |
| `notificationClassification` | string | Filter by classification description, e.g. `alert notification`, `information notification for attention`. Optional. |
| `dateFrom` | datepicker | Start date (`YYYY-MM-DD`) for `ecValidationDate`. Optional. |
| `dateTo` | datepicker | End date (`YYYY-MM-DD`) for `ecValidationDate`. Optional. |
| `maxResults` | number | Maximum notifications to return. Default 200, max 1000. |

### Output

```json
{
  "notifId": 873975,
  "reference": "2026.8325",
  "ecValidationDate": "19-09-2026 08:40:55",
  "subject": "Undeclared allergens sesame and peanuts in tahini halva",
  "published": false,
  "notifyingCountry": "Sweden",
  "originCountries": ["Iraq"],
  "productCategory": "other food product / mixed",
  "productType": "food",
  "notificationClassification": "alert notification",
  "riskDecision": "serious"
}
```

### Use cases

- **Food importers and retailers**: monitor whether products or suppliers from specific countries appear in new RASFF alerts, with serious-risk filtering.
- **Compliance and QA teams**: build recurring audits (scheduled runs) of notifications in specific product categories, with output exported to CSV or fed into internal dashboards.
- **Risk analysts**: aggregate notifications by notifying country, risk level or publication status to identify emerging hazard patterns.
- **AI agents**: answer natural-language questions about EU food safety events using the normalized JSON output, without parsing the official portal manually.

### Pricing

This Actor uses Apify's Pay-Per-Event (PPE) pricing model.

- **Actor Start:** $0.00005 (Apify default, charged once per run)
- **Notificatie-record:** $0.003 per returned notification (PPE event `notificatie-record`)
- No charge for filtered results: only notifications that pass the input filters are pushed to the dataset and charged.
- The live RASFF endpoint has no usage fee; cost is purely Apify compute + PPE events.

### Legal

- **Data source**: EU RASFF Window backend endpoint (`https://webgate.ec.europa.eu/rasff-window/backend/public/notification/search/consolidated/en/`). This is a discovered (not officially documented) internal API used by the public RASFF portal. It requires no authentication and returns public food-safety data.
- **Legal basis**: Public EU transparency data (low risk per INSTRUCTIE.txt sectie 3). The Actor delivers factual notification records with no advisory interpretation or risk judgment.
- **Disclaimer**: The Actor mirrors RASFF Window content. The EC's official RASFF portal remains the authoritative source; any discrepancy should be resolved against the EC's published records. The endpoint could change without notice (breaking-change risk noted in scope).
- **No personal data**: Notifications contain product categories, countries, hazard descriptions and risk classifications. They do not include individual names, addresses or health records.

### Related Actors

- **[Safety Gate Scraper — EU Product Safety Alerts (RAPEX)](https://apify.com/studio-amba/safetygate-scraper)** — related EU transparency source for non-food product safety (RAPEX), same backend-pattern family.

### Keywords

EU, RASFF, food safety, feed safety, rapid alert, food recall, alert notification, EU transparency, food compliance, hazard monitoring, border rejection, food import, supply chain risk, compliance audit, EC backend, notification feed, open data, EU regulation, consumer protection.

### Changelog

#### 0.1.0

- Initial release: RASFF backend endpoint integration, pagination, client-side filtering (category, country, risk, date), normalized output schema, PPE event `notificatie-record`, English-language README and Store metadata.
- Concurrentie-check bevestigd: 2 bestaande RASFF-actors op Apify Store (`scrapers_lat/eu-rasff-food-alerts-scraper`: 2 users, 48 runs; `promptica/rasff-food-alerts`: 2 users, 67 runs) — laag concurrentieniveau, ruimte voor deze variant.
- Technisch GO bevestigd: live endpoint respondeert consistent (200, JSON, `X-Rate-Limit-Remaining` aanwezig, 32.597+ notificaties in live test 2026-09-20).

# Actor input Schema

## `query` (type: `string`):

Free text filter on notification subject (optional).

## `productCategory` (type: `string`):

Filter by product category description, e.g. 'crustaceans and products thereof'. Optional.

## `notifyingCountry` (type: `string`):

ISO country code of the notifying country, e.g. 'SE', 'EE'. Optional.

## `originCountry` (type: `string`):

ISO country code of origin country, e.g. 'IQ', 'EC'. Optional.

## `riskDecision` (type: `string`):

Filter by risk decision, e.g. 'serious', 'not serious', 'potential risk'. Optional.

## `notificationClassification` (type: `string`):

Filter by classification, e.g. 'alert notification', 'information notification for attention'. Optional.

## `dateFrom` (type: `string`):

Start date for ecValidationDate filter (YYYY-MM-DD). Optional.

## `dateTo` (type: `string`):

End date for ecValidationDate filter (YYYY-MM-DD). Optional.

## `maxResults` (type: `integer`):

Maximum number of notifications to return.

## Actor input object example

```json
{
  "maxResults": 50
}
```

# Actor output Schema

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

Notification records stored in the default dataset.

# 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 = {
    "maxResults": 50
};

// Run the Actor and wait for it to finish
const run = await client.actor("codeclouds/eu-rasff-food-safety-alert-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 = { "maxResults": 50 }

# Run the Actor and wait for it to finish
run = client.actor("codeclouds/eu-rasff-food-safety-alert-monitor").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 '{
  "maxResults": 50
}' |
apify call codeclouds/eu-rasff-food-safety-alert-monitor --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,codeclouds/eu-rasff-food-safety-alert-monitor"
        }
    }
}
```

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/Kj1xDjLJBTrNqgQ6c/builds/odMvM9uxhluwDJEsy/openapi.json