# FDA Adverse Event Monitor (`sovereign_workspace/fda-adverse-event-monitor`) Actor

One event per new FDA adverse event report for the drugs or devices you watch: FAERS reports where your drug is the suspect drug, or MAUDE reports for your device, re-checked for precision. Public openFDA source.

- **URL**: https://apify.com/sovereign\_workspace/fda-adverse-event-monitor.md
- **Developed by:** [Chase Mariano](https://apify.com/sovereign_workspace) (community)
- **Stats:** 2 total users, 1 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $20.00 / 1,000 ae-matcheds

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

## FDA Adverse Event Monitor (FAERS / MAUDE)

One **record per new FDA adverse event report** for the drugs or medical
devices you watch. For drugs, that's FAERS reports where **your drug is
the suspect drug**, optionally narrowed to serious outcomes or specific
MedDRA reactions. For devices, it's MAUDE medical device reports (MDRs)
for your brand, manufacturer or FDA product code, optionally narrowed to
deaths, injuries or malfunctions. Built for pharmacovigilance, product
safety and post-market surveillance teams who need "tell me about new
reports on my products" as structured records for a signal-review or
complaint-trending pipeline, not a raw data dump.

**Pricing: pay per event.** `ae-matched`: one event per matched report
(not per reaction). A window with no matches costs you nothing.

**Precision is the point.** openFDA's own search matches a drug name
anywhere in a report's drug list. In a live check, of 100 hits for
"metformin, suspect drug", **only 33** actually had metformin as the
suspect drug; in the rest, metformin was a concomitant drug and something
else was suspect. This Actor re-checks every hit on **one drug** (name
and role together), or on **one device** (name, manufacturer and product
code together). A near-miss is skipped and never charged. With **Only
reports not delivered before** on (the default), a report is returned
and charged once per watch, even when scheduled windows overlap.

### Input

Serious FAERS reports where metformin is the suspect drug, looking back
180 days:

```json
{"source": "drug", "drug_names": ["metformin"], "serious_only": true,
 "since_days": 180}
```

Deaths or life-threatening outcomes with a specific reaction:

```json
{"source": "drug", "drug_names": ["metformin"],
 "outcomes": ["death", "life_threatening"], "reactions": ["Lactic acidosis"]}
```

MAUDE death and injury reports for a device product code:

```json
{"source": "device", "product_codes": ["LGW"],
 "event_types": ["death", "injury"], "since_days": 30}
```

**How the filters combine:**

- **Names** (drugs, devices, manufacturers) are whole-word,
  case-insensitive matches: `metformin` finds `METFORMIN HYDROCHLORIDE`
  and `SITAGLIPTIN AND METFORMIN`, but not `METFORMINX`.
- **Across fields:** different fields combine with AND.
- **Within a field:** entries combine with OR.
- **Reactions** are exact MedDRA preferred terms, in any case.

A drug watch needs at least one drug. A device watch needs at least one
device name, manufacturer or product code. Setting the other source's
list fields is refused, rather than silently ignored.

### Example output (one dataset item per report; narrative abridged)

```json
{"source": "device", "report_id": "50376410",
 "report_number": "3006630150-2026-06108", "report_version": null,
 "received_date": "2026-08-21", "latest_info_date": null,
 "event_date": "2026-07-28", "report_type": "Initial submission",
 "serious": null, "outcomes": ["Death"], "event_type": "Death",
 "reactions": ["No Clinical Signs, Symptoms or Conditions"],
 "product_problems": ["Adverse Event Without Identified Device or Use Problem"],
 "matched_products": [{"brand_name": "WaveWriter Alpha? 16",
   "generic_name": "STIMULATOR, SPINAL-CORD, TOTALLY IMPLANTED FOR PAIN RELIEF",
   "manufacturer": "BOSTON SCIENTIFIC NEUROMODULATION CORPORATION",
   "product_code": "LGW",
   "device_name": "Stimulator, Spinal-Cord, Totally Implanted For Pain Relief",
   "device_class": "3", "model_number": "SC-1216"}],
 "suspect_products": [], "reporter_type": "Other", "reporter_country": "US",
 "patient_sex": "Male", "patient_age": "90 YR",
 "narrative": "It was reported that a spinal cord stimulation (SCS) patient passed away. …",
 "data_updated": "2026-09-08"}
```

FAERS items have the same fields:

- `matched_products` holds the matched drug (name, role, active
  substance, brand and generic names, indication);
- `suspect_products` lists every suspect drug in the report;
- `serious`, `outcomes`, `reactions` (MedDRA terms), `reporter_type` and
  `latest_info_date` are filled;
- the device-only fields are null or `[]`.

### Output fields

One dataset item per result. Every field is always present (empty or
null when the source has no value). Defined in
`.actor/dataset_schema.json`.

| Field | Type | Description |
|---|---|---|
| `source` | string | `drug` (FAERS) or `device` (MAUDE) |
| `report_id` | string | FAERS `safetyreportid` or MAUDE `mdr_report_key` |
| `report_number` | string or null | Manufacturer/company report number |
| `report_version` | string or null | FAERS report version (null for MAUDE) |
| `received_date` | string or null | Date FDA first received the report, YYYY-MM-DD |
| `latest_info_date` | string or null | FAERS: date the most recent information arrived |
| `event_date` | string or null | MAUDE: date of the event |
| `report_type` | string or null | FAERS report type (e.g. Spontaneous) or MAUDE type of report |
| `serious` | boolean or null | FAERS seriousness flag |
| `outcomes` | array | FAERS serious outcomes, or MAUDE patient outcomes |
| `event_type` | string or null | MAUDE: Death, Injury, Malfunction or Other |
| `reactions` | array | FAERS MedDRA reaction terms, or MAUDE patient problems |
| `product_problems` | array | MAUDE device problems |
| `matched_products` | array | The drug(s) or device(s) in the report that matched your watch |
| `suspect_products` | array | FAERS: every drug listed as suspect in the report |
| `reporter_type` | string or null | FAERS reporter qualification, or MAUDE report source |
| `reporter_country` | string or null | Reporter country code |
| `patient_sex` | string or null | Patient sex as reported |
| `patient_age` | string or null | Patient age as reported, with unit |
| `narrative` | string or null | MAUDE event description (max 1000 characters) |
| `data_updated` | string or null | openFDA's last update of this dataset, YYYY-MM-DD |

Runs stop cleanly at your max-charge limit: nothing is pushed past what
you agreed to pay for.

### Coverage and freshness

- **FAERS (drugs)** loads **quarterly**. openFDA's docs: the data "may
  lag by 3 months or more". On 2026-09-23 the newest report was received
  on 2026-06-30 (openFDA updated 2026-07-30). **Drug watches need a
  window of 120 days or more** (the default is 120). New reports then
  arrive in quarterly batches, and "only new" stops a batch being charged
  twice. A **weekly or monthly schedule** is enough for drugs;
  daily runs find nothing new between quarterly loads.
- **MAUDE (devices)** loads **weekly**. On 2026-09-23 the newest report
  was received on 2026-08-31 (openFDA updated 2026-09-08).
- **Window date:** the date FDA *first* received the report (FAERS
  `receivedate`, MAUDE `date_received`). A FAERS follow-up to an old
  report isn't a new report.
- **One event per report,** however many reactions or devices it lists.
- **No report links:** FDA's MAUDE report pages refuse scripted requests,
  so items carry the report ID and number but no link.

**Responsible use (openFDA, verbatim):** "Adverse event reports submitted
to FDA do not undergo extensive validation or verification. Therefore, a
causal relationship cannot be established between product and reactions
listed in a report." FAERS: "There is no certainty that the reported
event … was actually due to the product." A report is a signal to
review, not evidence of harm.

Source: the openFDA drug/event and device/event APIs (public, CC0).
Without a key, openFDA allows 1,000 requests per day per IP address, and
Apify IPs are shared, so heavy schedules should add a free openFDA API
key. openFDA's disclaimer: "Do not rely on openFDA to make decisions
regarding medical care." This Actor isn't affiliated with or endorsed by
the FDA. Also see the
[FDA Recall Monitor](https://apify.com/sovereign_workspace/openfda-recall-monitor)
for drug, food and device recalls. The FDA 510(k) / PMA Clearance Monitor,
Drugs@FDA lookup and device establishment lookup cover approvals and
registrations.

# Actor input Schema

## `profile` (type: `string`):

Named config preset applied at start. Any field you set explicitly below overrides the preset.

## `source` (type: `string`):

Which FDA adverse event database to watch. FAERS (drugs) loads quarterly and lags about 3 months; MAUDE (devices) loads weekly.

## `drug_names` (type: `array`):

Brand, generic or active-ingredient names to watch, e.g. metformin, Humira. Whole-word match on one drug in the report. Required for the drug source.

## `suspect_only` (type: `boolean`):

FAERS: count a report only when the watched drug itself is listed as the suspect drug, not a concomitant one. Turn off to include concomitant and interacting roles.

## `serious_only` (type: `boolean`):

FAERS: only reports FDA flags as serious (death, life-threatening, hospitalization, disability, congenital anomaly or other serious).

## `outcomes` (type: `array`):

FAERS: only reports with at least one of these outcomes: death, life\_threatening, hospitalization, disabling, congenital\_anomaly, other\_serious.

## `reactions` (type: `array`):

FAERS: only reports listing at least one of these MedDRA preferred terms, exact term, any case, e.g. Lactic acidosis.

## `device_names` (type: `array`):

Brand or generic device names to watch, e.g. Vanta. Whole-word match on one device in the report.

## `manufacturers` (type: `array`):

Device manufacturer names, e.g. Medtronic. Whole-word match on the same device as the other device filters.

## `product_codes` (type: `array`):

Three-letter FDA device product codes, e.g. LGW. For the device source give at least one of devices, manufacturers or product codes.

## `event_types` (type: `array`):

MAUDE: only reports of these event types: death, injury, malfunction, other.

## `since_days` (type: `integer`):

How many days back to look, by the date FDA first received the report. FAERS data lags about 3 months, so drug watches need a window of 120 days or more.

## `only_new` (type: `boolean`):

For scheduled watches: never return (or charge) a report this same watch already returned. Kept in a named key-value store in your account.

## `limit` (type: `integer`):

Maximum number of matched reports to return per run.

## `api_key` (type: `string`):

Optional free openFDA key. Without one, openFDA allows 1,000 requests per day per IP, and Apify IPs are shared.

## Actor input object example

```json
{
  "source": "drug",
  "suspect_only": true,
  "serious_only": false,
  "since_days": 120,
  "only_new": true,
  "limit": 100
}
```

# Actor output Schema

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

No description

## `errorCounters` (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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("sovereign_workspace/fda-adverse-event-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 = {}

# Run the Actor and wait for it to finish
run = client.actor("sovereign_workspace/fda-adverse-event-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 '{}' |
apify call sovereign_workspace/fda-adverse-event-monitor --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,sovereign_workspace/fda-adverse-event-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/pknkXV18ezjjJvxnn/builds/Iq9LnNlbla2bHbeDr/openapi.json