# EU Car Recall Check & Monitor (Safety Gate) (`jyaussie/eu-vehicle-recall-monitor`) Actor

EU car recalls check and recall monitor: search official EU Safety Gate recalls for cars, vans, trucks and motorcycles by make, model, production year and date. 6,400+ alerts since 2005, updated weekly, clean English output. Schedule it to get only new recalls.

- **URL**: https://apify.com/jyaussie/eu-vehicle-recall-monitor.md
- **Developed by:** [Car Helper Tools](https://apify.com/jyaussie) (community)
- **Categories:** Business, E-commerce
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$5.00 / 1,000 vehicle recall alerts

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 Car Recall Monitor: official Safety Gate recalls for cars, vans, trucks & motorcycles

**Is this car, van or motorbike under an EU safety recall?** Search **6,400+ official EU Safety Gate motor-vehicle alerts (2005 to this week)** by **make, model, production year, date, country or risk**, or schedule it to get **only new recalls** for the makes you care about. Clean, English, structured output, ready for spreadsheets, CRMs, dealer systems and AI agents.

Other Safety Gate scrapers cover every product category (toys, cosmetics, chargers...). This Actor is built **only for vehicles**:

- **Make normalisation**: `VW` = `Volkswagen`, `Opel/Vauxhall` is split into both makes, `Mercedes- Benz` / `MERCEDES` = `Mercedes-Benz`, `Citroën` = `Citroen`.
- **Model lists**: "Astra, Corsa, Combo, Vivaro" becomes `["Astra","Corsa","Combo","Vivaro"]`.
- **Production window**: messy production dates are parsed into `productionFrom`, `productionTo` and `affectedProductionYears`, so you can ask "recalls for a **2018** Toyota Yaris".
- **Measures parsed**: who acted (manufacturer, importer, authority), what (recall from end users, withdrawal...) and when.
- **Fast and cheap**: the full archive is pre-built into the Actor, and only the newest weekly reports are fetched live. A typical run takes a few seconds on 256 MB.

### Who it's for

Used-car dealers and importers (e.g. checking EU imports), fleet managers, garages, insurers, leasing companies, car marketplaces, journalists and car-content sites.

### Input

| Field | Example | Notes |
|---|---|---|
| `makes` | `["Volkswagen","Skoda"]` | Empty = all makes |
| `models` | `["Golf"]` | Matched in model, type and description text |
| `productionYear` | `2018` | Keeps alerts whose production window covers this year (alerts without dates are kept) |
| `publishedFrom` / `publishedTo` | `2025-01-01` | Alert publication date |
| `keyword` | `airbag`, `Takata`, `fire` | Free text |
| `vehicleTypes` | `["Motorcycle"]` | Passenger car, Light commercial vehicle, Bus, Truck, Quad... |
| `notifyingCountries` | `["Germany"]` | English names |
| `riskTypes` | `["Fire"]` | Injuries, Fire, Burns, Environment... |
| `seriousRiskOnly` | `true` | |
| `onlyNewSinceLastRun` | `true` | **Monitor mode** for scheduled runs |
| `maxResults` | `100` | Newest first |

```json
{ "makes": ["Toyota"], "models": ["Yaris"], "productionYear": 2018 }
```

#### Monitor mode

Turn on `onlyNewSinceLastRun` and add a schedule (e.g. every Friday after the weekly report). Each run returns only alerts you have not received with the same filters, so you can wire it to email, Slack or a webhook. You pay nothing when there is nothing new.

### Example output (one row, shortened)

Real data, October 2026 build:

```json
{
  "alertNumber": "SR/01050/26",
  "publicationDate": "2026-04-10",
  "makes": ["Opel", "Vauxhall"],
  "models": ["Astra", "Corsa", "Combo", "Vivaro"],
  "vehicleType": "Passenger car / Passenger van",
  "productionFrom": "2025-10-15",
  "productionTo": "2026-02-28",
  "affectedProductionYears": [2025, 2026],
  "companyRecallCode": "KWF",
  "riskTypes": ["Injuries"],
  "riskLevel": "Serious risk",
  "hazard": "The DV5R engine may experience a loss of power due to slippage of the water pump pulley...",
  "measureTakenBy": "Manufacturer",
  "measure": "Recall of the product from end users",
  "measureDate": "2026-03-11",
  "notifyingCountry": "France",
  "alertUrl": "https://ec.europa.eu/safety-gate-alerts/screen/webReport/alertDetail/10098428",
  "sourceAttribution": "Alerts from the Rapid Alert System for dangerous non-food products, published free of charge on the Safety Gate website (https://ec.europa.eu/safety-gate-alerts) © European Union, 2005-2026",
  "language": "en"
}
```

A run summary is saved as `SUMMARY` in the key-value store.

### Use with AI agents (MCP)

Connect this Actor to Claude, ChatGPT, Cursor or any MCP client with Apify's hosted MCP server:

`https://mcp.apify.com/?tools=jyaussie/eu-vehicle-recall-monitor`

Example prompts:

- "Are there EU recalls for a 2016 Ford Focus?"
- "List serious-risk airbag recalls in the EU this year."
- "Show new Toyota recalls since my last check."

### Weekly recall monitor (scheduling)

Create an Apify Schedule (e.g. every Monday) with your makes/models and `"onlyNewSinceLastRun": true`. Each run returns only recalls you have not seen before, so you pay only for new alerts.

### Pricing

Pay per event: **$0.005 per alert returned** ($5 per 1,000). No start fee. If nothing matches, you pay nothing. No platform usage fees.

### Data source, licence & disclaimer

- Data: the official **EU Safety Gate** weekly reports (public XML exports). Reuse is authorised by the European Commission provided the meaning is not distorted and the source is acknowledged; every row carries the required acknowledgement in `sourceAttribution`. Output is in **English**, the original language of the alerts.
- This Actor is **not affiliated with or endorsed by the European Commission**. The Commission is not liable for the accuracy of information supplied by national authorities.
- Safety Gate lists alerts notified by EU/EEA authorities. Not every manufacturer recall appears there, so **no result does not prove a vehicle is recall-free**. Always confirm with the manufacturer or an authorised dealer using the VIN.
- Fields such as `productionFrom` and `makes` are derived by parsing the official text; the original text is kept in the `...AsPublished` fields.
- No personal data: alerts describe products and companies only.

# Actor input Schema

## `makes` (type: `array`):

Car, van, truck or motorcycle makes, e.g. Toyota, Volkswagen, Mercedes-Benz. Aliases like VW work. Leave empty for all makes.

## `models` (type: `array`):

Model names, e.g. Yaris, Golf, Corsa. Matched against the model, type and description text. Leave empty for all models.

## `productionYear` (type: `integer`):

Only alerts whose production window includes this year. Alerts with no production dates are kept.

## `publishedFrom` (type: `string`):

Only alerts published on or after this date.

## `publishedTo` (type: `string`):

Only alerts published on or before this date.

## `keyword` (type: `string`):

Free text, e.g. airbag, brake, Takata, battery fire.

## `vehicleTypes` (type: `array`):

e.g. Passenger car, Motorcycle, Light commercial vehicle, Bus, Truck, Quad. Partial match.

## `notifyingCountries` (type: `array`):

English country names, e.g. Germany, France, Cyprus.

## `riskTypes` (type: `array`):

e.g. Injuries, Fire, Burns, Environment.

## `seriousRiskOnly` (type: `boolean`):

Keep only alerts marked 'Serious risk'.

## `onlyNewSinceLastRun` (type: `boolean`):

Schedule the Actor and get only alerts you have not seen with the same filters. State is kept in a named key-value store in your account.

## `refreshLatest` (type: `boolean`):

Adds any weekly reports published after the bundled archive was built.

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

Newest first. You pay only for alerts returned.

## Actor input object example

```json
{
  "makes": [
    "Toyota"
  ],
  "models": [
    "Yaris"
  ],
  "seriousRiskOnly": false,
  "onlyNewSinceLastRun": false,
  "refreshLatest": true,
  "maxResults": 100
}
```

# Actor output Schema

## `overview` (type: `string`):

Default dataset, overview view.

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

Counts and filters used.

# 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 = {
    "makes": [
        "Toyota"
    ],
    "models": [
        "Yaris"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("jyaussie/eu-vehicle-recall-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 = {
    "makes": ["Toyota"],
    "models": ["Yaris"],
}

# Run the Actor and wait for it to finish
run = client.actor("jyaussie/eu-vehicle-recall-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 '{
  "makes": [
    "Toyota"
  ],
  "models": [
    "Yaris"
  ]
}' |
apify call jyaussie/eu-vehicle-recall-monitor --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,jyaussie/eu-vehicle-recall-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/xRx904R4yeUgNobS1/builds/oNgvQYxcn7YlzAxde/openapi.json